From 2b6a72914d522280b0900552a10ee1092ad7639b Mon Sep 17 00:00:00 2001 From: PengPengPeng717 <872462877.com> Date: Thu, 21 Aug 2025 17:38:29 +0800 Subject: [PATCH 1/5] CI --- .github/workflows/issueclose.yml | 12 +- .github/workflows/labelcreate.yml | 62 ++++---- .github/workflows/postprocessing.yml | 224 +++++++++++++-------------- .github/workflows/verification.yml | 71 +++++---- 4 files changed, 186 insertions(+), 183 deletions(-) diff --git a/.github/workflows/issueclose.yml b/.github/workflows/issueclose.yml index cbacdda8..51358339 100644 --- a/.github/workflows/issueclose.yml +++ b/.github/workflows/issueclose.yml @@ -18,9 +18,9 @@ jobs: uses: actions/setup-go@v4 with: go-version: 1.23.x - - name: Set up Tool - run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest - - name: Run cleaner process - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: llpkgstore issueclose + # - name: Set up Tool + # run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest + # - name: Run cleaner process + # env: + # GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + # run: llpkgstore issueclose diff --git a/.github/workflows/labelcreate.yml b/.github/workflows/labelcreate.yml index ddd7826d..ea99f37c 100644 --- a/.github/workflows/labelcreate.yml +++ b/.github/workflows/labelcreate.yml @@ -11,34 +11,34 @@ on: jobs: maintenance: runs-on: ubuntu-latest - if: startsWith(github.event.label.name, 'branch:release-branch.') - steps: - - name: Checkout to website - uses: actions/checkout@v4 - with: - ref: website - path: .website - - name: Checkout - uses: actions/checkout@v4 - with: - ref: main - path: .main - fetch-depth: 0 - - name: Set up Go - uses: actions/setup-go@v4 - with: - go-version: 1.23.x - - name: Set up Tool - run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest - - name: Copy llpkgstore.json to root - continue-on-error: true - run: | - # ignore error - ls .website .website/public - cp .website/public/llpkgstore.json .main - rm -rf .website - - name: Run maintenance process - working-directory: .main - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: llpkgstore labelcreate -l "${{ github.event.label.name }}" + # if: startsWith(github.event.label.name, 'branch:release-branch.') + # steps: + # - name: Checkout to website + # uses: actions/checkout@v4 + # with: + # ref: website + # path: .website + # - name: Checkout + # uses: actions/checkout@v4 + # with: + # ref: main + # path: .main + # fetch-depth: 0 + # - name: Set up Go + # uses: actions/setup-go@v4 + # with: + # go-version: 1.23.x + # - name: Set up Tool + # run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest + # - name: Copy llpkgstore.json to root + # continue-on-error: true + # run: | + # # ignore error + # ls .website .website/public + # cp .website/public/llpkgstore.json .main + # rm -rf .website + # - name: Run maintenance process + # working-directory: .main + # env: + # GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + # run: llpkgstore labelcreate -l "${{ github.event.label.name }}" diff --git a/.github/workflows/postprocessing.yml b/.github/workflows/postprocessing.yml index dccb945b..ca14fe21 100644 --- a/.github/workflows/postprocessing.yml +++ b/.github/workflows/postprocessing.yml @@ -23,119 +23,119 @@ jobs: matrix: os: - macos-13 - - macos-latest - - ubuntu-24.04 - - ubuntu-24.04-arm + # - macos-latest + # - ubuntu-24.04 + # - ubuntu-24.04-arm runs-on: ${{matrix.os}} - steps: - - name: Checkout - uses: actions/checkout@v4 - - name: Set up Go - uses: actions/setup-go@v4 - with: - go-version: 1.23.x - - name: Set up Tool - run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest - - name: Install dependencies - if: startsWith(matrix.os, 'macos') - run: | - brew update - brew install cmake conan cjson - - name: Install dependencies - if: startsWith(matrix.os, 'ubuntu') - run: | - sudo apt-get update - sudo apt-get install -y cmake python3 python3-pip pkg-config - python3 -m pip install conan - - name: Set up Conan - run: conan profile detect - - name: Run release process - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: llpkgstore release - - name: Upload binary file to artifact - uses: actions/upload-artifact@v4 - with: - name: ${{env.BIN_FILENAME}} - path: ${{env.BIN_PATH}} - retention-days: 1 - post-processing: - runs-on: ubuntu-latest - needs: [release-binary-files] - steps: - - name: Checkout - uses: actions/checkout@v4 - with: - ref: main - path: .main - - name: Set up Go - uses: actions/setup-go@v4 - with: - go-version: 1.23.x - - name: Set up Tool - run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest - - name: Checkout to website - uses: actions/checkout@v4 - with: - ref: website - path: .website - - name: Copy llpkgstore.json to root - continue-on-error: true - run: | - ls .website .website/public - cp .website/public/llpkgstore.json .main - rm -rf .website - - name: Run post-processing process - working-directory: .main - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: llpkgstore postprocessing - - name: Checkout website branch - uses: actions/checkout@v4 - with: - ref: website - path: .website - - name: Move llpkgstore.json to website - run: mv .main/llpkgstore.json .website/public - - name: Commit and push changes - working-directory: .website - run: | - git config --local user.email "action@github.com" - git config --local user.name "GitHub Action" - git add public/llpkgstore.json - git commit -m "Update llpkgstore.json" - git push - build-and-upload: - runs-on: ubuntu-latest - needs: [post-processing] - steps: - - name: Checkout code - uses: actions/checkout@v4 - with: - ref: website - - name: Setup Node.js - uses: actions/setup-node@v3 - with: - node-version: 23.8.0 - - run: corepack enable - - name: Install Dependencies - uses: borales/actions-yarn@v4 - with: - cmd: install - - name: Build - uses: borales/actions-yarn@v4 - with: - cmd: build - - name: Upload artifact - uses: actions/upload-pages-artifact@v3 - with: - path: 'dist' - deploy: - needs: build-and-upload - runs-on: ubuntu-latest - permissions: - pages: write - id-token: write + # steps: + # - name: Checkout + # uses: actions/checkout@v4 + # - name: Set up Go + # uses: actions/setup-go@v4 + # with: + # go-version: 1.23.x + # - name: Set up Tool + # run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest + # - name: Install dependencies + # if: startsWith(matrix.os, 'macos') + # run: | + # brew update + # brew install cmake conan cjson + # - name: Install dependencies + # if: startsWith(matrix.os, 'ubuntu') + # run: | + # sudo apt-get update + # sudo apt-get install -y cmake python3 python3-pip pkg-config + # python3 -m pip install conan + # - name: Set up Conan + # run: conan profile detect + # - name: Run release process + # env: + # GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + # run: llpkgstore release + # - name: Upload binary file to artifact + # uses: actions/upload-artifact@v4 + # with: + # name: ${{env.BIN_FILENAME}} + # path: ${{env.BIN_PATH}} + # retention-days: 1 + # post-processing: + # runs-on: ubuntu-latest + # needs: [release-binary-files] + # steps: + # - name: Checkout + # uses: actions/checkout@v4 + # with: + # ref: main + # path: .main + # - name: Set up Go + # uses: actions/setup-go@v4 + # with: + # go-version: 1.23.x + # - name: Set up Tool + # run: go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest + # - name: Checkout to website + # uses: actions/checkout@v4 + # with: + # ref: website + # path: .website + # - name: Copy llpkgstore.json to root + # continue-on-error: true + # run: | + # ls .website .website/public + # cp .website/public/llpkgstore.json .main + # rm -rf .website + # - name: Run post-processing process + # working-directory: .main + # env: + # GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + # run: llpkgstore postprocessing + # - name: Checkout website branch + # uses: actions/checkout@v4 + # with: + # ref: website + # path: .website + # - name: Move llpkgstore.json to website + # run: mv .main/llpkgstore.json .website/public + # - name: Commit and push changes + # working-directory: .website + # run: | + # git config --local user.email "action@github.com" + # git config --local user.name "GitHub Action" + # git add public/llpkgstore.json + # git commit -m "Update llpkgstore.json" + # git push + # build-and-upload: + # runs-on: ubuntu-latest + # needs: [post-processing] + # steps: + # - name: Checkout code + # uses: actions/checkout@v4 + # with: + # ref: website + # - name: Setup Node.js + # uses: actions/setup-node@v3 + # with: + # node-version: 23.8.0 + # - run: corepack enable + # - name: Install Dependencies + # uses: borales/actions-yarn@v4 + # with: + # cmd: install + # - name: Build + # uses: borales/actions-yarn@v4 + # with: + # cmd: build + # - name: Upload artifact + # uses: actions/upload-pages-artifact@v3 + # with: + # path: 'dist' + # deploy: + # needs: build-and-upload + # runs-on: ubuntu-latest + # permissions: + # pages: write + # id-token: write steps: - name: Deploy to GitHub Pages id: deployment diff --git a/.github/workflows/verification.yml b/.github/workflows/verification.yml index c4021ab1..9eeffa79 100644 --- a/.github/workflows/verification.yml +++ b/.github/workflows/verification.yml @@ -34,7 +34,7 @@ jobs: with: repository: '1351914167/llgo' path: .llgo - ref: presentation + ref: get_pip - name: Check out LLPyg uses: actions/checkout@v4 with: @@ -47,7 +47,7 @@ jobs: go-version: 1.24.x - name: Set up Tool run: | - go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest + go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@8_21 - name: Install dependencies if: startsWith(matrix.os, 'macos') run: | @@ -55,27 +55,27 @@ jobs: brew link --force libffi echo "$(brew --prefix llvm@${{matrix.llvm}})/bin" >> $GITHUB_PATH echo "$(brew --prefix lld@${{matrix.llvm}})/bin" >> $GITHUB_PATH - - name: Install dependencies - if: startsWith(matrix.os, 'ubuntu') - run: | - sudo apt-get update - echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{matrix.llvm}} main" | sudo tee /etc/apt/sources.list.d/llvm.list - wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add - - sudo apt-get install -y llvm-${{matrix.llvm}}-dev \ - clang-${{matrix.llvm}} \ - libclang-${{matrix.llvm}}-dev \ - lld-${{matrix.llvm}} \ - libunwind-${{matrix.llvm}}-dev \ - libc++-${{matrix.llvm}}-dev \ - pkg-config libgc-dev libssl-dev zlib1g-dev libffi-dev libuv1-dev - echo "/usr/lib/llvm-${{matrix.llvm}}/bin" >> $GITHUB_PATH - - name: Pre setup Python and Conan - if: startsWith(matrix.os, 'ubuntu') - run: | - sudo apt install -y python3 python3-pip - python3 -m pip install --upgrade pip - # python3 -m pip install conan pydump - # go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1 + # - name: Install dependencies + # if: startsWith(matrix.os, 'ubuntu') + # run: | + # sudo apt-get update + # echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{matrix.llvm}} main" | sudo tee /etc/apt/sources.list.d/llvm.list + # wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add - + # sudo apt-get install -y llvm-${{matrix.llvm}}-dev \ + # clang-${{matrix.llvm}} \ + # libclang-${{matrix.llvm}}-dev \ + # lld-${{matrix.llvm}} \ + # libunwind-${{matrix.llvm}}-dev \ + # libc++-${{matrix.llvm}}-dev \ + # pkg-config libgc-dev libssl-dev zlib1g-dev libffi-dev libuv1-dev + # echo "/usr/lib/llvm-${{matrix.llvm}}/bin" >> $GITHUB_PATH + # - name: Pre setup Python and Conan + # if: startsWith(matrix.os, 'ubuntu') + # run: | + # sudo apt install -y python3 python3-pip + # python3 -m pip install --upgrade pip + # # python3 -m pip install conan pydump + # # go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1 - name: Pre setup Python and Conan if: startsWith(matrix.os, 'macos') run: | @@ -87,9 +87,12 @@ jobs: - name: Setup LLGo working-directory: .llgo run: | - ./install.sh - export LLGO_ROOT=$(pwd) + go install -v ./cmd/... + export LLGO_ROOT=$PWD echo "LLGO_ROOT=$LLGO_ROOT" >> $GITHUB_ENV + # ./install.sh + # export LLGO_ROOT=$(pwd) + # echo "LLGO_ROOT=$LLGO_ROOT" >> $GITHUB_ENV # https://github.com/goplus/llgo/issues/1135 echo "LLGO_RPATH_CHANGE=ON" >> $GITHUB_ENV - name: Set up Python environment @@ -147,15 +150,15 @@ jobs: # Test llpyg with numpy as per guide llpyg numpy echo "llpyg generation completed successfully" - # - name: Verification & Prebuilt - # env: - # GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - # ALL_CHANGED_FILES: ${{ steps.changed-files.outputs.all_changed_files || 'numpy/llpkg.cfg numpy/llpyg.cfg' }} - # run: llpkgstore verification - # - name: Run demotest process - # env: - # LLPKG_PATH: ${{ env.LLPKG_PATH }} - # run: llpkgstore demotest + - name: Verification & Prebuilt + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + ALL_CHANGED_FILES: ${{ steps.changed-files.outputs.all_changed_files || 'numpy/llpkg.cfg numpy/llpyg.cfg' }} + run: llpkgstore verification + - name: Run demotest process + env: + LLPKG_PATH: ${{ env.LLPKG_PATH }} + run: llpkgstore demotest - name: Create Git tag run: | echo "Creating Git tag: numpy/v0.1.0" From 789ace4b9fb69455ac2afa6775e5de105a518868 Mon Sep 17 00:00:00 2001 From: PengPengPeng717 <872462877.com> Date: Fri, 22 Aug 2025 16:38:44 +0800 Subject: [PATCH 2/5] release numpy@v1.26.4 --- numpy/_demo/basic_test/main.go | 27 + numpy/go.mod | 2 +- numpy/llpkg.cfg | 15 + numpy/llpyg.cfg | 1 - numpy/numpy.go | 40672 +++++++++++++++---------------- 5 files changed, 20147 insertions(+), 20570 deletions(-) create mode 100644 numpy/_demo/basic_test/main.go create mode 100644 numpy/llpkg.cfg diff --git a/numpy/_demo/basic_test/main.go b/numpy/_demo/basic_test/main.go new file mode 100644 index 00000000..c70be070 --- /dev/null +++ b/numpy/_demo/basic_test/main.go @@ -0,0 +1,27 @@ +package main + +import ( + "fmt" + + "numpy" + + "github.com/goplus/lib/py" + "github.com/goplus/lib/py/std" +) + +func main() { + fmt.Println("=== NumPy Basic Test Demo ===") + + // 测试1: 创建数组 + fmt.Println("\n1. 创建数组测试:") + + // 创建一个简单的数组 + arr1 := py.List(1.0, 2.0, 3.0, 4.0, 5.0) + arr2 := py.List(2.0, 4.0, 6.0, 8.0, 10.0) + + // 使用numpy进行数组运算 + arr3 := numpy.Add(arr1, arr2) + std.Print(py.Str("result:"), arr3) + + fmt.Println("\n=== 测试完成 ===") +} diff --git a/numpy/go.mod b/numpy/go.mod index 8ce9049a..fc2aaa3c 100644 --- a/numpy/go.mod +++ b/numpy/go.mod @@ -1,4 +1,4 @@ -module github.com/PengPengPeng717/llpkg/numpy +module numpy go 1.24.5 diff --git a/numpy/llpkg.cfg b/numpy/llpkg.cfg new file mode 100644 index 00000000..fba1a7cf --- /dev/null +++ b/numpy/llpkg.cfg @@ -0,0 +1,15 @@ +{ + "type": "python", + "upstream": { + "installer": { + "name": "pip", + "config": { + "options": "" + } + }, + "package": { + "name": "numpy", + "version": "1.26.4" + } + } +} \ No newline at end of file diff --git a/numpy/llpyg.cfg b/numpy/llpyg.cfg index 932c66b2..698ff6b4 100644 --- a/numpy/llpyg.cfg +++ b/numpy/llpyg.cfg @@ -1,7 +1,6 @@ { "name": "numpy", "libName": "numpy", - "libVersion": "2.3.2", "modules": [ "numpy" ] diff --git a/numpy/numpy.go b/numpy/numpy.go index e0674759..dc1217db 100644 --- a/numpy/numpy.go +++ b/numpy/numpy.go @@ -6,659 +6,540 @@ import ( ) const LLGoPackage = "py.numpy" -// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Calculate the absolute value element-wise. -// -// ``np.abs`` is a shorthand for this function. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// absolute : ndarray -// An ndarray containing the absolute value of -// each element in `x`. For complex input, ``a + ib``, the -// absolute value is :math:`\sqrt{ a^2 + b^2 }`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([-1.2, 1.2]) -// >>> np.absolute(x) -// array([ 1.2, 1.2]) -// >>> np.absolute(1.2 + 1j) -// 1.5620499351813308 -// -// Plot the function over ``[-10, 10]``: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(start=-10, stop=10, num=101) -// >>> plt.plot(x, np.absolute(x)) -// >>> plt.show() +// dot(a, b, out=None) // -// Plot the function over the complex plane: +// Dot product of two arrays. Specifically, // -// >>> xx = x + 1j * x[:, np.newaxis] -// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') -// >>> plt.show() +// - If both `a` and `b` are 1-D arrays, it is inner product of vectors +// (without complex conjugation). // -// The `abs` function can be used as a shorthand for ``np.absolute`` on -// ndarrays. +// - If both `a` and `b` are 2-D arrays, it is matrix multiplication, +// but using :func:`matmul` or ``a @ b`` is preferred. // -// >>> x = np.array([-1.2, 1.2]) -// >>> abs(x) -// array([1.2, 1.2]) +// - 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. // -//go:linkname Abs py.abs -func Abs(__llgo_va_list ...interface{}) *py.Object -//go:linkname Invert py.invert -func Invert(__llgo_va_list ...interface{}) *py.Object +// - 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`. // -// Take values from the input array by matching 1d index and data slices. +// - 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`:: // -// This iterates over matching 1d slices oriented along the specified axis in -// the index and data arrays, and uses the former to look up values in the -// latter. These slices can be different lengths. +// dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) // -// Functions returning an index along an axis, like `argsort` and -// `argpartition`, produce suitable indices for this function. +// It uses an optimized BLAS library when possible (see `numpy.linalg`). // // Parameters // ---------- -// arr : ndarray (Ni..., M, Nk...) -// Source array -// indices : ndarray (Ni..., J, Nk...) -// Indices to take along each 1d slice of ``arr``. This must match the -// dimension of ``arr``, but dimensions Ni and Nj only need to broadcast -// against ``arr``. -// axis : int or None, optional -// The axis to take 1d slices along. If axis is None, the input array is -// treated as if it had first been flattened to 1d, for consistency with -// `sort` and `argsort`. -// -// .. versionchanged:: 2.3 -// The default value is now ``-1``. +// a : array_like +// First argument. +// b : array_like +// Second argument. +// out : ndarray, optional +// Output argument. This must have the exact kind that would be returned +// if it was not used. In particular, it must have the right type, must be +// C-contiguous, and its dtype must be the dtype that would be returned +// for `dot(a,b)`. This is a performance feature. Therefore, if these +// conditions are not met, an exception is raised, instead of attempting +// to be flexible. // // Returns // ------- -// out: ndarray (Ni..., J, Nk...) -// The indexed result. -// -// Notes -// ----- -// This is equivalent to (but faster than) the following use of `ndindex` and -// `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: -// -// Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] -// J = indices.shape[axis] # Need not equal M -// out = np.empty(Ni + (J,) + Nk) -// -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// a_1d = a [ii + s_[:,] + kk] -// indices_1d = indices[ii + s_[:,] + kk] -// out_1d = out [ii + s_[:,] + kk] -// for j in range(J): -// out_1d[j] = a_1d[indices_1d[j]] -// -// Equivalently, eliminating the inner loop, the last two lines would be:: +// output : ndarray +// Returns the dot product of `a` and `b`. If `a` and `b` are both +// scalars or both 1-D arrays then a scalar is returned; otherwise +// an array is returned. +// If `out` is given, then it is returned. // -// out_1d[:] = a_1d[indices_1d] +// Raises +// ------ +// ValueError +// If the last dimension of `a` is not the same size as +// the second-to-last dimension of `b`. // // See Also // -------- -// take : Take along an axis, using the same indices for every 1d slice -// put_along_axis : -// Put values into the destination array by matching 1d index and data slices +// vdot : Complex-conjugating dot product. +// tensordot : Sum products over arbitrary axes. +// einsum : Einstein summation convention. +// matmul : '@' operator as method with out parameter. +// linalg.multi_dot : Chained dot product. // // Examples // -------- -// >>> import numpy as np -// -// For this sample array -// -// >>> a = np.array([[10, 30, 20], [60, 40, 50]]) -// -// We can sort either by using sort directly, or argsort and this function +// >>> np.dot(3, 4) +// 12 // -// >>> np.sort(a, axis=1) -// array([[10, 20, 30], -// [40, 50, 60]]) -// >>> ai = np.argsort(a, axis=1) -// >>> ai -// array([[0, 2, 1], -// [1, 2, 0]]) -// >>> np.take_along_axis(a, ai, axis=1) -// array([[10, 20, 30], -// [40, 50, 60]]) +// Neither argument is complex-conjugated: // -// The same works for max and min, if you maintain the trivial dimension -// with ``keepdims``: +// >>> np.dot([2j, 3j], [2j, 3j]) +// (-13+0j) // -// >>> np.max(a, axis=1, keepdims=True) -// array([[30], -// [60]]) -// >>> ai = np.argmax(a, axis=1, keepdims=True) -// >>> ai -// array([[1], -// [0]]) -// >>> np.take_along_axis(a, ai, axis=1) -// array([[30], -// [60]]) +// For 2-D arrays it is the matrix product: // -// If we want to get the max and min at the same time, we can stack the -// indices first +// >>> a = [[1, 0], [0, 1]] +// >>> b = [[4, 1], [2, 2]] +// >>> np.dot(a, b) +// array([[4, 1], +// [2, 2]]) // -// >>> ai_min = np.argmin(a, axis=1, keepdims=True) -// >>> ai_max = np.argmax(a, axis=1, keepdims=True) -// >>> ai = np.concatenate([ai_min, ai_max], axis=1) -// >>> ai -// array([[0, 1], -// [1, 0]]) -// >>> np.take_along_axis(a, ai, axis=1) -// array([[10, 30], -// [40, 60]]) +// >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) +// >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) +// >>> np.dot(a, b)[2,3,2,1,2,2] +// 499128 +// >>> sum(a[2,3,2,:] * b[1,2,:,2]) +// 499128 // // -//go:linkname TakeAlongAxis py.take_along_axis -func TakeAlongAxis(arr *py.Object, indices *py.Object, axis *py.Object) *py.Object // -// Extract a diagonal or construct a diagonal array. +//go:linkname Dot py.dot +func Dot(a *py.Object, b *py.Object, out *py.Object) *py.Object // -// See the more detailed documentation for ``numpy.diagonal`` if you use this -// function to extract a diagonal and wish to write to the resulting array; -// whether it returns a copy or a view depends on what version of numpy you -// are using. +// Return a new array of given shape and type, filled with ones. // // Parameters // ---------- -// v : array_like -// If `v` is a 2-D array, return a copy of its `k`-th diagonal. -// If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th -// diagonal. -// k : int, optional -// Diagonal in question. The default is 0. Use `k>0` for diagonals -// above the main diagonal, and `k<0` for diagonals below the main -// diagonal. +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// dtype : data-type, optional +// The desired data-type for the array, e.g., `numpy.int8`. Default is +// `numpy.float64`. +// order : {'C', 'F'}, optional, default: C +// Whether to store multi-dimensional data in row-major +// (C-style) or column-major (Fortran-style) order in +// memory. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // // Returns // ------- // out : ndarray -// The extracted diagonal or constructed diagonal array. +// Array of ones with the given shape, dtype, and order. // // See Also // -------- -// diagonal : Return specified diagonals. -// diagflat : Create a 2-D array with the flattened input as a diagonal. -// trace : Sum along diagonals. -// triu : Upper triangle of an array. -// tril : Lower triangle of an array. +// ones_like : Return an array of ones with shape and type of input. +// empty : Return a new uninitialized array. +// zeros : Return a new array setting values to zero. +// full : Return a new array of given shape filled with value. +// // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(9).reshape((3,3)) -// >>> x -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) +// >>> np.ones(5) +// array([1., 1., 1., 1., 1.]) // -// >>> np.diag(x) -// array([0, 4, 8]) -// >>> np.diag(x, k=1) -// array([1, 5]) -// >>> np.diag(x, k=-1) -// array([3, 7]) +// >>> np.ones((5,), dtype=int) +// array([1, 1, 1, 1, 1]) // -// >>> np.diag(np.diag(x)) -// array([[0, 0, 0], -// [0, 4, 0], -// [0, 0, 8]]) +// >>> np.ones((2, 1)) +// array([[1.], +// [1.]]) // +// >>> s = (2,2) +// >>> np.ones(s) +// array([[1., 1.], +// [1., 1.]]) // // -//go:linkname Diag py.diag -func Diag(v *py.Object, k *py.Object) *py.Object // -// Reverse the order of elements along axis 0 (up/down). +//go:linkname Ones py.ones +func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object // -// For a 2-D array, this flips the entries in each column in the up/down -// direction. Rows are preserved, but appear in a different order than before. +// Return selected slices of an array along given axis. +// +// When working along a given axis, a slice along that axis is returned in +// `output` for each index where `condition` evaluates to True. When +// working on a 1-D array, `compress` is equivalent to `extract`. // // Parameters // ---------- -// m : array_like -// Input array. +// condition : 1-D array of bools +// Array that selects which entries to return. If len(condition) +// is less than the size of `a` along the given axis, then output is +// truncated to the length of the condition array. +// a : array_like +// Array from which to extract a part. +// axis : int, optional +// Axis along which to take slices. If None (default), work on the +// flattened array. +// out : ndarray, optional +// Output array. Its type is preserved and it must be of the right +// shape to hold the output. // // Returns // ------- -// out : array_like -// A view of `m` with the rows reversed. Since a view is -// returned, this operation is :math:`\mathcal O(1)`. +// compressed_array : ndarray +// A copy of `a` without the slices along axis for which `condition` +// is false. // // See Also // -------- -// fliplr : Flip array in the left/right direction. -// flip : Flip array in one or more dimensions. -// rot90 : Rotate array counterclockwise. -// -// Notes -// ----- -// Equivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``. -// Requires the array to be at least 1-D. +// take, choose, diag, diagonal, select +// ndarray.compress : Equivalent method in ndarray +// extract : Equivalent method when working on 1-D arrays +// :ref:`ufuncs-output-type` // // Examples // -------- -// >>> import numpy as np -// >>> A = np.diag([1.0, 2, 3]) -// >>> A -// array([[1., 0., 0.], -// [0., 2., 0.], -// [0., 0., 3.]]) -// >>> np.flipud(A) -// array([[0., 0., 3.], -// [0., 2., 0.], -// [1., 0., 0.]]) -// -// >>> rng = np.random.default_rng() -// >>> A = rng.normal(size=(2,3,5)) -// >>> np.all(np.flipud(A) == A[::-1,...]) -// True +// >>> a = np.array([[1, 2], [3, 4], [5, 6]]) +// >>> a +// array([[1, 2], +// [3, 4], +// [5, 6]]) +// >>> np.compress([0, 1], a, axis=0) +// array([[3, 4]]) +// >>> np.compress([False, True, True], a, axis=0) +// array([[3, 4], +// [5, 6]]) +// >>> np.compress([False, True], a, axis=1) +// array([[2], +// [4], +// [6]]) // -// >>> np.flipud([1,2]) -// array([2, 1]) +// Working on the flattened array does not return slices along an axis but +// selects elements. // +// >>> np.compress([False, True], a) +// array([2]) // // -//go:linkname Flipud py.flipud -func Flipud(m *py.Object) *py.Object // -// can_cast(from_, to, casting='safe') +//go:linkname Compress py.compress +func Compress(condition *py.Object, a *py.Object, axis *py.Object, out *py.Object) *py.Object // -// Returns True if cast between data types can occur according to the -// casting rule. +// Return the cumulative sum of the elements along a given axis. // // Parameters // ---------- -// from_ : dtype, dtype specifier, NumPy scalar, or array -// Data type, NumPy scalar, or array to cast from. -// to : dtype or dtype specifier -// Data type to cast to. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. -// -// * 'no' means the data types should not be cast at all. -// * 'equiv' means only byte-order changes are allowed. -// * 'safe' means only casts which can preserve values are allowed. -// * 'same_kind' means only safe casts or casts within a kind, -// like float64 to float32, are allowed. -// * 'unsafe' means any data conversions may be done. +// a : array_like +// Input array. +// axis : int, optional +// Axis along which the cumulative sum is computed. The default +// (None) is to compute the cumsum over the flattened array. +// dtype : dtype, optional +// Type of the returned array and of the accumulator in which the +// elements are summed. If `dtype` is not specified, it defaults +// to the dtype of `a`, unless `a` has an integer dtype with a +// precision less than that of the default platform integer. In +// that case, the default platform integer is used. +// out : ndarray, optional +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output +// but the type will be cast if necessary. See :ref:`ufuncs-output-type` for +// more details. // // Returns // ------- -// out : bool -// True if cast can occur according to the casting rule. +// cumsum_along_axis : ndarray. +// A new array holding the result is returned unless `out` is +// specified, in which case a reference to `out` is returned. The +// result has the same size as `a`, and the same shape as `a` if +// `axis` is not None or `a` is a 1-d array. +// +// See Also +// -------- +// sum : Sum array elements. +// trapz : Integration of array values using the composite trapezoidal rule. +// diff : Calculate the n-th discrete difference along given axis. // // Notes // ----- -// .. versionchanged:: 2.0 -// This function does not support Python scalars anymore and does not -// apply any value-based logic for 0-D arrays and NumPy scalars. +// Arithmetic is modular when using integer types, and no error is +// raised on overflow. // -// See also -// -------- -// dtype, result_type +// ``cumsum(a)[-1]`` may not be equal to ``sum(a)`` for floating-point +// values since ``sum`` may use a pairwise summation routine, reducing +// the roundoff-error. See `sum` for more information. // // Examples // -------- -// Basic examples +// >>> a = np.array([[1,2,3], [4,5,6]]) +// >>> a +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.cumsum(a) +// array([ 1, 3, 6, 10, 15, 21]) +// >>> np.cumsum(a, dtype=float) # specifies type of output value(s) +// array([ 1., 3., 6., 10., 15., 21.]) // -// >>> import numpy as np -// >>> np.can_cast(np.int32, np.int64) -// True -// >>> np.can_cast(np.float64, complex) -// True -// >>> np.can_cast(complex, float) -// False +// >>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns +// array([[1, 2, 3], +// [5, 7, 9]]) +// >>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows +// array([[ 1, 3, 6], +// [ 4, 9, 15]]) // -// >>> np.can_cast('i8', 'f8') -// True -// >>> np.can_cast('i8', 'f4') -// False -// >>> np.can_cast('i4', 'S4') -// False +// ``cumsum(b)[-1]`` may not be equal to ``sum(b)`` // +// >>> b = np.array([1, 2e-9, 3e-9] * 1000000) +// >>> b.cumsum()[-1] +// 1000000.0050045159 +// >>> b.sum() +// 1000000.0050000029 // // -//go:linkname CanCast py.can_cast -func CanCast(from_ *py.Object, to *py.Object, casting *py.Object) *py.Object -//go:linkname Equal py.equal -func Equal(__llgo_va_list ...interface{}) *py.Object // -// Return the size of the buffer used in ufuncs. +//go:linkname Cumsum py.cumsum +func Cumsum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object +// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Returns -// ------- -// getbufsize : int -// Size of ufunc buffer in bytes. +// Return element-wise quotient and remainder simultaneously. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.getbufsize() -// 8192 +// .. versionadded:: 1.13.0 // +// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster +// because it avoids redundant work. It is used to implement the Python +// built-in function ``divmod`` on NumPy arrays. // +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -//go:linkname Getbufsize py.getbufsize -func Getbufsize() *py.Object +// Returns +// ------- +// out1 : ndarray +// Element-wise quotient resulting from floor division. +// This is a scalar if both `x1` and `x2` are scalars. +// out2 : ndarray +// Element-wise remainder from floor division. +// This is a scalar if both `x1` and `x2` are scalars. // -// Return the sum of array elements over a given axis treating Not a -// Numbers (NaNs) as zero. +// See Also +// -------- +// floor_divide : Equivalent to Python's ``//`` operator. +// remainder : Equivalent to Python's ``%`` operator. +// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return +// values switched. // -// In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or -// empty. In later versions zero is returned. +// Examples +// -------- +// >>> np.divmod(np.arange(5), 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) // -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose sum is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the sum is computed. The default is to compute the -// sum of the flattened array. -// dtype : data-type, optional -// The type of the returned array and of the accumulator in which the -// elements are summed. By default, the dtype of `a` is used. An -// exception is when `a` has an integer type with less precision than -// the platform (u)intp. In that case, the default will be either -// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 -// bits. For inexact inputs, dtype must be inexact. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``. If provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. The casting of NaN to integer -// can yield unexpected results. -// 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`. -// -// If the value is anything but the default, then -// `keepdims` will be passed through to the `mean` or `sum` methods -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// initial : scalar, optional -// Starting value for the sum. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to include in the sum. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 +// The `divmod` function can be used as a shorthand for ``np.divmod`` on +// ndarrays. // -// Returns -// ------- -// nansum : ndarray. -// A new array holding the result is returned unless `out` is -// specified, in which it is returned. The result has the same -// size as `a`, and the same shape as `a` if `axis` is not None -// or `a` is a 1-d array. +// >>> x = np.arange(5) +// >>> divmod(x, 3) +// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) // -// See Also -// -------- -// numpy.sum : Sum across array propagating NaNs. -// isnan : Show which elements are NaN. -// isfinite : Show which elements are not NaN or +/-inf. +//go:linkname Divmod py.divmod +func Divmod(x1 *py.Object, x2 *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object +// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Notes -// ----- -// If both positive and negative infinity are present, the sum will be Not -// A Number (NaN). +// Return the distance between x and the nearest adjacent number. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.nansum(1) -// 1 -// >>> np.nansum([1]) -// 1 -// >>> np.nansum([1, np.nan]) -// 1.0 -// >>> a = np.array([[1, 1], [1, np.nan]]) -// >>> np.nansum(a) -// 3.0 -// >>> np.nansum(a, axis=0) -// array([2., 1.]) -// >>> np.nansum([1, np.nan, np.inf]) -// inf -// >>> np.nansum([1, np.nan, -np.inf]) -// -inf -// >>> from numpy.testing import suppress_warnings -// >>> with np.errstate(invalid="ignore"): -// ... np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present -// np.float64(nan) +// Parameters +// ---------- +// x : array_like +// Values to find the spacing of. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // +// Returns +// ------- +// out : ndarray or scalar +// The spacing of values of `x`. +// This is a scalar if `x` is a scalar. // +// Notes +// ----- +// It can be considered as a generalization of EPS: +// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there +// should not be any representable number between ``x + spacing(x)`` and +// x for any finite x. // -//go:linkname Nansum py.nansum -func Nansum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// Spacing of +- inf and NaN is NaN. // -// Save several arrays into a single file in compressed ``.npz`` format. +// Examples +// -------- +// >>> np.spacing(1) == np.finfo(np.float64).eps +// True // -// Provide arrays as keyword arguments to store them under the -// corresponding name in the output file: ``savez_compressed(fn, x=x, y=y)``. +//go:linkname Spacing py.spacing +func Spacing(x *py.Object, out *py.Object) *py.Object // -// If arrays are specified as positional arguments, i.e., -// ``savez_compressed(fn, x, y)``, their names will be `arr_0`, `arr_1`, etc. +// View inputs as arrays with at least two dimensions. // // Parameters // ---------- -// file : file, str, or pathlib.Path -// Either the filename (string) or an open file (file-like object) -// where the data will be saved. If file is a string or a Path, the -// ``.npz`` extension will be appended to the filename if it is not -// already there. -// args : Arguments, optional -// Arrays to save to the file. Please use keyword arguments (see -// `kwds` below) to assign names to arrays. Arrays specified as -// args will be named "arr_0", "arr_1", and so on. -// allow_pickle : bool, optional -// Allow saving object arrays using Python pickles. Reasons for -// disallowing pickles include security (loading pickled data can execute -// arbitrary code) and portability (pickled objects may not be loadable -// on different Python installations, for example if the stored objects -// require libraries that are not available, and not all pickled data is -// compatible between different versions of Python). -// Default: True -// kwds : Keyword arguments, optional -// Arrays to save to the file. Each array will be saved to the -// output file with its corresponding keyword name. +// arys1, arys2, ... : array_like +// One or more array-like sequences. Non-array inputs are converted +// to arrays. Arrays that already have two or more dimensions are +// preserved. // // Returns // ------- -// None +// res, res2, ... : ndarray +// An array, or list of arrays, each with ``a.ndim >= 2``. +// Copies are avoided where possible, and views with two or more +// dimensions are returned. // // See Also // -------- -// numpy.save : Save a single array to a binary file in NumPy format. -// numpy.savetxt : Save an array to a file as plain text. -// numpy.savez : Save several arrays into an uncompressed ``.npz`` file format -// numpy.load : Load the files created by savez_compressed. -// -// Notes -// ----- -// The ``.npz`` file format is a zipped archive of files named after the -// variables they contain. The archive is compressed with -// ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable -// in ``.npy`` format. For a description of the ``.npy`` format, see -// :py:mod:`numpy.lib.format`. -// -// -// When opening the saved ``.npz`` file with `load` a `~lib.npyio.NpzFile` -// object is returned. This is a dictionary-like object which can be queried -// for its list of arrays (with the ``.files`` attribute), and for the arrays -// themselves. +// atleast_1d, atleast_3d // // Examples // -------- -// >>> import numpy as np -// >>> test_array = np.random.rand(3, 2) -// >>> test_vector = np.random.rand(4) -// >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector) -// >>> loaded = np.load('/tmp/123.npz') -// >>> print(np.array_equal(test_array, loaded['a'])) -// True -// >>> print(np.array_equal(test_vector, loaded['b'])) -// True +// >>> np.atleast_2d(3.0) +// array([[3.]]) // +// >>> x = np.arange(3.0) +// >>> np.atleast_2d(x) +// array([[0., 1., 2.]]) +// >>> np.atleast_2d(x).base is x +// True // +// >>> np.atleast_2d(1, [1, 2], [[1, 2]]) +// [array([[1]]), array([[1, 2]]), array([[1, 2]])] // -//go:linkname SavezCompressed py.savez_compressed -func SavezCompressed(__llgo_va_list ...interface{}) *py.Object // -// Find the coefficients of a polynomial with the given sequence of roots. // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. +//go:linkname Atleast2d py.atleast_2d +func Atleast2d(__llgo_va_list ...interface{}) *py.Object // -// Returns the coefficients of the polynomial whose leading coefficient -// is one for the given sequence of zeros (multiple roots must be included -// in the sequence as many times as their multiplicity; see Examples). -// A square matrix (or array, which will be treated as a matrix) can also -// be given, in which case the coefficients of the characteristic polynomial -// of the matrix are returned. +// Return an array copy of the given object. // // Parameters // ---------- -// seq_of_zeros : array_like, shape (N,) or (N, N) -// A sequence of polynomial roots, or a square array or matrix object. +// a : array_like +// Input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Controls the memory layout of the copy. 'C' means C-order, +// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, +// 'C' otherwise. 'K' means match the layout of `a` as closely +// as possible. (Note that this function and :meth:`ndarray.copy` are very +// similar, but have different default values for their order= +// arguments.) +// subok : bool, optional +// If True, then sub-classes will be passed-through, otherwise the +// returned array will be forced to be a base-class array (defaults to False). +// +// .. versionadded:: 1.19.0 // // Returns // ------- -// c : ndarray -// 1D array of polynomial coefficients from highest to lowest degree: -// -// ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]`` -// where c[0] always equals 1. -// -// Raises -// ------ -// ValueError -// If input is the wrong shape (the input must be a 1-D or square -// 2-D array). +// arr : ndarray +// Array interpretation of `a`. // // See Also // -------- -// polyval : Compute polynomial values. -// roots : Return the roots of a polynomial. -// polyfit : Least squares polynomial fit. -// poly1d : A one-dimensional polynomial class. +// ndarray.copy : Preferred method for creating an array copy // // Notes // ----- -// Specifying the roots of a polynomial still leaves one degree of -// freedom, typically represented by an undetermined leading -// coefficient. [1]_ In the case of this function, that coefficient - -// the first one in the returned array - is always taken as one. (If -// for some reason you have one other point, the only automatic way -// presently to leverage that information is to use ``polyfit``.) -// -// The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n` -// matrix **A** is given by -// -// :math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`, -// -// where **I** is the `n`-by-`n` identity matrix. [2]_ -// -// References -// ---------- -// .. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trigonometry, -// Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996. +// This is equivalent to: // -// .. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition," -// Academic Press, pg. 182, 1980. +// >>> np.array(a, copy=True) #doctest: +SKIP // // Examples // -------- +// Create an array x, with a reference y and a copy z: // -// Given a sequence of a polynomial's zeros: +// >>> x = np.array([1, 2, 3]) +// >>> y = x +// >>> z = np.copy(x) // -// >>> import numpy as np +// Note that, when we modify x, y changes, but not z: // -// >>> np.poly((0, 0, 0)) # Multiple root example -// array([1., 0., 0., 0.]) +// >>> x[0] = 10 +// >>> x[0] == y[0] +// True +// >>> x[0] == z[0] +// False // -// The line above represents z**3 + 0*z**2 + 0*z + 0. +// Note that, np.copy clears previously set WRITEABLE=False flag. // -// >>> np.poly((-1./2, 0, 1./2)) -// array([ 1. , 0. , -0.25, 0. ]) +// >>> a = np.array([1, 2, 3]) +// >>> a.flags["WRITEABLE"] = False +// >>> b = np.copy(a) +// >>> b.flags["WRITEABLE"] +// True +// >>> b[0] = 3 +// >>> b +// array([3, 2, 3]) // -// The line above represents z**3 - z/4 +// 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 +// same object which may lead to surprises if that object can +// be modified (is mutable): // -// >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0])) -// array([ 1. , -0.77086955, 0.08618131, 0. ]) # random -// -// Given a square array object: +// >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) +// >>> b = np.copy(a) +// >>> b[2][0] = 10 +// >>> a +// array([1, 'm', list([10, 3, 4])], dtype=object) // -// >>> P = np.array([[0, 1./3], [-1./2, 0]]) -// >>> np.poly(P) -// array([1. , 0. , 0.16666667]) +// To ensure all elements within an ``object`` array are copied, +// use `copy.deepcopy`: // -// Note how in all cases the leading coefficient is always 1. +// >>> import copy +// >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) +// >>> c = copy.deepcopy(a) +// >>> c[2][0] = 10 +// >>> c +// array([1, 'm', list([10, 3, 4])], dtype=object) +// >>> a +// array([1, 'm', list([2, 3, 4])], dtype=object) // // // -//go:linkname Poly py.poly -func Poly(__llgo_va_list ...interface{}) *py.Object +//go:linkname Copy py.copy +func Copy(a *py.Object, order *py.Object, subok *py.Object) *py.Object +// ascontiguousarray(a, dtype=None, *, like=None) // -// Return a 2-D array with ones on the diagonal and zeros elsewhere. +// Return a contiguous array (ndim >= 1) in memory (C order). // // Parameters // ---------- -// N : int -// Number of rows in the output. -// M : int, optional -// Number of columns in the output. If None, defaults to `N`. -// k : int, optional -// Index of the diagonal: 0 (the default) refers to the main diagonal, -// a positive value refers to an upper diagonal, and a negative value -// to a lower diagonal. -// dtype : data-type, optional -// Data-type of the returned array. -// order : {'C', 'F'}, optional -// Whether the output should be stored in row-major (C-style) or -// column-major (Fortran-style) order in memory. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. -// -// .. versionadded:: 2.0.0 +// a : array_like +// Input array. +// dtype : str or dtype object, optional +// Data-type of returned array. // 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 @@ -670,849 +551,682 @@ func Poly(__llgo_va_list ...interface{}) *py.Object // // Returns // ------- -// I : ndarray of shape (N,M) -// An array where all elements are equal to zero, except for the `k`-th -// diagonal, whose values are equal to one. +// out : ndarray +// Contiguous array of same shape and content as `a`, with type `dtype` +// if specified. // // See Also // -------- -// identity : (almost) equivalent function -// diag : diagonal 2-D array from a 1-D array specified by the user. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// require : Return an ndarray that satisfies requirements. +// ndarray.flags : Information about the memory layout of the array. // // Examples // -------- -// >>> import numpy as np -// >>> np.eye(2, dtype=int) -// array([[1, 0], -// [0, 1]]) -// >>> np.eye(3, k=1) -// array([[0., 1., 0.], -// [0., 0., 1.], -// [0., 0., 0.]]) +// 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: // -//go:linkname Eye py.eye -func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object +// >>> y = np.ascontiguousarray(x) +// >>> y.flags['C_CONTIGUOUS'] +// True +// >>> np.may_share_memory(x, y) +// False // -// Return the indices for the upper-triangle of an (n, m) array. +// Now, starting with a C-contiguous array: // -// Parameters -// ---------- -// n : int -// The size of the arrays for which the returned indices will -// be valid. -// k : int, optional -// Diagonal offset (see `triu` for details). -// m : int, optional -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. +// >>> x = np.ones((2, 3), order='C') +// >>> x.flags['C_CONTIGUOUS'] +// True // +// Then, calling ``ascontiguousarray`` returns the same object: // -// Returns -// ------- -// inds : tuple, shape(2) of ndarrays, shape(`n`) -// The row and column indices, respectively. The row indices are sorted -// in non-decreasing order, and the correspdonding column indices are -// strictly increasing for each row. +// >>> y = np.ascontiguousarray(x) +// >>> x is y +// True // -// See also -// -------- -// tril_indices : similar function, for lower-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// triu, tril +// Note: This function returns an array with at least one-dimension (1-d) +// so it will not preserve 0-d arrays. // -// Examples -// -------- -// >>> import numpy as np +//go:linkname Ascontiguousarray py.ascontiguousarray +func Ascontiguousarray(a *py.Object, dtype *py.Object) *py.Object +// promote_types(type1, type2) // -// Compute two different sets of indices to access 4x4 arrays, one for the -// upper triangular part starting at the main diagonal, and one starting two -// diagonals further right: +// 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 considered "canonical", this mainly +// means that the promoted dtype will always be in native byte order. // -// >>> iu1 = np.triu_indices(4) -// >>> iu1 -// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) +// This function is symmetric, but rarely associative. // -// Note that row indices (first array) are non-decreasing, and the corresponding -// column indices (second array) are strictly increasing for each row. +// Parameters +// ---------- +// type1 : dtype or dtype specifier +// First data type. +// type2 : dtype or dtype specifier +// Second data type. // -// Here is how they can be used with a sample array: +// Returns +// ------- +// out : dtype +// The promoted data type. // -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) +// Notes +// ----- +// Please see `numpy.result_type` for additional information about promotion. // -// Both for indexing: +// .. versionadded:: 1.6.0 // -// >>> a[iu1] -// array([ 0, 1, 2, ..., 10, 11, 15]) +// Starting in NumPy 1.9, promote_types function now returns a valid string +// length when given an integer or float dtype as one argument and a string +// dtype as another argument. Previously it always returned the input string +// dtype, even if it wasn't long enough to store the max integer/float value +// converted to a string. // -// And for assigning values: +// .. versionchanged:: 1.23.0 // -// >>> a[iu1] = -1 -// >>> a -// array([[-1, -1, -1, -1], -// [ 4, -1, -1, -1], -// [ 8, 9, -1, -1], -// [12, 13, 14, -1]]) +// NumPy now supports promotion for more structured dtypes. It will now +// remove unnecessary padding from a structure dtype and promote included +// fields individually. // -// These cover only a small part of the whole array (two diagonals right -// of the main one): +// See Also +// -------- +// result_type, dtype, can_cast // -// >>> iu2 = np.triu_indices(4, 2) -// >>> a[iu2] = -10 -// >>> a -// array([[ -1, -1, -10, -10], -// [ 4, -1, -1, -10], -// [ 8, 9, -1, -1], -// [ 12, 13, 14, -1]]) +// Examples +// -------- +// >>> np.promote_types('f4', 'f8') +// dtype('float64') // +// >>> np.promote_types('i8', 'f4') +// dtype('float64') // +// >>> np.promote_types('>i8', '>> np.promote_types('i4', 'S8') +// dtype('S11') // -// Trigonometric inverse tangent, element-wise. +// An example of a non-associative case: // -// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. +// >>> p = np.promote_types +// >>> p('S', p('i1', 'u1')) +// dtype('S6') +// >>> p(p('S', 'i1'), 'u1') +// dtype('S4') // -// Parameters -// ---------- -// x : array_like -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +//go:linkname PromoteTypes py.promote_types +func PromoteTypes(type1 *py.Object, type2 *py.Object) *py.Object // -// Returns -// ------- -// out : ndarray or scalar -// Out has the same shape as `x`. Its real part is in -// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). -// This is a scalar if `x` is a scalar. +// Return an array of zeros with the same shape and type as a given array. // -// See Also -// -------- -// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) -// and the positive `x`-axis. -// angle : Argument of complex values. +// Parameters +// ---------- +// a : array_like +// The shape and data-type of `a` define these same attributes of +// the returned array. +// dtype : data-type, optional +// Overrides the data type of the result. // -// Notes -// ----- -// `arctan` is a multi-valued function: for each `x` there are infinitely -// many numbers `z` such that tan(`z`) = `x`. The convention is to return -// the angle `z` whose real part lies in [-pi/2, pi/2]. +// .. versionadded:: 1.6.0 +// order : {'C', 'F', 'A', or 'K'}, optional +// Overrides the memory layout of the result. 'C' means C-order, +// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, +// 'C' otherwise. 'K' means match the layout of `a` as closely +// as possible. // -// For real-valued input data types, `arctan` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. +// .. versionadded:: 1.6.0 +// subok : bool, optional. +// If True, then the newly created array will use the sub-class +// type of `a`, otherwise it will be a base-class array. Defaults +// to True. +// shape : int or sequence of ints, optional. +// Overrides the shape of the result. If order='K' and the number of +// dimensions is unchanged, will try to keep order, otherwise, +// order='C' is implied. // -// For complex-valued input, `arctan` is a complex analytic function that -// has [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous -// from the left on the former and from the right on the latter. +// .. versionadded:: 1.17.0 // -// The inverse tangent is also known as `atan` or tan^{-1}. +// Returns +// ------- +// out : ndarray +// Array of zeros with the same shape and type as `a`. // -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// -// We expect the arctan of 0 to be 0, and of 1 to be pi/4: -// -// >>> import numpy as np -// >>> np.arctan([0, 1]) -// array([ 0. , 0.78539816]) -// -// >>> np.pi/4 -// 0.78539816339744828 -// -// Plot arctan: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-10, 10) -// >>> plt.plot(x, np.arctan(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arctan py.arctan -func Arctan(x *py.Object, out *py.Object) *py.Object -// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Return the ceiling of the input, element-wise. -// -// The ceil of the scalar `x` is the smallest integer `i`, such that -// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The ceiling of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// floor, trunc, rint, fix -// -// Examples -// -------- -// >>> import numpy as np -// -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.ceil(a) -// array([-1., -1., -0., 1., 2., 2., 2.]) -// -//go:linkname Ceil py.ceil -func Ceil(x *py.Object, out *py.Object) *py.Object -// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Convert angles from radians to degrees. +// See Also +// -------- +// empty_like : Return an empty array with shape and type of input. +// ones_like : Return an array of ones with shape and type of input. +// full_like : Return a new array with shape of input filled with value. +// zeros : Return a new array setting values to zero. // -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Examples +// -------- +// >>> x = np.arange(6) +// >>> x = x.reshape((2, 3)) +// >>> x +// array([[0, 1, 2], +// [3, 4, 5]]) +// >>> np.zeros_like(x) +// array([[0, 0, 0], +// [0, 0, 0]]) // -// Returns -// ------- -// y : ndarray of floats -// The corresponding degree values; if `out` was supplied this is a -// reference to it. -// This is a scalar if `x` is a scalar. +// >>> y = np.arange(3, dtype=float) +// >>> y +// array([0., 1., 2.]) +// >>> np.zeros_like(y) +// array([0., 0., 0.]) // -// See Also -// -------- -// rad2deg : equivalent function // -// Examples -// -------- -// Convert a radian array to degrees // -// >>> import numpy as np -// >>> rad = np.arange(12.)*np.pi/6 -// >>> np.degrees(rad) -// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., -// 270., 300., 330.]) +//go:linkname ZerosLike py.zeros_like +func ZerosLike(__llgo_va_list ...interface{}) *py.Object // -// >>> out = np.zeros((rad.shape)) -// >>> r = np.degrees(rad, out) -// >>> np.all(r == out) -// True +// may_share_memory(a, b, /, max_work=None) // -//go:linkname Degrees py.degrees -func Degrees(x *py.Object, out *py.Object) *py.Object +// Determine if two arrays might share memory // -// Return indices that are non-zero in the flattened version of a. +// A return of True does not necessarily mean that the two arrays +// share any element. It just means that they *might*. // -// This is equivalent to ``np.nonzero(np.ravel(a))[0]``. +// Only the memory bounds of a and b are checked by default. // // Parameters // ---------- -// a : array_like -// Input data. +// a, b : ndarray +// Input arrays +// max_work : int, optional +// Effort to spend on solving the overlap problem. See +// `shares_memory` for details. Default for ``may_share_memory`` +// is to do a bounds check. // // Returns // ------- -// res : ndarray -// Output array, containing the indices of the elements of ``a.ravel()`` -// that are non-zero. +// out : bool // // See Also // -------- -// nonzero : Return the indices of the non-zero elements of the input array. -// ravel : Return a 1-D array containing the elements of the input array. +// shares_memory // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(-2, 3) -// >>> x -// array([-2, -1, 0, 1, 2]) -// >>> np.flatnonzero(x) -// array([0, 1, 3, 4]) -// -// Use the indices of the non-zero elements as an index array to extract -// these elements: -// -// >>> x.ravel()[np.flatnonzero(x)] -// array([-2, -1, 1, 2]) -// +// >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9])) +// False +// >>> x = np.zeros([3, 4]) +// >>> np.may_share_memory(x[:,0], x[:,1]) +// True // // -//go:linkname Flatnonzero py.flatnonzero -func Flatnonzero(a *py.Object) *py.Object // -// Compute the arithmetic mean along the specified axis. +//go:linkname MayShareMemory py.may_share_memory +func MayShareMemory(a *py.Object, b *py.Object, maxWork *py.Object) *py.Object // -// Returns the average of the array elements. The average is taken over -// the flattened array by default, otherwise over the specified axis. -// `float64` intermediate and return values are used for integer inputs. +// Sum of array elements over a given axis. // // Parameters // ---------- // a : array_like -// Array containing numbers whose mean is desired. If `a` is not an -// array, a conversion is attempted. +// Elements to sum. // axis : None or int or tuple of ints, optional -// Axis or axes along which the means are computed. The default is to -// compute the mean of the flattened array. +// Axis or axes along which a sum is performed. The default, +// axis=None, will sum all of the elements of the input array. If +// axis is negative it counts from the last to the first axis. // -// If this is a tuple of ints, a mean is performed over multiple axes, -// instead of a single axis or all the axes as before. -// dtype : data-type, optional -// Type to use in computing the mean. For integer inputs, the default -// is `float64`; for floating point inputs, it is the same as the -// input dtype. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. -// See :ref:`ufuncs-output-type` for more details. -// See :ref:`ufuncs-output-type` for more details. +// .. versionadded:: 1.7.0 // +// If axis is a tuple of ints, a sum is performed on all of the axes +// specified in the tuple instead of a single axis or all the axes as +// before. +// dtype : dtype, optional +// The type of the returned array and of the accumulator in which the +// elements are summed. The dtype of `a` is used by default unless `a` +// has an integer dtype of less precision than the default platform +// integer. In that case, if `a` is signed then the platform integer +// is used while if `a` is unsigned then an unsigned integer of the +// same precision as the platform integer is used. +// out : ndarray, optional +// Alternative output array in which to place the result. It must have +// the same shape as the expected output, but the type of the output +// values will be cast if necessary. // 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 input array. // // If the default value is passed, then `keepdims` will not be -// passed through to the `mean` method of sub-classes of +// passed through to the `sum` method of sub-classes of // `ndarray`, however any non-default value will be. If the // sub-class' method does not implement `keepdims` any // exceptions will be raised. +// initial : scalar, optional +// Starting value for the sum. See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.15.0 // // where : array_like of bool, optional -// Elements to include in the mean. See `~numpy.ufunc.reduce` for details. +// Elements to include in the sum. See `~numpy.ufunc.reduce` for details. // -// .. versionadded:: 1.20.0 +// .. versionadded:: 1.17.0 // // Returns // ------- -// m : ndarray, see dtype parameter above -// If `out=None`, returns a new array containing the mean values, -// otherwise a reference to the output array is returned. +// sum_along_axis : ndarray +// An array with the same shape as `a`, with the specified +// axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar +// is returned. If an output array is specified, a reference to +// `out` is returned. // // See Also // -------- -// average : Weighted average -// std, var, nanmean, nanstd, nanvar +// ndarray.sum : Equivalent method. +// +// add.reduce : Equivalent functionality of `add`. +// +// cumsum : Cumulative sum of array elements. +// +// trapz : Integration of array values using the composite trapezoidal rule. +// +// mean, average // // Notes // ----- -// The arithmetic mean is the sum of the elements along the axis divided -// by the number of elements. +// Arithmetic is modular when using integer types, and no error is +// raised on overflow. // -// Note that for floating-point input, the mean is computed using the -// same precision the input has. Depending on the input data, this can -// cause the results to be inaccurate, especially for `float32` (see -// example below). Specifying a higher-precision accumulator using the -// `dtype` keyword can alleviate this issue. +// The sum of an empty array is the neutral element 0: // -// By default, `float16` results are computed using `float32` intermediates -// for extra precision. +// >>> np.sum([]) +// 0.0 // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> np.mean(a) -// 2.5 -// >>> np.mean(a, axis=0) -// array([2., 3.]) -// >>> np.mean(a, axis=1) -// array([1.5, 3.5]) +// For floating point numbers the numerical precision of sum (and +// ``np.add.reduce``) is in general limited by directly adding each number +// individually to the result causing rounding errors in every step. +// However, often numpy will use a numerically better approach (partial +// pairwise summation) leading to improved precision in many use-cases. +// This improved precision is always provided when no ``axis`` is given. +// When ``axis`` is given, it will depend on which axis is summed. +// Technically, to provide the best speed possible, the improved precision +// is only used when the summation is along the fast axis in memory. +// Note that the exact precision may vary depending on other parameters. +// In contrast to NumPy, Python's ``math.fsum`` function uses a slower but +// more precise approach to summation. +// Especially when summing a large number of lower precision floating point +// numbers, such as ``float32``, numerical errors can become significant. +// In such cases it can be advisable to use `dtype="float64"` to use a higher +// precision for the output. // -// In single precision, `mean` can be inaccurate: +// Examples +// -------- +// >>> np.sum([0.5, 1.5]) +// 2.0 +// >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32) +// 1 +// >>> np.sum([[0, 1], [0, 5]]) +// 6 +// >>> np.sum([[0, 1], [0, 5]], axis=0) +// array([0, 6]) +// >>> np.sum([[0, 1], [0, 5]], axis=1) +// array([1, 5]) +// >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1) +// array([1., 5.]) // -// >>> a = np.zeros((2, 512*512), dtype=np.float32) -// >>> a[0, :] = 1.0 -// >>> a[1, :] = 0.1 -// >>> np.mean(a) -// np.float32(0.54999924) +// If the accumulator is too small, overflow occurs: // -// Computing the mean in float64 is more accurate: +// >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8) +// -128 // -// >>> np.mean(a, dtype=np.float64) -// 0.55000000074505806 # may vary +// You can also start the sum with a value other than zero: // -// Computing the mean in timedelta64 is available: +// >>> np.sum([10], initial=5) +// 15 // -// >>> b = np.array([1, 3], dtype="timedelta64[D]") -// >>> np.mean(b) -// np.timedelta64(2,'D') // -// Specifying a where argument: +//go:linkname Sum py.sum +func Sum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// >>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]]) -// >>> np.mean(a) -// 12.0 -// >>> np.mean(a, where=[[True], [False], [False]]) -// 9.0 +// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. // +// The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is +// the signed angle in radians between the ray ending at the origin and +// passing through the point (1,0), and the ray ending at the origin and +// passing through the point (`x2`, `x1`). (Note the role reversal: the +// "`y`-coordinate" is the first function parameter, the "`x`-coordinate" +// is the second.) By IEEE convention, this function is defined for +// `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see +// Notes for specific values). // +// This function is not defined for complex-valued arguments; for the +// so-called argument of complex values, use `angle`. // -//go:linkname Mean py.mean -func Mean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object) *py.Object +// Parameters +// ---------- +// x1 : array_like, real-valued +// `y`-coordinates. +// x2 : array_like, real-valued +// `x`-coordinates. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// shares_memory(a, b, /, max_work=None) +// Returns +// ------- +// angle : ndarray +// Array of angles in radians, in the range ``[-pi, pi]``. +// This is a scalar if both `x1` and `x2` are scalars. // -// Determine if two arrays share memory. +// See Also +// -------- +// arctan, tan, angle // -// .. warning:: +// Notes +// ----- +// *arctan2* is identical to the `atan2` function of the underlying +// C library. The following special values are defined in the C +// standard: [1]_ // -// This function can be exponentially slow for some inputs, unless -// `max_work` is set to zero or a positive integer. -// If in doubt, use `numpy.may_share_memory` instead. +// ====== ====== ================ +// `x1` `x2` `arctan2(x1,x2)` +// ====== ====== ================ +// +/- 0 +0 +/- 0 +// +/- 0 -0 +/- pi +// > 0 +/-inf +0 / +pi +// < 0 +/-inf -0 / -pi +// +/-inf +inf +/- (pi/4) +// +/-inf -inf +/- (3*pi/4) +// ====== ====== ================ // -// Parameters -// ---------- -// a, b : ndarray -// Input arrays -// max_work : int, optional -// Effort to spend on solving the overlap problem (maximum number -// of candidate solutions to consider). The following special -// values are recognized: +// Note that +0 and -0 are distinct floating point numbers, as are +inf +// and -inf. // -// max_work=-1 (default) -// The problem is solved exactly. In this case, the function returns -// True only if there is an element shared between the arrays. Finding -// the exact solution may take extremely long in some cases. -// max_work=0 -// Only the memory bounds of a and b are checked. -// This is equivalent to using ``may_share_memory()``. +// References +// ---------- +// .. [1] ISO/IEC standard 9899:1999, "Programming language C." // -// Raises -// ------ -// numpy.exceptions.TooHardError -// Exceeded max_work. +// Examples +// -------- +// Consider four points in different quadrants: // -// Returns -// ------- -// out : bool +// >>> x = np.array([-1, +1, +1, -1]) +// >>> y = np.array([-1, -1, +1, +1]) +// >>> np.arctan2(y, x) * 180 / np.pi +// array([-135., -45., 45., 135.]) // -// See Also -// -------- -// may_share_memory +// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 +// and at several other special points, obtaining values in +// the range ``[-pi, pi]``: // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([1, 2, 3, 4]) -// >>> np.shares_memory(x, np.array([5, 6, 7])) -// False -// >>> np.shares_memory(x[::2], x) -// True -// >>> np.shares_memory(x[::2], x[1::2]) -// False +// >>> 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]) // -// Checking whether two arrays share memory is NP-complete, and -// runtime may increase exponentially in the number of -// dimensions. Hence, `max_work` should generally be set to a finite -// number, as it is possible to construct examples that take -// extremely long to run: +//go:linkname Arctan2 py.arctan2 +func Arctan2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// >>> from numpy.lib.stride_tricks import as_strided -// >>> x = np.zeros([192163377], dtype=np.int8) -// >>> x1 = as_strided( -// ... x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049)) -// >>> x2 = as_strided( -// ... x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1)) -// >>> np.shares_memory(x1, x2, max_work=1000) -// Traceback (most recent call last): -// ... -// numpy.exceptions.TooHardError: Exceeded max_work +// Set printing options. // -// Running ``np.shares_memory(x1, x2)`` without `max_work` set takes -// around 1 minute for this case. It is possible to find problems -// that take still significantly longer. +// These options determine the way floating point numbers, arrays and +// other NumPy objects are displayed. // +// Parameters +// ---------- +// precision : int or None, optional +// Number of digits of precision for floating point output (default 8). +// May be None if `floatmode` is not `fixed`, to print as many digits as +// necessary to uniquely specify the value. +// threshold : int, optional +// Total number of array elements which trigger summarization +// rather than full repr (default 1000). +// To always use the full repr without summarization, pass `sys.maxsize`. +// edgeitems : int, optional +// Number of array items in summary at beginning and end of +// each dimension (default 3). +// linewidth : int, optional +// The number of characters per line for the purpose of inserting +// line breaks (default 75). +// suppress : bool, optional +// If True, always print floating point numbers using fixed point +// notation, in which case numbers equal to zero in the current precision +// will print as zero. If False, then scientific notation is used when +// absolute value of the smallest number is < 1e-4 or the ratio of the +// maximum absolute value to the minimum is > 1e3. The default is False. +// nanstr : str, optional +// String representation of floating point not-a-number (default nan). +// infstr : str, optional +// String representation of floating point infinity (default inf). +// sign : string, either '-', '+', or ' ', optional +// Controls printing of the sign of floating-point types. If '+', always +// print the sign of positive values. If ' ', always prints a space +// (whitespace character) in the sign position of positive values. If +// '-', omit the sign character of positive values. (default '-') +// formatter : dict of callables, optional +// If not None, the keys should indicate the type(s) that the respective +// formatting function applies to. Callables should return a string. +// Types that are not specified (by their corresponding keys) are handled +// by the default formatters. Individual types for which a formatter +// can be set are: // +// - 'bool' +// - 'int' +// - 'timedelta' : a `numpy.timedelta64` +// - 'datetime' : a `numpy.datetime64` +// - 'float' +// - 'longfloat' : 128-bit floats +// - 'complexfloat' +// - 'longcomplexfloat' : composed of two 128-bit floats +// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` +// - 'object' : `np.object_` arrays // -//go:linkname SharesMemory py.shares_memory -func SharesMemory(a *py.Object, b *py.Object, maxWork *py.Object) *py.Object +// Other keys that can be used to set a group of types at once are: // -// Return an array of zeros with the same shape and type as a given array. +// - 'all' : sets all types +// - 'int_kind' : sets 'int' +// - 'float_kind' : sets 'float' and 'longfloat' +// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' +// - 'str_kind' : sets 'numpystr' +// floatmode : str, optional +// Controls the interpretation of the `precision` option for +// floating-point types. Can take the following values +// (default maxprec_equal): // -// Parameters -// ---------- -// a : array_like -// The shape and data-type of `a` define these same attributes of -// the returned array. -// dtype : data-type, optional -// Overrides the data type of the result. -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `a`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. +// * 'fixed': Always print exactly `precision` fractional digits, +// even if this would print more or fewer digits than +// necessary to specify the value uniquely. +// * 'unique': Print the minimum number of fractional digits necessary +// to represent each value uniquely. Different elements may +// have a different number of digits. The value of the +// `precision` option is ignored. +// * 'maxprec': Print at most `precision` fractional digits, but if +// an element can be uniquely represented with fewer digits +// only print it with that many. +// * 'maxprec_equal': Print at most `precision` fractional digits, +// but if every element in the array can be uniquely +// represented with an equal number of fewer digits, use that +// many digits for all elements. +// legacy : string or `False`, optional +// If set to the string `'1.13'` enables 1.13 legacy printing mode. This +// approximates numpy 1.13 print output by including a space in the sign +// position of floats and different behavior for 0d arrays. This also +// enables 1.21 legacy printing mode (described below). // -// .. versionadded:: 2.0.0 +// If set to the string `'1.21'` enables 1.21 legacy printing mode. This +// approximates numpy 1.21 print output of complex structured dtypes +// by not inserting spaces after commas that separate fields and after +// colons. // -// Returns -// ------- -// out : ndarray -// Array of zeros with the same shape and type as `a`. +// If set to `False`, disables legacy mode. +// +// Unrecognized strings will be ignored with a warning for forward +// compatibility. +// +// .. versionadded:: 1.14.0 +// .. versionchanged:: 1.22.0 // // See Also // -------- -// empty_like : Return an empty array with shape and type of input. -// ones_like : Return an array of ones with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// zeros : Return a new array setting values to zero. +// get_printoptions, printoptions, set_string_function, array2string +// +// Notes +// ----- +// `formatter` is always reset with a call to `set_printoptions`. +// +// Use `printoptions` as a context manager to set the values temporarily. // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(6) -// >>> x = x.reshape((2, 3)) +// Floating point precision can be set: +// +// >>> np.set_printoptions(precision=4) +// >>> np.array([1.123456789]) +// [1.1235] +// +// Long arrays can be summarised: +// +// >>> np.set_printoptions(threshold=5) +// >>> np.arange(10) +// array([0, 1, 2, ..., 7, 8, 9]) +// +// Small results can be suppressed: +// +// >>> eps = np.finfo(float).eps +// >>> x = np.arange(4.) +// >>> x**2 - (x + eps)**2 +// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) +// >>> np.set_printoptions(suppress=True) +// >>> x**2 - (x + eps)**2 +// array([-0., -0., 0., 0.]) +// +// A custom formatter can be used to display array elements as desired: +// +// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) +// >>> x = np.arange(3) // >>> x -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.zeros_like(x) -// array([[0, 0, 0], -// [0, 0, 0]]) +// array([int: 0, int: -1, int: -2]) +// >>> np.set_printoptions() # formatter gets reset +// >>> x +// array([0, 1, 2]) // -// >>> y = np.arange(3, dtype=float) -// >>> y -// array([0., 1., 2.]) -// >>> np.zeros_like(y) -// array([0., 0., 0.]) +// To put back the default options, you can use: // +// >>> np.set_printoptions(edgeitems=3, infstr='inf', +// ... linewidth=75, nanstr='nan', precision=8, +// ... suppress=False, threshold=1000, formatter=None) // +// Also to temporarily override options, use `printoptions` as a context manager: // -//go:linkname ZerosLike py.zeros_like -func ZerosLike(a *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object +// >>> with np.printoptions(precision=2, suppress=True, threshold=5): +// ... np.linspace(0, 10, 10) +// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) // -// Test whether each element of a 1-D array is also present in a second array. // -// .. deprecated:: 2.0 -// Use :func:`isin` instead of `in1d` for new code. // -// Returns a boolean array the same length as `ar1` that is True -// where an element of `ar1` is in `ar2` and False otherwise. +//go:linkname SetPrintoptions py.set_printoptions +func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object +// +// Compute the median along the specified axis. +// +// Returns the median of the array elements. // // Parameters // ---------- -// ar1 : (M,) array_like -// Input array. -// ar2 : array_like -// The values against which to test each value of `ar1`. -// assume_unique : bool, optional -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. Default is False. -// invert : bool, optional -// If True, the values in the returned array are inverted (that is, -// 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. +// a : array_like +// Input array or object that can be converted to an array. +// axis : {int, sequence of int, None}, optional +// Axis or axes along which the medians are computed. The default +// is to compute the median along a flattened version of the array. +// A sequence of axes is supported since version 1.9.0. +// out : ndarray, optional +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output, +// but the type (of the output) will be cast if necessary. +// overwrite_input : bool, optional +// If True, then allow use of memory of input array `a` for +// calculations. The input array will be modified by the call to +// `median`. This will save memory when you do not need to preserve +// the contents of the input array. Treat the input as undefined, +// but it will probably be fully or partially sorted. Default is +// False. If `overwrite_input` is ``True`` and `a` is not already an +// `ndarray`, an error will be raised. +// 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 `arr`. // -// * 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.9.0 // // Returns // ------- -// in1d : (M,) ndarray, bool -// The values `ar1[in1d]` are in `ar2`. +// median : ndarray +// A new array holding the result. If the input contains integers +// or floats smaller than ``float64``, then the output data-type is +// ``np.float64``. Otherwise, the data-type of the output is the +// same as that of the input. If `out` is specified, that array is +// returned instead. // // See Also // -------- -// isin : Version of this function that preserves the -// shape of ar1. +// mean, percentile // // Notes // ----- -// `in1d` can be considered as an element-wise function version of the -// python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly -// equivalent to ``np.array([item in b for item in a])``. -// However, this idea fails if `ar2` is a set, or similar (non-sequence) -// container: As ``ar2`` is converted to an array, in those cases -// ``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. +// Given a vector ``V`` of length ``N``, the median of ``V`` is the +// middle value of a sorted copy of ``V``, ``V_sorted`` - i +// e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the +// two middle values of ``V_sorted`` when ``N`` is even. // // Examples // -------- -// >>> import numpy as np -// >>> test = np.array([0, 1, 2, 5, 0]) -// >>> states = [0, 2] -// >>> mask = np.in1d(test, states) -// >>> mask -// array([ True, False, True, False, True]) -// >>> test[mask] -// array([0, 2, 0]) -// >>> mask = np.in1d(test, states, invert=True) -// >>> mask -// array([False, True, False, True, False]) -// >>> test[mask] -// array([1, 5]) +// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) +// >>> a +// array([[10, 7, 4], +// [ 3, 2, 1]]) +// >>> np.median(a) +// 3.5 +// >>> np.median(a, axis=0) +// array([6.5, 4.5, 2.5]) +// >>> np.median(a, axis=1) +// array([7., 2.]) +// >>> m = np.median(a, axis=0) +// >>> out = np.zeros_like(m) +// >>> np.median(a, axis=0, out=m) +// array([6.5, 4.5, 2.5]) +// >>> m +// array([6.5, 4.5, 2.5]) +// >>> b = a.copy() +// >>> np.median(b, axis=1, overwrite_input=True) +// array([7., 2.]) +// >>> assert not np.all(a==b) +// >>> b = a.copy() +// >>> np.median(b, axis=None, overwrite_input=True) +// 3.5 +// >>> assert not np.all(a==b) // // -//go:linkname In1d py.in1d -func In1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object -// fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None) // -// Construct an array from data in a text or binary file. +//go:linkname Median py.median +func Median(a *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, keepdims *py.Object) *py.Object +// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// A highly efficient way of reading binary data with a known data-type, -// as well as parsing simply formatted text files. Data written using the -// `tofile` method can be read using this function. -// -// Parameters -// ---------- -// file : file or str or Path -// Open file object or filename. -// dtype : data-type -// Data type of the returned array. -// For binary files, it is used to determine the size and byte-order -// of the items in the file. -// Most builtin numeric types are supported and extension types may be supported. -// count : int -// Number of items to read. ``-1`` means all items (i.e., the complete -// file). -// sep : str -// Separator between items if file is a text file. -// Empty ("") separator means the file should be treated as binary. -// Spaces (" ") in the separator match zero or more whitespace characters. -// A separator consisting only of spaces must match at least one -// whitespace. -// offset : int -// The offset (in bytes) from the file's current position. Defaults to 0. -// Only permitted for binary files. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// See also -// -------- -// load, save -// ndarray.tofile -// loadtxt : More flexible way of loading data from a text file. -// -// Notes -// ----- -// Do not rely on the combination of `tofile` and `fromfile` for -// data storage, as the binary files generated are not platform -// independent. In particular, no byte-order or data-type information is -// saved. Data can be stored in the platform independent ``.npy`` format -// using `save` and `load` instead. -// -// Examples -// -------- -// Construct an ndarray: -// -// >>> import numpy as np -// >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]), -// ... ('temp', float)]) -// >>> x = np.zeros((1,), dtype=dt) -// >>> x['time']['min'] = 10; x['temp'] = 98.25 -// >>> x -// array([((10, 0), 98.25)], -// dtype=[('time', [('min', '>> import tempfile -// >>> fname = tempfile.mkstemp()[1] -// >>> x.tofile(fname) -// -// Read the raw data from disk: -// -// >>> np.fromfile(fname, dtype=dt) -// array([((10, 0), 98.25)], -// dtype=[('time', [('min', '>> np.save(fname, x) -// >>> np.load(fname + '.npy') -// array([((10, 0), 98.25)], -// dtype=[('time', [('min', '>> import numpy as np -// >>> np.array_repr(np.array([1,2])) -// 'array([1, 2])' -// >>> np.array_repr(np.ma.array([0.])) -// 'MaskedArray([0.])' -// >>> np.array_repr(np.array([], np.int32)) -// 'array([], dtype=int32)' -// -// >>> x = np.array([1e-6, 4e-7, 2, 3]) -// >>> np.array_repr(x, precision=6, suppress_small=True) -// 'array([0.000001, 0. , 2. , 3. ])' -// -// -// -//go:linkname ArrayRepr py.array_repr -func ArrayRepr(arr *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object -// -// Return a string representation of the data in an array. -// -// The data in the array is returned as a single string. This function is -// similar to `array_repr`, the difference being that `array_repr` also -// returns information on the kind of array and its data type. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// max_line_width : int, optional -// Inserts newlines if text is longer than `max_line_width`. -// Defaults to ``numpy.get_printoptions()['linewidth']``. -// precision : int, optional -// Floating point precision. -// Defaults to ``numpy.get_printoptions()['precision']``. -// suppress_small : bool, optional -// Represent numbers "very close" to zero as zero; default is False. -// Very close is defined by precision: if the precision is 8, e.g., -// numbers smaller (in absolute value) than 5e-9 are represented as -// zero. -// Defaults to ``numpy.get_printoptions()['suppress']``. -// -// See Also -// -------- -// array2string, array_repr, set_printoptions -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.array_str(np.arange(3)) -// '[0 1 2]' -// -// -// -//go:linkname ArrayStr py.array_str -func ArrayStr(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object -// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Inverse sine, element-wise. +// Inverse sine, element-wise. // // Parameters // ---------- @@ -1569,7 +1283,6 @@ func ArrayStr(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppr // // Examples // -------- -// >>> import numpy as np // >>> np.arcsin(1) # pi/2 // 1.5707963267948966 // >>> np.arcsin(-1) # -pi/2 @@ -1577,9 +1290,57 @@ func ArrayStr(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppr // >>> np.arcsin(0) // 0.0 // -//go:linkname Asin py.asin -func Asin(__llgo_va_list ...interface{}) *py.Object -// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Arcsin py.arcsin +func Arcsin(x *py.Object, out *py.Object) *py.Object +// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from degrees to radians. +// +// Parameters +// ---------- +// x : array_like +// Angles in degrees. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The corresponding angle in radians. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// rad2deg : Convert angles from radians to degrees. +// unwrap : Remove large jumps in angle by wrapping. +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// ``deg2rad(x)`` is ``x * pi / 180``. +// +// Examples +// -------- +// >>> np.deg2rad(180) +// 3.1415926535897931 +// +//go:linkname Deg2rad py.deg2rad +func Deg2rad(x *py.Object, out *py.Object) *py.Object +// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // // Decompose the elements of x into mantissa and twos exponent. // @@ -1630,2351 +1391,1879 @@ func Asin(__llgo_va_list ...interface{}) *py.Object // // Examples // -------- -// >>> import numpy as np // >>> x = np.arange(9) // >>> y1, y2 = np.frexp(x) // >>> y1 // array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, // 0.5 ]) // >>> y2 -// array([0, 1, 2, 2, 3, 3, 3, 3, 4], dtype=int32) +// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) // >>> y1 * 2**y2 // array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) // //go:linkname Frexp py.frexp func Frexp(x *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object // -// Return a new array of given shape and type, filled with ones. +// Trim the leading and/or trailing zeros from a 1-D array or sequence. // // Parameters // ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// The desired data-type for the array, e.g., `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: C -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. -// -// .. versionadded:: 2.0.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 +// filt : 1-D array or sequence +// Input array. +// trim : str, optional +// A string with 'f' representing trim from front and 'b' to trim from +// back. Default is 'fb', trim zeros from both front and back of the +// array. // // Returns // ------- -// out : ndarray -// Array of ones with the given shape, dtype, and order. -// -// See Also -// -------- -// ones_like : Return an array of ones with shape and type of input. -// empty : Return a new uninitialized array. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. +// trimmed : 1-D array or sequence +// The result of trimming the input. The input data type is preserved. // // Examples // -------- -// >>> import numpy as np -// >>> np.ones(5) -// array([1., 1., 1., 1., 1.]) +// >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0)) +// >>> np.trim_zeros(a) +// array([1, 2, 3, 0, 2, 1]) // -// >>> np.ones((5,), dtype=int) -// array([1, 1, 1, 1, 1]) +// >>> np.trim_zeros(a, 'b') +// array([0, 0, 0, ..., 0, 2, 1]) // -// >>> np.ones((2, 1)) -// array([[1.], -// [1.]]) +// The input data type is preserved, list/tuple in means list/tuple out. // -// >>> s = (2,2) -// >>> np.ones(s) -// array([[1., 1.], -// [1., 1.]]) +// >>> np.trim_zeros([0, 1, 2, 0]) +// [1, 2] // // // -//go:linkname Ones py.ones -func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object -// Return a contiguous flattened array. +//go:linkname TrimZeros py.trim_zeros +func TrimZeros(filt *py.Object, trim *py.Object) *py.Object // -// A 1-D array, containing the elements of the input, is returned. A copy is -// made only if needed. +// Return the Hanning window. // -// As of NumPy 1.10, the returned array will have the same type as the input -// array. (for example, a masked array will be returned for a masked array -// input) +// The Hanning window is a taper formed by using a weighted cosine. // // Parameters // ---------- -// a : array_like -// Input array. The elements in `a` are read in the order specified by -// `order`, and packed as a 1-D array. -// order : {'C','F', 'A', 'K'}, optional -// -// The elements of `a` are read using this index order. 'C' means -// to index the elements in row-major, C-style order, -// with the last axis index changing fastest, back to the first -// axis index changing slowest. 'F' means to index the elements -// in column-major, Fortran-style order, with the -// first index changing fastest, and the last index changing -// slowest. Note that the 'C' and 'F' options take no account of -// the memory layout of the underlying array, and only refer to -// the order of axis indexing. 'A' means to read the elements in -// Fortran-like index order if `a` is Fortran *contiguous* in -// memory, C-like order 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. +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. // // Returns // ------- -// y : array_like -// y is a contiguous 1-D array of the same subtype as `a`, -// with shape ``(a.size,)``. -// Note that matrices are special cased for backward compatibility, -// if `a` is a matrix, then y is a 1-D ndarray. +// out : ndarray, shape(M,) +// The window, with the maximum value normalized to one (the value +// one appears only if `M` is odd). // // See Also // -------- -// ndarray.flat : 1-D iterator over an array. -// ndarray.flatten : 1-D array copy of the elements of an array -// in row-major order. -// ndarray.reshape : Change the shape of an array without changing its data. +// bartlett, blackman, hamming, kaiser // // Notes // ----- -// In row-major, C-style order, in two dimensions, the row index -// varies the slowest, and the column index the quickest. This can -// be generalized to multiple dimensions, where row-major order -// implies that the index along the first axis varies slowest, and -// the index along the last quickest. The opposite holds for -// column-major, Fortran-style index ordering. -// -// When a view is desired in as many cases as possible, ``arr.reshape(-1)`` -// may be preferable. However, ``ravel`` supports ``K`` in the optional -// ``order`` argument while ``reshape`` does not. -// -// Examples -// -------- -// It is equivalent to ``reshape(-1, order=order)``. -// -// >>> import numpy as np -// >>> x = np.array([[1, 2, 3], [4, 5, 6]]) -// >>> np.ravel(x) -// array([1, 2, 3, 4, 5, 6]) +// The Hanning window is defined as // -// >>> x.reshape(-1) -// array([1, 2, 3, 4, 5, 6]) +// .. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 // -// >>> np.ravel(x, order='F') -// array([1, 4, 2, 5, 3, 6]) +// The Hanning was named for Julius von Hann, an Austrian meteorologist. +// It is also known as the Cosine Bell. Some authors prefer that it be +// called a Hann window, to help avoid confusion with the very similar +// Hamming window. // -// When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering: +// Most references to the Hanning window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. 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. // -// >>> np.ravel(x.T) -// array([1, 4, 2, 5, 3, 6]) -// >>> np.ravel(x.T, order='A') -// array([1, 2, 3, 4, 5, 6]) +// References +// ---------- +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 106-108. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. // -// When ``order`` is 'K', it will preserve orderings that are neither 'C' -// nor 'F', but won't reverse axes: +// Examples +// -------- +// >>> np.hanning(12) +// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, +// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, +// 0.07937323, 0. ]) // -// >>> a = np.arange(3)[::-1]; a -// array([2, 1, 0]) -// >>> a.ravel(order='C') -// array([2, 1, 0]) -// >>> a.ravel(order='K') -// array([2, 1, 0]) +// Plot the window and its frequency response: // -// >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a -// array([[[ 0, 2, 4], -// [ 1, 3, 5]], -// [[ 6, 8, 10], -// [ 7, 9, 11]]]) -// >>> a.ravel(order='C') -// array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11]) -// >>> a.ravel(order='K') -// array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hanning(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hann window") +// Text(0.5, 1.0, 'Hann window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() // +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of the Hann window") +// Text(0.5, 1.0, 'Frequency response of the Hann window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() // // -//go:linkname Ravel py.ravel -func Ravel(a *py.Object, order *py.Object) *py.Object // -// Find the set exclusive-or of two arrays. +//go:linkname Hanning py.hanning +func Hanning(M *py.Object) *py.Object // -// Return the sorted, unique values that are in only one (not both) of the -// input arrays. +// Create a two-dimensional array with the flattened input as a diagonal. // // Parameters // ---------- -// ar1, ar2 : array_like -// Input arrays. -// assume_unique : bool -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. Default is False. +// v : array_like +// Input data, which is flattened and set as the `k`-th +// diagonal of the output. +// k : int, optional +// Diagonal to set; 0, the default, corresponds to the "main" diagonal, +// a positive (negative) `k` giving the number of the diagonal above +// (below) the main. // // Returns // ------- -// setxor1d : ndarray -// Sorted 1D array of unique values that are in only one of the input -// arrays. +// out : ndarray +// The 2-D output array. +// +// See Also +// -------- +// diag : MATLAB work-alike for 1-D and 2-D arrays. +// diagonal : Return specified diagonals. +// trace : Sum along diagonals. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([1, 2, 3, 2, 4]) -// >>> b = np.array([2, 3, 5, 7, 5]) -// >>> np.setxor1d(a,b) -// array([1, 4, 5, 7]) +// >>> np.diagflat([[1,2], [3,4]]) +// array([[1, 0, 0, 0], +// [0, 2, 0, 0], +// [0, 0, 3, 0], +// [0, 0, 0, 4]]) // +// >>> np.diagflat([1,2], 1) +// array([[0, 1, 0], +// [0, 0, 2], +// [0, 0, 0]]) // // -//go:linkname Setxor1d py.setxor1d -func Setxor1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object) *py.Object -// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Trigonometric inverse tangent, element-wise. +//go:linkname Diagflat py.diagflat +func Diagflat(v *py.Object, k *py.Object) *py.Object // -// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. +// Generate a Vandermonde matrix. // -// Parameters -// ---------- -// x : array_like -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// The columns of the output matrix are powers of the input vector. The +// order of the powers is determined by the `increasing` boolean argument. +// Specifically, when `increasing` is False, the `i`-th output column is +// the input vector raised element-wise to the power of ``N - i - 1``. Such +// a matrix with a geometric progression in each row is named for Alexandre- +// Theophile Vandermonde. // -// Returns -// ------- -// out : ndarray or scalar -// Out has the same shape as `x`. Its real part is in -// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). -// This is a scalar if `x` is a scalar. +// Parameters +// ---------- +// x : array_like +// 1-D input array. +// N : int, optional +// Number of columns in the output. If `N` is not specified, a square +// array is returned (``N = len(x)``). +// increasing : bool, optional +// Order of the powers of the columns. If True, the powers increase +// from left to right, if False (the default) they are reversed. // -// See Also -// -------- -// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) -// and the positive `x`-axis. -// angle : Argument of complex values. +// .. versionadded:: 1.9.0 // -// Notes -// ----- -// `arctan` is a multi-valued function: for each `x` there are infinitely -// many numbers `z` such that tan(`z`) = `x`. The convention is to return -// the angle `z` whose real part lies in [-pi/2, pi/2]. +// Returns +// ------- +// out : ndarray +// Vandermonde matrix. If `increasing` is False, the first column is +// ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is +// True, the columns are ``x^0, x^1, ..., x^(N-1)``. // -// For real-valued input data types, `arctan` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. +// See Also +// -------- +// polynomial.polynomial.polyvander // -// For complex-valued input, `arctan` is a complex analytic function that -// has [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous -// from the left on the former and from the right on the latter. +// Examples +// -------- +// >>> x = np.array([1, 2, 3, 5]) +// >>> N = 3 +// >>> np.vander(x, N) +// array([[ 1, 1, 1], +// [ 4, 2, 1], +// [ 9, 3, 1], +// [25, 5, 1]]) // -// The inverse tangent is also known as `atan` or tan^{-1}. +// >>> np.column_stack([x**(N-1-i) for i in range(N)]) +// array([[ 1, 1, 1], +// [ 4, 2, 1], +// [ 9, 3, 1], +// [25, 5, 1]]) // -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- +// >>> x = np.array([1, 2, 3, 5]) +// >>> np.vander(x) +// array([[ 1, 1, 1, 1], +// [ 8, 4, 2, 1], +// [ 27, 9, 3, 1], +// [125, 25, 5, 1]]) +// >>> np.vander(x, increasing=True) +// array([[ 1, 1, 1, 1], +// [ 1, 2, 4, 8], +// [ 1, 3, 9, 27], +// [ 1, 5, 25, 125]]) // -// We expect the arctan of 0 to be 0, and of 1 to be pi/4: +// The determinant of a square Vandermonde matrix is the product +// of the differences between the values of the input vector: // -// >>> import numpy as np -// >>> np.arctan([0, 1]) -// array([ 0. , 0.78539816]) +// >>> np.linalg.det(np.vander(x)) +// 48.000000000000043 # may vary +// >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1) +// 48 // -// >>> np.pi/4 -// 0.78539816339744828 // -// Plot arctan: // -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-10, 10) -// >>> plt.plot(x, np.arctan(x)) -// >>> plt.axis('tight') -// >>> plt.show() +//go:linkname Vander py.vander +func Vander(x *py.Object, N *py.Object, increasing *py.Object) *py.Object // -//go:linkname Atan py.atan -func Atan(__llgo_va_list ...interface{}) *py.Object +// Return the indices for the upper-triangle of arr. // -// Return a full array with the same shape and type as a given array. +// See `triu_indices` for full details. // // Parameters // ---------- -// a : array_like -// The shape and data-type of `a` define these same attributes of -// the returned array. -// fill_value : array_like -// Fill value. -// dtype : data-type, optional -// Overrides the data type of the result. -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `a`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. -// -// .. versionadded:: 2.0.0 +// arr : ndarray, shape(N, N) +// The indices will be valid for square arrays. +// k : int, optional +// Diagonal offset (see `triu` for details). // // Returns // ------- -// out : ndarray -// Array of `fill_value` with the same shape and type as `a`. -// -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// ones_like : Return an array of ones with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full : Return a new array of given shape filled with value. +// triu_indices_from : tuple, shape(2) of ndarray, shape(N) +// Indices for the upper-triangle of `arr`. // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(6, dtype=int) -// >>> np.full_like(x, 1) -// array([1, 1, 1, 1, 1, 1]) -// >>> np.full_like(x, 0.1) -// array([0, 0, 0, 0, 0, 0]) -// >>> np.full_like(x, 0.1, dtype=np.double) -// array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) -// >>> np.full_like(x, np.nan, dtype=np.double) -// array([nan, nan, nan, nan, nan, nan]) -// -// >>> y = np.arange(6, dtype=np.double) -// >>> 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]]]) // +// Create a 4 by 4 array. // -//go:linkname FullLike py.full_like -func FullLike(a *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) // -// Set printing options. +// Pass the array to get the indices of the upper triangular elements. // -// These options determine the way floating point numbers, arrays and -// other NumPy objects are displayed. +// >>> triui = np.triu_indices_from(a) +// >>> triui +// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) // -// Parameters -// ---------- -// precision : int or None, optional -// Number of digits of precision for floating point output (default 8). -// May be None if `floatmode` is not `fixed`, to print as many digits as -// necessary to uniquely specify the value. -// threshold : int, optional -// Total number of array elements which trigger summarization -// rather than full repr (default 1000). -// To always use the full repr without summarization, pass `sys.maxsize`. -// edgeitems : int, optional -// Number of array items in summary at beginning and end of -// each dimension (default 3). -// linewidth : int, optional -// The number of characters per line for the purpose of inserting -// line breaks (default 75). -// suppress : bool, optional -// If True, always print floating point numbers using fixed point -// notation, in which case numbers equal to zero in the current precision -// will print as zero. If False, then scientific notation is used when -// absolute value of the smallest number is < 1e-4 or the ratio of the -// maximum absolute value to the minimum is > 1e3. The default is False. -// nanstr : str, optional -// String representation of floating point not-a-number (default nan). -// infstr : str, optional -// String representation of floating point infinity (default inf). -// sign : string, either '-', '+', or ' ', optional -// Controls printing of the sign of floating-point types. If '+', always -// print the sign of positive values. If ' ', always prints a space -// (whitespace character) in the sign position of positive values. If -// '-', omit the sign character of positive values. (default '-') +// >>> a[triui] +// array([ 0, 1, 2, 3, 5, 6, 7, 10, 11, 15]) // -// .. versionchanged:: 2.0 -// The sign parameter can now be an integer type, previously -// types were floating-point types. +// This is syntactic sugar for triu_indices(). // -// formatter : dict of callables, optional -// If not None, the keys should indicate the type(s) that the respective -// formatting function applies to. Callables should return a string. -// Types that are not specified (by their corresponding keys) are handled -// by the default formatters. Individual types for which a formatter -// can be set are: +// >>> np.triu_indices(a.shape[0]) +// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) // -// - 'bool' -// - 'int' -// - 'timedelta' : a `numpy.timedelta64` -// - 'datetime' : a `numpy.datetime64` -// - 'float' -// - 'longfloat' : 128-bit floats -// - 'complexfloat' -// - 'longcomplexfloat' : composed of two 128-bit floats -// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` -// - 'object' : `np.object_` arrays +// Use the `k` parameter to return the indices for the upper triangular array +// from the k-th diagonal. // -// Other keys that can be used to set a group of types at once are: +// >>> triuim1 = np.triu_indices_from(a, k=1) +// >>> a[triuim1] +// array([ 1, 2, 3, 6, 7, 11]) // -// - 'all' : sets all types -// - 'int_kind' : sets 'int' -// - 'float_kind' : sets 'float' and 'longfloat' -// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' -// - 'str_kind' : sets 'numpystr' -// floatmode : str, optional -// Controls the interpretation of the `precision` option for -// floating-point types. Can take the following values -// (default maxprec_equal): // -// * 'fixed': Always print exactly `precision` fractional digits, -// even if this would print more or fewer digits than -// necessary to specify the value uniquely. -// * 'unique': Print the minimum number of fractional digits necessary -// to represent each value uniquely. Different elements may -// have a different number of digits. The value of the -// `precision` option is ignored. -// * 'maxprec': Print at most `precision` fractional digits, but if -// an element can be uniquely represented with fewer digits -// only print it with that many. -// * 'maxprec_equal': Print at most `precision` fractional digits, -// but if every element in the array can be uniquely -// represented with an equal number of fewer digits, use that -// many digits for all elements. -// legacy : string or `False`, optional -// If set to the string ``'1.13'`` enables 1.13 legacy printing mode. This -// approximates numpy 1.13 print output by including a space in the sign -// position of floats and different behavior for 0d arrays. This also -// enables 1.21 legacy printing mode (described below). +// See Also +// -------- +// triu_indices, triu, tril_indices_from // -// If set to the string ``'1.21'`` enables 1.21 legacy printing mode. This -// approximates numpy 1.21 print output of complex structured dtypes -// by not inserting spaces after commas that separate fields and after -// colons. +// Notes +// ----- +// .. versionadded:: 1.4.0 // -// If set to ``'1.25'`` approximates printing of 1.25 which mainly means -// that numeric scalars are printed without their type information, e.g. -// as ``3.0`` rather than ``np.float64(3.0)``. // -// If set to ``'2.1'``, shape information is not given when arrays are -// summarized (i.e., multiple elements replaced with ``...``). // -// If set to ``'2.2'``, the transition to use scientific notation for -// printing ``np.float16`` and ``np.float32`` types may happen later or -// not at all for larger values. +//go:linkname TriuIndicesFrom py.triu_indices_from +func TriuIndicesFrom(arr *py.Object, k *py.Object) *py.Object +// set_numeric_ops(op1=func1, op2=func2, ...) // -// If set to `False`, disables legacy mode. +// Set numerical operators for array objects. // -// Unrecognized strings will be ignored with a warning for forward -// compatibility. +// .. deprecated:: 1.16 // -// .. versionchanged:: 1.22.0 -// .. versionchanged:: 2.2 +// For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`. +// For ndarray subclasses, define the ``__array_ufunc__`` method and +// override the relevant ufunc. // -// override_repr: callable, optional -// If set a passed function will be used for generating arrays' repr. -// Other options will be ignored. +// Parameters +// ---------- +// op1, op2, ... : callable +// Each ``op = func`` pair describes an operator to be replaced. +// For example, ``add = lambda x, y: np.add(x, y) % 5`` would replace +// addition by modulus 5 addition. // -// See Also -// -------- -// get_printoptions, printoptions, array2string +// Returns +// ------- +// saved_ops : list of callables +// A list of all operators, stored before making replacements. // // Notes // ----- -// `formatter` is always reset with a call to `set_printoptions`. +// .. warning:: +// Use with care! Incorrect usage may lead to memory errors. // -// Use `printoptions` as a context manager to set the values temporarily. +// A function replacing an operator cannot make use of that operator. +// For example, when replacing add, you may not use ``+``. Instead, +// directly call ufuncs. // // Examples // -------- -// Floating point precision can be set: +// >>> def add_mod5(x, y): +// ... return np.add(x, y) % 5 +// ... +// >>> old_funcs = np.set_numeric_ops(add=add_mod5) // -// >>> import numpy as np -// >>> np.set_printoptions(precision=4) -// >>> np.array([1.123456789]) -// [1.1235] +// >>> x = np.arange(12).reshape((3, 4)) +// >>> x + x +// array([[0, 2, 4, 1], +// [3, 0, 2, 4], +// [1, 3, 0, 2]]) // -// Long arrays can be summarised: +// >>> ignore = np.set_numeric_ops(**old_funcs) # restore operators // -// >>> np.set_printoptions(threshold=5) -// >>> np.arange(10) -// array([0, 1, 2, ..., 7, 8, 9], shape=(10,)) +//go:linkname SetNumericOps py.set_numeric_ops +func SetNumericOps(op1 *py.Object, op2 *py.Object) *py.Object // -// Small results can be suppressed: +// Test whether any array element along a given axis evaluates to True. // -// >>> eps = np.finfo(float).eps -// >>> x = np.arange(4.) -// >>> x**2 - (x + eps)**2 -// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) -// >>> np.set_printoptions(suppress=True) -// >>> x**2 - (x + eps)**2 -// array([-0., -0., 0., 0.]) +// Returns single boolean if `axis` is ``None`` // -// A custom formatter can be used to display array elements as desired: +// Parameters +// ---------- +// a : array_like +// Input array or object that can be converted to an array. +// axis : None or int or tuple of ints, optional +// Axis or axes along which a logical OR reduction is performed. +// The default (``axis=None``) is to perform a logical OR over all +// the dimensions of the input array. `axis` may be negative, in +// which case it counts from the last to the first axis. // -// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) -// >>> x = np.arange(3) -// >>> x -// array([int: 0, int: -1, int: -2]) -// >>> np.set_printoptions() # formatter gets reset -// >>> x -// array([0, 1, 2]) +// .. versionadded:: 1.7.0 // -// To put back the default options, you can use: +// If this is a tuple of ints, a reduction is performed on multiple +// axes, instead of a single axis or all the axes as before. +// out : ndarray, optional +// Alternate output array in which to place the result. It must have +// the same shape as the expected output and its type is preserved +// (e.g., if it is of type float, then it will remain so, returning +// 1.0 for True and 0.0 for False, regardless of the type of `a`). +// See :ref:`ufuncs-output-type` for more details. // -// >>> np.set_printoptions(edgeitems=3, infstr='inf', -// ... linewidth=75, nanstr='nan', precision=8, -// ... suppress=False, threshold=1000, formatter=None) +// 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 input array. // -// Also to temporarily override options, use `printoptions` -// as a context manager: +// If the default value is passed, then `keepdims` will not be +// passed through to the `any` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. // -// >>> with np.printoptions(precision=2, suppress=True, threshold=5): -// ... np.linspace(0, 10, 10) -// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ], shape=(10,)) +// where : array_like of bool, optional +// Elements to include in checking for any `True` values. +// See `~numpy.ufunc.reduce` for details. // +// .. versionadded:: 1.20.0 // +// Returns +// ------- +// any : bool or ndarray +// A new boolean or `ndarray` is returned unless `out` is specified, +// in which case a reference to `out` is returned. // -//go:linkname SetPrintoptions py.set_printoptions -func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object +// See Also +// -------- +// ndarray.any : equivalent method // -// Find the unique elements of an array, and counts, inverse, and indices. +// all : Test whether all elements along a given axis evaluate to True. // -// This function is an Array API compatible alternative to:: +// Notes +// ----- +// Not a Number (NaN), positive infinity and negative infinity evaluate +// to `True` because these are not equal to zero. // -// np.unique(x, return_index=True, return_inverse=True, -// return_counts=True, equal_nan=False, sorted=False) +// Examples +// -------- +// >>> np.any([[True, False], [True, True]]) +// True // -// but returns a namedtuple for easier access to each output. +// >>> np.any([[True, False], [False, False]], axis=0) +// array([ True, False]) // -// .. note:: -// This function currently always returns a sorted result, however, -// this could change in any NumPy minor release. +// >>> np.any([-1, 0, 5]) +// True // -// Parameters -// ---------- -// x : array_like -// Input array. It will be flattened if it is not already 1-D. +// >>> np.any(np.nan) +// True // -// Returns -// ------- -// out : namedtuple -// The result containing: +// >>> np.any([[True, False], [False, False]], where=[[False], [True]]) +// False // -// * values - The unique elements of an input array. -// * indices - The first occurring indices for each unique element. -// * inverse_indices - The indices from the set of unique elements -// that reconstruct `x`. -// * counts - The corresponding counts for each unique element. +// >>> o=np.array(False) +// >>> z=np.any([-1, 4, 5], out=o) +// >>> z, o +// (array(True), array(True)) +// >>> # Check now that z is a reference to o +// >>> z is o +// True +// >>> id(z), id(o) # identity of z and o # doctest: +SKIP +// (191614240, 191614240) // -// See Also -// -------- -// unique : Find the unique elements of an array. // -// Examples -// -------- -// >>> import numpy as np -// >>> x = [1, 1, 2] -// >>> uniq = np.unique_all(x) -// >>> uniq.values -// array([1, 2]) -// >>> uniq.indices -// array([0, 2]) -// >>> uniq.inverse_indices -// array([0, 0, 1]) -// >>> uniq.counts -// array([2, 1]) // +//go:linkname Any py.any +func Any(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object) *py.Object +// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname UniqueAll py.unique_all -func UniqueAll(x *py.Object) *py.Object +// Multiply arguments element-wise. // -// Reverse the order of elements in an array along the given axis. +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays to be multiplied. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// The shape of the array is preserved, but the elements are reordered. +// Returns +// ------- +// y : ndarray +// The product of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. // -// Parameters -// ---------- -// m : array_like -// Input array. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to flip over. The default, -// axis=None, will flip over all of the axes of the input array. -// If axis is negative it counts from the last to the first axis. +// Notes +// ----- +// Equivalent to `x1` * `x2` in terms of array broadcasting. // -// If axis is a tuple of ints, flipping is performed on all of the axes -// specified in the tuple. +// Examples +// -------- +// >>> np.multiply(2.0, 4.0) +// 8.0 // -// Returns -// ------- -// out : array_like -// A view of `m` with the entries of axis reversed. Since a view is -// returned, this operation is done in constant time. +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.multiply(x1, x2) +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) // -// See Also -// -------- -// flipud : Flip an array vertically (axis=0). -// fliplr : Flip an array horizontally (axis=1). +// The ``*`` operator can be used as a shorthand for ``np.multiply`` on +// ndarrays. // -// Notes -// ----- -// flip(m, 0) is equivalent to flipud(m). +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 * x2 +// array([[ 0., 1., 4.], +// [ 0., 4., 10.], +// [ 0., 7., 16.]]) // -// flip(m, 1) is equivalent to fliplr(m). +//go:linkname Multiply py.multiply +func Multiply(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n. +// Return the elements of an array that satisfy some condition. // -// flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all -// positions. +// This is equivalent to ``np.compress(ravel(condition), ravel(arr))``. If +// `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``. // -// flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at -// position 0 and position 1. +// Note that `place` does the exact opposite of `extract`. +// +// Parameters +// ---------- +// condition : array_like +// An array whose nonzero or True entries indicate the elements of `arr` +// to extract. +// arr : array_like +// Input array of the same size as `condition`. +// +// Returns +// ------- +// extract : ndarray +// Rank 1 array of values from `arr` where `condition` is True. +// +// See Also +// -------- +// take, put, copyto, compress, place // // Examples // -------- -// >>> import numpy as np -// >>> A = np.arange(8).reshape((2,2,2)) -// >>> A -// array([[[0, 1], -// [2, 3]], -// [[4, 5], -// [6, 7]]]) -// >>> np.flip(A, 0) -// array([[[4, 5], -// [6, 7]], -// [[0, 1], -// [2, 3]]]) -// >>> np.flip(A, 1) -// array([[[2, 3], -// [0, 1]], -// [[6, 7], -// [4, 5]]]) -// >>> np.flip(A) -// array([[[7, 6], -// [5, 4]], -// [[3, 2], -// [1, 0]]]) -// >>> np.flip(A, (0, 2)) -// array([[[5, 4], -// [7, 6]], -// [[1, 0], -// [3, 2]]]) -// >>> rng = np.random.default_rng() -// >>> A = rng.normal(size=(3,4,5)) -// >>> np.all(np.flip(A,2) == A[:,:,::-1,...]) -// True +// >>> arr = np.arange(12).reshape((3, 4)) +// >>> arr +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11]]) +// >>> condition = np.mod(arr, 3)==0 +// >>> condition +// array([[ True, False, False, True], +// [False, False, True, False], +// [False, True, False, False]]) +// >>> np.extract(condition, arr) +// array([0, 3, 6, 9]) // // -//go:linkname Flip py.flip -func Flip(m *py.Object, axis *py.Object) *py.Object +// If `condition` is boolean: // -// Return the normalized sinc function. +// >>> arr[condition] +// array([0, 3, 6, 9]) // -// 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. +//go:linkname Extract py.extract +func Extract(condition *py.Object, arr *py.Object) *py.Object +// Convert the input to an array, checking for NaNs or Infs. // // Parameters // ---------- -// x : ndarray -// Array (possibly multi-dimensional) of values for which to calculate -// ``sinc(x)``. +// a : array_like +// Input data, in any form that can be converted to an array. This +// includes lists, lists of tuples, tuples, tuples of tuples, tuples +// of lists and ndarrays. Success requires no NaNs or Infs. +// dtype : data-type, optional +// By default, the data-type is inferred from the input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Memory layout. 'A' and 'K' depend on the order of input array a. +// 'C' row-major (C-style), +// 'F' column-major (Fortran-style) memory representation. +// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise +// 'K' (keep) preserve input order +// Defaults to 'C'. // // Returns // ------- // out : ndarray -// ``sinc(x)``, which has the same shape as the input. -// -// Notes -// ----- -// The name sinc is short for "sine cardinal" or "sinus cardinalis". -// -// The sinc function is used in various signal processing applications, -// including in anti-aliasing, in the construction of a Lanczos resampling -// filter, and in interpolation. +// Array interpretation of `a`. No copy is performed if the input +// is already an ndarray. If `a` is a subclass of ndarray, a base +// class ndarray is returned. // -// For bandlimited interpolation of discrete-time signals, the ideal -// interpolation kernel is proportional to the sinc function. +// Raises +// ------ +// ValueError +// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). // -// References -// ---------- -// .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web -// Resource. https://mathworld.wolfram.com/SincFunction.html -// .. [2] Wikipedia, "Sinc function", -// https://en.wikipedia.org/wiki/Sinc_function +// See Also +// -------- +// asarray : Create and array. +// asanyarray : Similar function which passes through subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfarray : Convert input to a floating point ndarray. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// fromiter : Create an array from an iterator. +// fromfunction : Construct an array by executing a function on grid +// positions. // // Examples // -------- -// >>> import numpy as np -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-4, 4, 41) -// >>> np.sinc(x) -// array([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary -// -8.90384387e-02, -5.84680802e-02, 3.89804309e-17, -// 6.68206631e-02, 1.16434881e-01, 1.26137788e-01, -// 8.50444803e-02, -3.89804309e-17, -1.03943254e-01, -// -1.89206682e-01, -2.16236208e-01, -1.55914881e-01, -// 3.89804309e-17, 2.33872321e-01, 5.04551152e-01, -// 7.56826729e-01, 9.35489284e-01, 1.00000000e+00, -// 9.35489284e-01, 7.56826729e-01, 5.04551152e-01, -// 2.33872321e-01, 3.89804309e-17, -1.55914881e-01, -// -2.16236208e-01, -1.89206682e-01, -1.03943254e-01, -// -3.89804309e-17, 8.50444803e-02, 1.26137788e-01, -// 1.16434881e-01, 6.68206631e-02, 3.89804309e-17, -// -5.84680802e-02, -8.90384387e-02, -8.40918587e-02, -// -4.92362781e-02, -3.89804309e-17]) +// Convert a list into an array. If all elements are finite +// ``asarray_chkfinite`` is identical to ``asarray``. // -// >>> plt.plot(x, np.sinc(x)) -// [] -// >>> plt.title("Sinc Function") -// Text(0.5, 1.0, 'Sinc Function') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("X") -// Text(0.5, 0, 'X') -// >>> plt.show() +// >>> a = [1, 2] +// >>> np.asarray_chkfinite(a, dtype=float) +// array([1., 2.]) // +// Raises ValueError if array_like contains Nans or Infs. // +// >>> a = [1, 2, np.inf] +// >>> try: +// ... np.asarray_chkfinite(a) +// ... except ValueError: +// ... print('ValueError') +// ... +// ValueError // -//go:linkname Sinc py.sinc -func Sinc(x *py.Object) *py.Object // -// Least squares polynomial fit. // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. +//go:linkname AsarrayChkfinite py.asarray_chkfinite +func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object // -// Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg` -// to points `(x, y)`. Returns a vector of coefficients `p` that minimises -// the squared error in the order `deg`, `deg-1`, ... `0`. +// Extract a diagonal or construct a diagonal array. // -// The `Polynomial.fit ` class -// method is recommended for new code as it is more stable numerically. See -// the documentation of the method for more information. +// See the more detailed documentation for ``numpy.diagonal`` if you use this +// function to extract a diagonal and wish to write to the resulting array; +// whether it returns a copy or a view depends on what version of numpy you +// are using. // // Parameters // ---------- -// x : array_like, shape (M,) -// x-coordinates of the M sample points ``(x[i], y[i])``. -// y : array_like, shape (M,) or (M, K) -// y-coordinates of the sample points. Several data sets of sample -// points sharing the same x-coordinates can be fitted at once by -// passing in a 2D-array that contains one dataset per column. -// deg : int -// Degree of the fitting polynomial -// rcond : float, optional -// Relative condition number of the fit. Singular values smaller than -// this relative to the largest singular value will be ignored. The -// default value is len(x)*eps, where eps is the relative precision of -// the float type, about 2e-16 in most cases. -// full : bool, optional -// Switch determining nature of return value. When it is False (the -// default) just the coefficients are returned, when True diagnostic -// information from the singular value decomposition is also returned. -// w : array_like, shape (M,), optional -// Weights. If not None, the weight ``w[i]`` applies to the unsquared -// residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are -// chosen so that the errors of the products ``w[i]*y[i]`` all have the -// same variance. When using inverse-variance weighting, use -// ``w[i] = 1/sigma(y[i])``. The default value is None. -// cov : bool or str, optional -// If given and not `False`, return not just the estimate but also its -// covariance matrix. By default, the covariance are scaled by -// chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed -// to be unreliable except in a relative sense and everything is scaled -// such that the reduced chi2 is unity. This scaling is omitted if -// ``cov='unscaled'``, as is relevant for the case that the weights are -// w = 1/sigma, with sigma known to be a reliable estimate of the -// uncertainty. +// v : array_like +// If `v` is a 2-D array, return a copy of its `k`-th diagonal. +// If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th +// diagonal. +// k : int, optional +// Diagonal in question. The default is 0. Use `k>0` for diagonals +// above the main diagonal, and `k<0` for diagonals below the main +// diagonal. // // Returns // ------- -// p : ndarray, shape (deg + 1,) or (deg + 1, K) -// Polynomial coefficients, highest power first. If `y` was 2-D, the -// coefficients for `k`-th data set are in ``p[:,k]``. +// out : ndarray +// The extracted diagonal or constructed diagonal array. // -// residuals, rank, singular_values, rcond -// These values are only returned if ``full == True`` +// See Also +// -------- +// diagonal : Return specified diagonals. +// diagflat : Create a 2-D array with the flattened input as a diagonal. +// trace : Sum along diagonals. +// triu : Upper triangle of an array. +// tril : Lower triangle of an array. // -// - residuals -- sum of squared residuals of the least squares fit -// - rank -- the effective rank of the scaled Vandermonde -// coefficient matrix -// - singular_values -- singular values of the scaled Vandermonde -// coefficient matrix -// - rcond -- value of `rcond`. +// Examples +// -------- +// >>> x = np.arange(9).reshape((3,3)) +// >>> x +// array([[0, 1, 2], +// [3, 4, 5], +// [6, 7, 8]]) // -// For more details, see `numpy.linalg.lstsq`. +// >>> np.diag(x) +// array([0, 4, 8]) +// >>> np.diag(x, k=1) +// array([1, 5]) +// >>> np.diag(x, k=-1) +// array([3, 7]) // -// V : ndarray, shape (deg + 1, deg + 1) or (deg + 1, deg + 1, K) -// Present only if ``full == False`` and ``cov == True``. The covariance -// matrix of the polynomial coefficient estimates. The diagonal of -// this matrix are the variance estimates for each coefficient. If y -// is a 2-D array, then the covariance matrix for the `k`-th data set -// are in ``V[:,:,k]`` +// >>> np.diag(np.diag(x)) +// array([[0, 0, 0], +// [0, 4, 0], +// [0, 0, 8]]) // // -// Warns -// ----- -// RankWarning -// The rank of the coefficient matrix in the least-squares fit is -// deficient. The warning is only raised if ``full == False``. // -// The warnings can be turned off by +//go:linkname Diag py.diag +func Diag(v *py.Object, k *py.Object) *py.Object // -// >>> import warnings -// >>> warnings.simplefilter('ignore', np.exceptions.RankWarning) +// Lower triangle of an array. +// +// Return a copy of an array with elements above the `k`-th diagonal zeroed. +// For arrays with ``ndim`` exceeding 2, `tril` will apply to the final two +// axes. +// +// Parameters +// ---------- +// m : array_like, shape (..., M, N) +// Input array. +// k : int, optional +// Diagonal above which to zero elements. `k = 0` (the default) is the +// main diagonal, `k < 0` is below it and `k > 0` is above. +// +// Returns +// ------- +// tril : ndarray, shape (..., M, N) +// Lower triangle of `m`, of same shape and data-type as `m`. // // See Also // -------- -// polyval : Compute polynomial values. -// linalg.lstsq : Computes a least-squares fit. -// scipy.interpolate.UnivariateSpline : Computes spline fits. -// -// Notes -// ----- -// The solution minimizes the squared error +// triu : same thing, only for the upper triangle // -// .. math:: -// E = \sum_{j=0}^k |p(x_j) - y_j|^2 +// Examples +// -------- +// >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1) +// array([[ 0, 0, 0], +// [ 4, 0, 0], +// [ 7, 8, 0], +// [10, 11, 12]]) // -// in the equations:: +// >>> np.tril(np.arange(3*4*5).reshape(3, 4, 5)) +// array([[[ 0, 0, 0, 0, 0], +// [ 5, 6, 0, 0, 0], +// [10, 11, 12, 0, 0], +// [15, 16, 17, 18, 0]], +// [[20, 0, 0, 0, 0], +// [25, 26, 0, 0, 0], +// [30, 31, 32, 0, 0], +// [35, 36, 37, 38, 0]], +// [[40, 0, 0, 0, 0], +// [45, 46, 0, 0, 0], +// [50, 51, 52, 0, 0], +// [55, 56, 57, 58, 0]]]) // -// x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0] -// x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1] -// ... -// x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k] // -// The coefficient matrix of the coefficients `p` is a Vandermonde matrix. // -// `polyfit` issues a `~exceptions.RankWarning` when the least-squares fit is -// badly conditioned. This implies that the best fit is not well-defined due -// to numerical error. The results may be improved by lowering the polynomial -// degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter -// can also be set to a value smaller than its default, but the resulting -// fit may be spurious: including contributions from the small singular -// values can add numerical noise to the result. +//go:linkname Tril py.tril +func Tril(m *py.Object, k *py.Object) *py.Object // -// Note that fitting polynomial coefficients is inherently badly conditioned -// when the degree of the polynomial is large or the interval of sample points -// is badly centered. The quality of the fit should always be checked in these -// cases. When polynomial fits are not satisfactory, splines may be a good -// alternative. +// Pad an array. // -// References +// Parameters // ---------- -// .. [1] Wikipedia, "Curve fitting", -// https://en.wikipedia.org/wiki/Curve_fitting -// .. [2] Wikipedia, "Polynomial interpolation", -// https://en.wikipedia.org/wiki/Polynomial_interpolation +// array : array_like of rank N +// 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 +// for each axis. +// ``(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. // -// Examples -// -------- -// >>> import numpy as np -// >>> import warnings -// >>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]) -// >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0]) -// >>> z = np.polyfit(x, y, 3) -// >>> z -// array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary +// 'constant' (default) +// Pads with a constant value. +// 'edge' +// Pads with the edge values of array. +// 'linear_ramp' +// Pads with the linear ramp between end_value and the +// array edge value. +// 'maximum' +// Pads with the maximum value of all or part of the +// vector along each axis. +// 'mean' +// Pads with the mean value of all or part of the +// vector along each axis. +// 'median' +// Pads with the median value of all or part of the +// vector along each axis. +// 'minimum' +// Pads with the minimum value of all or part of the +// vector along each axis. +// 'reflect' +// Pads with the reflection of the vector mirrored on +// the first and last values of the vector along each +// axis. +// 'symmetric' +// Pads with the reflection of the vector mirrored +// along the edge of the array. +// 'wrap' +// Pads with the wrap of the vector along the axis. +// The first values are used to pad the end and the +// end values are used to pad the beginning. +// 'empty' +// Pads with undefined values. // -// It is convenient to use `poly1d` objects for dealing with polynomials: +// .. versionadded:: 1.17 // -// >>> p = np.poly1d(z) -// >>> p(0.5) -// 0.6143849206349179 # may vary -// >>> p(3.5) -// -0.34732142857143039 # may vary -// >>> p(10) -// 22.579365079365115 # may vary +// +// Padding function, see Notes. +// stat_length : sequence or int, optional +// Used in 'maximum', 'mean', 'median', and 'minimum'. Number of +// values at edge of each axis used to calculate the statistic value. // -// High-order polynomials may oscillate wildly: +// ``((before_1, after_1), ... (before_N, after_N))`` unique statistic +// lengths for each axis. // -// >>> with warnings.catch_warnings(): -// ... warnings.simplefilter('ignore', np.exceptions.RankWarning) -// ... p30 = np.poly1d(np.polyfit(x, y, 30)) -// ... -// >>> p30(4) -// -0.80000000000000204 # may vary -// >>> p30(5) -// -0.99999999999999445 # may vary -// >>> p30(4.5) -// -0.10547061179440398 # may vary +// ``(before, after)`` or ``((before, after),)`` yields same before +// and after statistic lengths for each axis. // -// Illustration: +// ``(stat_length,)`` or ``int`` is a shortcut for +// ``before = after = statistic`` length for all axes. // -// >>> import matplotlib.pyplot as plt -// >>> xp = np.linspace(-2, 6, 100) -// >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--') -// >>> plt.ylim(-2,2) -// (-2, 2) -// >>> plt.show() +// Default is ``None``, to use the entire axis. +// constant_values : sequence or scalar, optional +// Used in 'constant'. The values to set the padded values for each +// axis. +// +// ``((before_1, after_1), ... (before_N, after_N))`` unique pad 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. // -//go:linkname Polyfit py.polyfit -func Polyfit(x *py.Object, y *py.Object, deg *py.Object, rcond *py.Object, full *py.Object, w *py.Object, cov *py.Object) *py.Object +// Default is 0. +// end_values : sequence or scalar, optional +// Used in 'linear_ramp'. The values used for the ending value of the +// linear_ramp and that will form the edge of the padded array. // -// Generate a Vandermonde matrix. +// ``((before_1, after_1), ... (before_N, after_N))`` unique end values +// for each axis. // -// The columns of the output matrix are powers of the input vector. The -// order of the powers is determined by the `increasing` boolean argument. -// Specifically, when `increasing` is False, the `i`-th output column is -// the input vector raised element-wise to the power of ``N - i - 1``. Such -// a matrix with a geometric progression in each row is named for Alexandre- -// Theophile Vandermonde. +// ``(before, after)`` or ``((before, after),)`` yields same before +// and after end values for each axis. // -// Parameters -// ---------- -// x : array_like -// 1-D input array. -// N : int, optional -// Number of columns in the output. If `N` is not specified, a square -// array is returned (``N = len(x)``). -// increasing : bool, optional -// Order of the powers of the columns. If True, the powers increase -// from left to right, if False (the default) they are reversed. +// ``(constant,)`` or ``constant`` is a shortcut for +// ``before = after = constant`` for all axes. +// +// Default is 0. +// reflect_type : {'even', 'odd'}, optional +// Used in 'reflect', and 'symmetric'. The 'even' style is the +// default with an unaltered reflection around the edge value. For +// the 'odd' style, the extended part of the array is created by +// subtracting the reflected values from two times the edge value. // // Returns // ------- -// out : ndarray -// Vandermonde matrix. If `increasing` is False, the first column is -// ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is -// True, the columns are ``x^0, x^1, ..., x^(N-1)``. +// pad : ndarray +// Padded array of rank equal to `array` with shape increased +// according to `pad_width`. // -// See Also -// -------- -// polynomial.polynomial.polyvander +// Notes +// ----- +// .. versionadded:: 1.7.0 // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([1, 2, 3, 5]) -// >>> N = 3 -// >>> np.vander(x, N) -// array([[ 1, 1, 1], -// [ 4, 2, 1], -// [ 9, 3, 1], -// [25, 5, 1]]) +// For an array with rank greater than 1, some of the padding of later +// axes is calculated from padding of previous axes. This is easiest to +// think about with a rank 2 array where the corners of the padded array +// are calculated by using padded values from the first axis. // -// >>> np.column_stack([x**(N-1-i) for i in range(N)]) -// array([[ 1, 1, 1], -// [ 4, 2, 1], -// [ 9, 3, 1], -// [25, 5, 1]]) +// The padding function, if used, should modify a rank 1 array in-place. It +// has the following signature:: // -// >>> x = np.array([1, 2, 3, 5]) -// >>> np.vander(x) -// array([[ 1, 1, 1, 1], -// [ 8, 4, 2, 1], -// [ 27, 9, 3, 1], -// [125, 25, 5, 1]]) -// >>> np.vander(x, increasing=True) -// array([[ 1, 1, 1, 1], -// [ 1, 2, 4, 8], -// [ 1, 3, 9, 27], -// [ 1, 5, 25, 125]]) +// padding_func(vector, iaxis_pad_width, iaxis, kwargs) // -// The determinant of a square Vandermonde matrix is the product -// of the differences between the values of the input vector: +// where // -// >>> np.linalg.det(np.vander(x)) -// 48.000000000000043 # may vary -// >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1) -// 48 +// vector : ndarray +// A rank 1 array already padded with zeros. Padded values are +// vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:]. +// iaxis_pad_width : tuple +// A 2-tuple of ints, iaxis_pad_width[0] represents the number of +// values padded at the beginning of vector where +// iaxis_pad_width[1] represents the number of values padded at +// the end of vector. +// iaxis : int +// The axis currently being calculated. +// kwargs : dict +// Any keyword arguments the function requires. // +// Examples +// -------- +// >>> a = [1, 2, 3, 4, 5] +// >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6)) +// array([4, 4, 1, ..., 6, 6, 6]) // +// >>> np.pad(a, (2, 3), 'edge') +// array([1, 1, 1, ..., 5, 5, 5]) // -//go:linkname Vander py.vander -func Vander(x *py.Object, N *py.Object, increasing *py.Object) *py.Object +// >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4)) +// array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4]) // -// Compute the variance along the specified axis. +// >>> np.pad(a, (2,), 'maximum') +// array([5, 5, 1, 2, 3, 4, 5, 5, 5]) // -// Returns the variance of the array elements, a measure of the spread of a -// distribution. The variance is computed for the flattened array by -// default, otherwise over the specified axis. +// >>> np.pad(a, (2,), 'mean') +// array([3, 3, 1, 2, 3, 4, 5, 3, 3]) // -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose variance is desired. If `a` is not an -// array, a conversion is attempted. -// axis : None or int or tuple of ints, optional -// Axis or axes along which the variance is computed. The default is to -// compute the variance of the flattened array. -// If this is a tuple of ints, a variance is performed over multiple axes, -// instead of a single axis or all the axes as before. -// dtype : data-type, optional -// Type to use in computing the variance. For arrays of integer type -// the default is `float64`; for arrays of float types it is the same as -// the array type. -// out : ndarray, optional -// Alternate output array in which to place the result. It must have -// the same shape as the expected output, but the type is cast if -// necessary. -// ddof : {int, float}, optional -// "Delta Degrees of Freedom": the divisor used in the calculation is -// ``N - ddof``, where ``N`` represents the number of elements. By -// default `ddof` is zero. See notes for details about use of `ddof`. -// 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 input array. +// >>> np.pad(a, (2,), 'median') +// array([3, 3, 1, 2, 3, 4, 5, 3, 3]) // -// If the default value is passed, then `keepdims` will not be -// passed through to the `var` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// where : array_like of bool, optional -// Elements to include in the variance. See `~numpy.ufunc.reduce` for -// details. +// >>> a = [[1, 2], [3, 4]] +// >>> np.pad(a, ((3, 2), (2, 3)), 'minimum') +// array([[1, 1, 1, 2, 1, 1, 1], +// [1, 1, 1, 2, 1, 1, 1], +// [1, 1, 1, 2, 1, 1, 1], +// [1, 1, 1, 2, 1, 1, 1], +// [3, 3, 3, 4, 3, 3, 3], +// [1, 1, 1, 2, 1, 1, 1], +// [1, 1, 1, 2, 1, 1, 1]]) // -// .. versionadded:: 1.20.0 +// >>> a = [1, 2, 3, 4, 5] +// >>> np.pad(a, (2, 3), 'reflect') +// array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2]) // -// mean : array like, optional -// Provide the mean to prevent its recalculation. The mean should have -// a shape as if it was calculated with ``keepdims=True``. -// The axis for the calculation of the mean should be the same as used in -// the call to this var function. +// >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd') +// array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8]) // -// .. versionadded:: 2.0.0 +// >>> np.pad(a, (2, 3), 'symmetric') +// array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3]) +// +// >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd') +// array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7]) +// +// >>> np.pad(a, (2, 3), 'wrap') +// array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3]) +// +// >>> def pad_with(vector, pad_width, iaxis, kwargs): +// ... pad_value = kwargs.get('padder', 10) +// ... vector[:pad_width[0]] = pad_value +// ... vector[-pad_width[1]:] = pad_value +// >>> a = np.arange(6) +// >>> a = a.reshape((2, 3)) +// >>> np.pad(a, 2, pad_with) +// array([[10, 10, 10, 10, 10, 10, 10], +// [10, 10, 10, 10, 10, 10, 10], +// [10, 10, 0, 1, 2, 10, 10], +// [10, 10, 3, 4, 5, 10, 10], +// [10, 10, 10, 10, 10, 10, 10], +// [10, 10, 10, 10, 10, 10, 10]]) +// >>> np.pad(a, 2, pad_with, padder=100) +// array([[100, 100, 100, 100, 100, 100, 100], +// [100, 100, 100, 100, 100, 100, 100], +// [100, 100, 0, 1, 2, 100, 100], +// [100, 100, 3, 4, 5, 100, 100], +// [100, 100, 100, 100, 100, 100, 100], +// [100, 100, 100, 100, 100, 100, 100]]) +// +// +//go:linkname Pad py.pad +func Pad(array *py.Object, padWidth *py.Object, mode *py.Object) *py.Object +// +// vdot(a, b, /) +// +// Return the dot product of two vectors. +// +// The vdot(`a`, `b`) function handles complex numbers differently than +// dot(`a`, `b`). If the first argument is complex the complex conjugate +// of the first argument is used for the calculation of the dot product. // -// correction : {int, float}, optional -// Array API compatible name for the ``ddof`` parameter. Only one of them -// can be provided at the same time. +// Note that `vdot` handles multidimensional arrays differently than `dot`: +// it does *not* perform a matrix product, but flattens input arguments +// to 1-D vectors first. Consequently, it should only be used for vectors. // -// .. versionadded:: 2.0.0 +// Parameters +// ---------- +// a : array_like +// If `a` is complex the complex conjugate is taken before calculation +// of the dot product. +// b : array_like +// Second argument to the dot product. // // Returns // ------- -// variance : ndarray, see dtype parameter above -// If ``out=None``, returns a new array containing the variance; -// otherwise, a reference to the output array is returned. +// output : ndarray +// Dot product of `a` and `b`. Can be an int, float, or +// complex depending on the types of `a` and `b`. // // See Also // -------- -// std, mean, nanmean, nanstd, nanvar -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// There are several common variants of the array variance calculation. -// Assuming the input `a` is a one-dimensional NumPy array and ``mean`` is -// either provided as an argument or computed as ``a.mean()``, NumPy -// computes the variance of an array as:: -// -// N = len(a) -// d2 = abs(a - mean)**2 # abs is for complex `a` -// var = d2.sum() / (N - ddof) # note use of `ddof` -// -// Different values of the argument `ddof` are useful in different -// contexts. NumPy's default ``ddof=0`` corresponds with the expression: +// dot : Return the dot product without using the complex conjugate of the +// first argument. // -// .. math:: +// Examples +// -------- +// >>> a = np.array([1+2j,3+4j]) +// >>> b = np.array([5+6j,7+8j]) +// >>> np.vdot(a, b) +// (70-8j) +// >>> np.vdot(b, a) +// (70+8j) // -// \frac{\sum_i{|a_i - \bar{a}|^2 }}{N} +// Note that higher-dimensional arrays are flattened! // -// which is sometimes called the "population variance" in the field of -// statistics because it applies the definition of variance to `a` as if `a` -// were a complete population of possible observations. +// >>> a = np.array([[1, 4], [5, 6]]) +// >>> b = np.array([[4, 1], [2, 2]]) +// >>> np.vdot(a, b) +// 30 +// >>> np.vdot(b, a) +// 30 +// >>> 1*4 + 4*1 + 5*2 + 6*2 +// 30 // -// Many other libraries define the variance of an array differently, e.g.: // -// .. math:: // -// \frac{\sum_i{|a_i - \bar{a}|^2}}{N - 1} +//go:linkname Vdot py.vdot +func Vdot(a *py.Object, b *py.Object) *py.Object // -// In statistics, the resulting quantity is sometimes called the "sample -// variance" because if `a` is a random sample from a larger population, -// this calculation provides an unbiased estimate of the variance of the -// population. The use of :math:`N-1` in the denominator is often called -// "Bessel's correction" because it corrects for bias (toward lower values) -// in the variance estimate introduced when the sample mean of `a` is used -// in place of the true mean of the population. For this quantity, use -// ``ddof=1``. +// Replaces specified elements of an array with given values. // -// Note that for complex numbers, the absolute value is taken before -// squaring, so that the result is always real and nonnegative. +// The indexing works on the flattened target array. `put` is roughly +// equivalent to: // -// For floating-point input, the variance is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for `float32` (see example -// below). Specifying a higher-accuracy accumulator using the ``dtype`` -// keyword can alleviate this issue. +// :: // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> np.var(a) -// 1.25 -// >>> np.var(a, axis=0) -// array([1., 1.]) -// >>> np.var(a, axis=1) -// array([0.25, 0.25]) +// a.flat[ind] = v // -// In single precision, var() can be inaccurate: +// Parameters +// ---------- +// a : ndarray +// Target array. +// ind : array_like +// Target indices, interpreted as integers. +// v : array_like +// Values to place in `a` at target indices. If `v` is shorter than +// `ind` it will be repeated as necessary. +// mode : {'raise', 'wrap', 'clip'}, optional +// Specifies how out-of-bounds indices will behave. // -// >>> a = np.zeros((2, 512*512), dtype=np.float32) -// >>> a[0, :] = 1.0 -// >>> a[1, :] = 0.1 -// >>> np.var(a) -// np.float32(0.20250003) +// * 'raise' -- raise an error (default) +// * 'wrap' -- wrap around +// * 'clip' -- clip to the range // -// Computing the variance in float64 is more accurate: +// 'clip' mode means that all indices that are too large are replaced +// by the index that addresses the last element along that axis. Note +// that this disables indexing with negative numbers. In 'raise' mode, +// if an exception occurs the target array may still be modified. // -// >>> np.var(a, dtype=np.float64) -// 0.20249999932944759 # may vary -// >>> ((1-0.55)**2 + (0.1-0.55)**2)/2 -// 0.2025 +// See Also +// -------- +// putmask, place +// put_along_axis : Put elements by matching the array and the index arrays // -// Specifying a where argument: +// Examples +// -------- +// >>> a = np.arange(5) +// >>> np.put(a, [0, 2], [-44, -55]) +// >>> a +// array([-44, 1, -55, 3, 4]) // -// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) -// >>> np.var(a) -// 6.833333333333333 # may vary -// >>> np.var(a, where=[[True], [True], [False]]) -// 4.0 +// >>> a = np.arange(5) +// >>> np.put(a, 22, -5, mode='clip') +// >>> a +// array([ 0, 1, 2, 3, -5]) // -// Using the mean keyword to save computation time: // -// >>> import numpy as np -// >>> from timeit import timeit -// >>> -// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) -// >>> mean = np.mean(a, axis=1, keepdims=True) -// >>> -// >>> g = globals() -// >>> n = 10000 -// >>> t1 = timeit("var = np.var(a, axis=1, mean=mean)", globals=g, number=n) -// >>> t2 = timeit("var = np.var(a, axis=1)", globals=g, number=n) -// >>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%') -// #doctest: +SKIP -// Percentage execution time saved 32% // +//go:linkname Put py.put +func Put(a *py.Object, ind *py.Object, v *py.Object, mode *py.Object) *py.Object // +// Return the size of the buffer used in ufuncs. // -//go:linkname Var py.var -func Var(__llgo_va_list ...interface{}) *py.Object +// Returns +// ------- +// getbufsize : int +// Size of ufunc buffer in bytes. // -// Find the unique elements of `x` and indices to reconstruct `x`. // -// This function is an Array API compatible alternative to:: // -// np.unique(x, return_inverse=True, equal_nan=False, sorted=False) +//go:linkname Getbufsize py.getbufsize +func Getbufsize() *py.Object // -// but returns a namedtuple for easier access to each output. +// Convert inputs to arrays with at least one dimension. // -// .. note:: -// This function currently always returns a sorted result, however, -// this could change in any NumPy minor release. +// Scalar inputs are converted to 1-dimensional arrays, whilst +// higher-dimensional inputs are preserved. // // Parameters // ---------- -// x : array_like -// Input array. It will be flattened if it is not already 1-D. +// arys1, arys2, ... : array_like +// One or more input arrays. // // Returns // ------- -// out : namedtuple -// The result containing: -// -// * values - The unique elements of an input array. -// * inverse_indices - The indices from the set of unique elements -// that reconstruct `x`. +// ret : ndarray +// An array, or list of arrays, each with ``a.ndim >= 1``. +// Copies are made only if necessary. // // See Also // -------- -// unique : Find the unique elements of an array. +// atleast_2d, atleast_3d // // Examples // -------- -// >>> import numpy as np -// >>> x = [1, 1, 2] -// >>> uniq = np.unique_inverse(x) -// >>> uniq.values -// array([1, 2]) -// >>> uniq.inverse_indices -// array([0, 0, 1]) +// >>> np.atleast_1d(1.0) +// array([1.]) // +// >>> x = np.arange(9.0).reshape(3,3) +// >>> np.atleast_1d(x) +// array([[0., 1., 2.], +// [3., 4., 5.], +// [6., 7., 8.]]) +// >>> np.atleast_1d(x) is x +// True // -//go:linkname UniqueInverse py.unique_inverse -func UniqueInverse(x *py.Object) *py.Object +// >>> np.atleast_1d(1, [3, 4]) +// [array([1]), array([3, 4])] // -// Compute the weighted average along the specified axis. // -// Parameters -// ---------- -// a : array_like -// Array containing data to be averaged. If `a` is not an array, a -// conversion is attempted. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to average `a`. The default, -// `axis=None`, will average over all of the elements of the input array. -// If axis is negative it counts from the last to the first axis. -// If axis is a tuple of ints, averaging is performed on all of the axes -// specified in the tuple instead of a single axis or all the axes as -// before. -// weights : array_like, optional -// An array of weights associated with the values in `a`. Each value in -// `a` contributes to the average according to its associated weight. -// The array of weights must be the same shape as `a` if no axis is -// specified, otherwise the weights must have dimensions and shape -// consistent with `a` along the specified axis. -// If `weights=None`, then all data in `a` are assumed to have a -// weight equal to one. -// The calculation is:: // -// avg = sum(a * weights) / sum(weights) +//go:linkname Atleast1d py.atleast_1d +func Atleast1d(__llgo_va_list ...interface{}) *py.Object // -// where the sum is over all included elements. -// The only constraint on the values of `weights` is that `sum(weights)` -// must not be 0. -// returned : bool, optional -// Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`) -// 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`. +// View inputs as arrays with at least three dimensions. // -// .. versionadded:: 1.23.0 +// Parameters +// ---------- +// arys1, arys2, ... : array_like +// One or more array-like sequences. Non-array inputs are converted to +// arrays. Arrays that already have three or more dimensions are +// preserved. // // Returns // ------- -// retval, [sum_of_weights] : array_type or double -// Return the average along the specified axis. When `returned` is `True`, -// return a tuple with the average as the first element and the sum -// of the weights as the second element. `sum_of_weights` is of the -// same type as `retval`. The result dtype follows a general pattern. -// If `weights` is None, the result dtype will be that of `a` , or ``float64`` -// if `a` is integral. Otherwise, if `weights` is not None and `a` is non- -// integral, the result type will be the type of lowest precision capable of -// representing values of both `a` and `weights`. If `a` happens to be -// integral, the previous rules still applies but the result dtype will -// at least be ``float64``. -// -// Raises -// ------ -// ZeroDivisionError -// When all weights along axis are zero. See `numpy.ma.average` for a -// version robust to this type of error. -// TypeError -// When `weights` does not have the same shape as `a`, and `axis=None`. -// ValueError -// When `weights` does not have dimensions and shape consistent with `a` -// along specified `axis`. +// res1, res2, ... : ndarray +// An array, or list of arrays, each with ``a.ndim >= 3``. Copies are +// avoided where possible, and views with three or more dimensions are +// returned. For example, a 1-D array of shape ``(N,)`` becomes a view +// of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a +// view of shape ``(M, N, 1)``. // // See Also // -------- -// mean -// -// ma.average : average for masked arrays -- useful if your data contains -// "missing" values -// numpy.result_type : Returns the type that results from applying the -// numpy type promotion rules to the arguments. +// atleast_1d, atleast_2d // // Examples // -------- -// >>> import numpy as np -// >>> data = np.arange(1, 5) -// >>> data -// array([1, 2, 3, 4]) -// >>> np.average(data) -// 2.5 -// >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1)) -// 4.0 -// -// >>> data = np.arange(6).reshape((3, 2)) -// >>> data -// array([[0, 1], -// [2, 3], -// [4, 5]]) -// >>> np.average(data, axis=1, weights=[1./4, 3./4]) -// array([0.75, 2.75, 4.75]) -// >>> np.average(data, weights=[1./4, 3./4]) -// Traceback (most recent call last): -// ... -// TypeError: Axis must be specified when shapes of a and weights differ. +// >>> np.atleast_3d(3.0) +// array([[[3.]]]) // -// With ``keepdims=True``, the following result has shape (3, 1). +// >>> x = np.arange(3.0) +// >>> np.atleast_3d(x).shape +// (1, 3, 1) // -// >>> np.average(data, axis=1, keepdims=True) -// array([[0.5], -// [2.5], -// [4.5]]) +// >>> x = np.arange(12.0).reshape(4,3) +// >>> np.atleast_3d(x).shape +// (4, 3, 1) +// >>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself +// True // -// >>> data = np.arange(8).reshape((2, 2, 2)) -// >>> data -// array([[[0, 1], -// [2, 3]], -// [[4, 5], -// [6, 7]]]) -// >>> np.average(data, axis=(0, 1), weights=[[1./4, 3./4], [1., 1./2]]) -// array([3.4, 4.4]) -// >>> np.average(data, axis=0, weights=[[1./4, 3./4], [1., 1./2]]) -// Traceback (most recent call last): -// ... -// ValueError: Shape of weights must be consistent -// with shape of a along specified axis. +// >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]): +// ... print(arr, arr.shape) # doctest: +SKIP +// ... +// [[[1] +// [2]]] (1, 2, 1) +// [[[1] +// [2]]] (1, 2, 1) +// [[[1 2]]] (1, 1, 2) // // -//go:linkname Average py.average -func Average(a *py.Object, axis *py.Object, weights *py.Object, returned *py.Object) *py.Object // -// Return minimum of an array or minimum along an axis, ignoring any NaNs. -// When all-NaN slices are encountered a ``RuntimeWarning`` is raised and -// Nan is returned for that slice. +//go:linkname Atleast3d py.atleast_3d +func Atleast3d(__llgo_va_list ...interface{}) *py.Object // -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose minimum is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the minimum is computed. The default is to compute -// the minimum of the flattened array. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. -// 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`. +// Stack arrays in sequence depth wise (along third axis). // -// If the value is anything but the default, then -// `keepdims` will be passed through to the `min` method -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// initial : scalar, optional -// The maximum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. +// This is equivalent to concatenation along the third axis after 2-D arrays +// of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape +// `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by +// `dsplit`. // -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to compare for the minimum. See `~numpy.ufunc.reduce` -// for details. +// This function makes most sense for arrays with up to 3 dimensions. For +// instance, for pixel-data with a height (first axis), width (second axis), +// and r/g/b channels (third axis). The functions `concatenate`, `stack` and +// `block` provide more general stacking and concatenation operations. // -// .. versionadded:: 1.22.0 +// Parameters +// ---------- +// tup : sequence of arrays +// The arrays must have the same shape along all but the third axis. +// 1-D or 2-D arrays must have the same shape. // // Returns // ------- -// nanmin : ndarray -// An array with the same shape as `a`, with the specified axis -// removed. If `a` is a 0-d array, or if axis is None, an ndarray -// scalar is returned. The same dtype as `a` is returned. +// stacked : ndarray +// The array formed by stacking the given arrays, will be at least 3-D. // // See Also // -------- -// nanmax : -// The maximum value of an array along a given axis, ignoring any NaNs. -// amin : -// The minimum value of an array along a given axis, propagating any NaNs. -// fmin : -// Element-wise minimum of two arrays, ignoring any NaNs. -// minimum : -// Element-wise minimum of two arrays, propagating any NaNs. -// isnan : -// Shows which elements are Not a Number (NaN). -// isfinite: -// Shows which elements are neither NaN nor infinity. -// -// amax, fmax, maximum -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// Positive infinity is treated as a very large number and negative -// infinity is treated as a very small (i.e. negative) number. -// -// If the input has a integer type the function is equivalent to np.min. +// concatenate : Join a sequence of arrays along an existing axis. +// stack : Join a sequence of arrays along a new axis. +// block : Assemble an nd-array from nested lists of blocks. +// vstack : Stack arrays in sequence vertically (row wise). +// hstack : Stack arrays in sequence horizontally (column wise). +// column_stack : Stack 1-D arrays as columns into a 2-D array. +// dsplit : Split array along third axis. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nanmin(a) -// 1.0 -// >>> np.nanmin(a, axis=0) -// array([1., 2.]) -// >>> np.nanmin(a, axis=1) -// array([1., 3.]) -// -// When positive infinity and negative infinity are present: +// >>> a = np.array((1,2,3)) +// >>> b = np.array((2,3,4)) +// >>> np.dstack((a,b)) +// array([[[1, 2], +// [2, 3], +// [3, 4]]]) // -// >>> np.nanmin([1, 2, np.nan, np.inf]) -// 1.0 -// >>> np.nanmin([1, 2, np.nan, -np.inf]) -// -inf +// >>> a = np.array([[1],[2],[3]]) +// >>> b = np.array([[2],[3],[4]]) +// >>> np.dstack((a,b)) +// array([[[1, 2]], +// [[2, 3]], +// [[3, 4]]]) // // // -//go:linkname Nanmin py.nanmin -func Nanmin(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +//go:linkname Dstack py.dstack +func Dstack(tup *py.Object) *py.Object +// Find the wrapper for the array with the highest priority. // -// Replace NaN with zero and infinity with large finite numbers (default -// behaviour) or with the numbers defined by the user using the `nan`, -// `posinf` and/or `neginf` keywords. +// In case of ties, leftmost wins. If no wrapper is found, return None // -// 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 -// value in `neginf` keyword. // -// For complex dtypes, the above is applied to each of the real and -// imaginary components of `x` separately. +//go:linkname GetArrayWrap py.get_array_wrap +func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object // -// If `x` is not inexact, then no replacements are made. +// Broadcast any number of arrays against each other. // // Parameters // ---------- -// x : scalar or array_like -// Input data. -// copy : bool, optional -// Whether to create a copy of `x` (True) or to replace values -// in-place (False). The in-place operation only occurs if -// casting to an array does not require a copy. -// Default is True. -// nan : int, float, optional -// Value to be used to fill NaN values. If no value is passed -// then NaN values will be replaced with 0.0. -// posinf : int, float, optional -// 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. -// neginf : int, float, optional -// 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. +// `*args` : array_likes +// The arrays to broadcast. +// +// subok : bool, optional +// If True, then sub-classes will be passed-through, otherwise +// the returned arrays will be forced to be a base-class array (default). // // Returns // ------- -// out : ndarray -// `x`, with the non-finite values replaced. If `copy` is False, this may -// be `x` itself. +// broadcasted : list of arrays +// These arrays are views on the original arrays. They are typically +// not contiguous. Furthermore, more than one element of a +// broadcasted array may refer to a single memory location. If you need +// to write to the arrays, make copies first. While you can set the +// ``writable`` flag True, writing to a single output value may end up +// changing more than one location in the output array. +// +// .. deprecated:: 1.17 +// The output is currently marked so that if written to, a deprecation +// warning will be emitted. A future version will set the +// ``writable`` flag False so writing to it will raise an error. // // See Also // -------- -// isinf : Shows which elements are positive or negative infinity. -// isneginf : Shows which elements are negative infinity. -// isposinf : Shows which elements are positive infinity. -// isnan : Shows which elements are Not a Number (NaN). -// isfinite : Shows which elements are finite (not NaN, not infinity) -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. +// broadcast +// broadcast_to +// broadcast_shapes // // Examples // -------- -// >>> import numpy as np -// >>> np.nan_to_num(np.inf) -// 1.7976931348623157e+308 -// >>> np.nan_to_num(-np.inf) -// -1.7976931348623157e+308 -// >>> np.nan_to_num(np.nan) -// 0.0 -// >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128]) -// >>> np.nan_to_num(x) -// 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, -// -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 -// -1.28000000e+002, 1.28000000e+002]) -// >>> np.nan_to_num(y) -// array([ 1.79769313e+308 +0.00000000e+000j, # may vary -// 0.00000000e+000 +0.00000000e+000j, -// 0.00000000e+000 +1.79769313e+308j]) -// >>> np.nan_to_num(y, nan=111111, posinf=222222) -// array([222222.+111111.j, 111111. +0.j, 111111.+222222.j]) +// >>> x = np.array([[1,2,3]]) +// >>> y = np.array([[4],[5]]) +// >>> np.broadcast_arrays(x, y) +// [array([[1, 2, 3], +// [1, 2, 3]]), array([[4, 4, 4], +// [5, 5, 5]])] // +// Here is a useful idiom for getting contiguous copies instead of +// non-contiguous views. +// +// >>> [np.array(a) for a in np.broadcast_arrays(x, y)] +// [array([[1, 2, 3], +// [1, 2, 3]]), array([[4, 4, 4], +// [5, 5, 5]])] // -//go:linkname NanToNum py.nan_to_num -func NanToNum(x *py.Object, copy *py.Object, nan *py.Object, posinf *py.Object, neginf *py.Object) *py.Object // -// Return a string representation of a number in the given base system. +// +//go:linkname BroadcastArrays py.broadcast_arrays +func BroadcastArrays(__llgo_va_list ...interface{}) *py.Object +// +// concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind") +// +// Join a sequence of arrays along an existing axis. // // Parameters // ---------- -// number : int -// The value to convert. Positive and negative values are handled. -// base : int, optional -// Convert `number` to the `base` number system. The valid range is 2-36, -// the default value is 2. -// padding : int, optional -// Number of zeros padded on the left. Default is 0 (no padding). +// a1, a2, ... : sequence of array_like +// The arrays must have the same shape, except in the dimension +// corresponding to `axis` (the first, by default). +// axis : int, optional +// The axis along which the arrays will be joined. If axis is None, +// arrays are flattened before use. Default is 0. +// out : ndarray, optional +// If provided, the destination to place the result. The shape must be +// correct, matching that of what concatenate 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.20.0 +// +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional +// Controls what kind of data casting may occur. Defaults to 'same_kind'. +// +// .. versionadded:: 1.20.0 // // Returns // ------- -// out : str -// String representation of `number` in `base` system. +// res : ndarray +// The concatenated array. // // See Also // -------- -// binary_repr : Faster version of `base_repr` for base 2. +// ma.concatenate : Concatenate function that preserves input masks. +// array_split : Split an array into multiple sub-arrays of equal or +// near-equal size. +// split : Split array into a list of multiple sub-arrays of equal size. +// hsplit : Split array into multiple sub-arrays horizontally (column wise). +// vsplit : Split array into multiple sub-arrays vertically (row wise). +// dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). +// stack : Stack a sequence of arrays along a new axis. +// block : Assemble arrays from blocks. +// hstack : Stack arrays in sequence horizontally (column wise). +// vstack : Stack arrays in sequence vertically (row wise). +// dstack : Stack arrays in sequence depth wise (along third dimension). +// column_stack : Stack 1-D arrays as columns into a 2-D array. +// +// Notes +// ----- +// When one or more of the arrays to be concatenated is a MaskedArray, +// this function will return a MaskedArray object instead of an ndarray, +// but the input masks are *not* preserved. In cases where a MaskedArray +// is expected as input, use the ma.concatenate function from the masked +// array module instead. // // Examples // -------- -// >>> import numpy as np -// >>> np.base_repr(5) -// '101' -// >>> np.base_repr(6, 5) -// '11' -// >>> np.base_repr(7, base=5, padding=3) -// '00012' -// -// >>> np.base_repr(10, base=16) -// 'A' -// >>> np.base_repr(32, base=16) -// '20' -// -// -// -//go:linkname BaseRepr py.base_repr -func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object -// -// Construct an array from an index array and a list of arrays to choose from. +// >>> a = np.array([[1, 2], [3, 4]]) +// >>> b = np.array([[5, 6]]) +// >>> np.concatenate((a, b), axis=0) +// array([[1, 2], +// [3, 4], +// [5, 6]]) +// >>> np.concatenate((a, b.T), axis=1) +// array([[1, 2, 5], +// [3, 4, 6]]) +// >>> np.concatenate((a, b), axis=None) +// array([1, 2, 3, 4, 5, 6]) // -// First of all, if confused or uncertain, definitely look at the Examples - -// in its full generality, this function is less simple than it might -// seem from the following code description:: +// This function will not preserve masking of MaskedArray inputs. // -// np.choose(a,c) == np.array([c[a[I]][I] for I in np.ndindex(a.shape)]) +// >>> a = np.ma.arange(3) +// >>> a[1] = np.ma.masked +// >>> b = np.arange(2, 5) +// >>> a +// masked_array(data=[0, --, 2], +// mask=[False, True, False], +// fill_value=999999) +// >>> b +// array([2, 3, 4]) +// >>> np.concatenate([a, b]) +// masked_array(data=[0, 1, 2, 2, 3, 4], +// mask=False, +// fill_value=999999) +// >>> np.ma.concatenate([a, b]) +// masked_array(data=[0, --, 2, 2, 3, 4], +// mask=[False, True, False, False, False, False], +// fill_value=999999) // -// But this omits some subtleties. Here is a fully general summary: // -// Given an "index" array (`a`) of integers and a sequence of ``n`` arrays -// (`choices`), `a` and each choice array are first broadcast, as necessary, -// to arrays of a common shape; calling these *Ba* and *Bchoices[i], i = -// 0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape`` -// for each ``i``. Then, a new array with shape ``Ba.shape`` is created as -// follows: // -// * if ``mode='raise'`` (the default), then, first of all, each element of -// ``a`` (and thus ``Ba``) must be in the range ``[0, n-1]``; now, suppose -// that ``i`` (in that range) is the value at the ``(j0, j1, ..., jm)`` -// position in ``Ba`` - then the value at the same position in the new array -// is the value in ``Bchoices[i]`` at that same position; +//go:linkname Concatenate py.concatenate +func Concatenate(list0 *py.Object, axis *py.Object, out *py.Object, dtype *py.Object, casting *py.Object) *py.Object // -// * if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed) -// integer; modular arithmetic is used to map integers outside the range -// `[0, n-1]` back into that range; and then the new array is constructed -// as above; +// can_cast(from_, to, casting='safe') // -// * if ``mode='clip'``, values in `a` (and thus ``Ba``) may be any (signed) -// integer; negative integers are mapped to 0; values greater than ``n-1`` -// are mapped to ``n-1``; and then the new array is constructed as above. +// Returns True if cast between data types can occur according to the +// casting rule. If from is a scalar or array scalar, also returns +// True if the scalar value can be cast without overflow or truncation +// to an integer. // // Parameters // ---------- -// a : int array -// This array must contain integers in ``[0, n-1]``, where ``n`` is the -// number of choices, unless ``mode=wrap`` or ``mode=clip``, in which -// cases any integers are permissible. -// choices : sequence of arrays -// Choice arrays. `a` and all of the choices must be broadcastable to the -// same shape. If `choices` is itself an array (not recommended), then -// its outermost dimension (i.e., the one corresponding to -// ``choices.shape[0]``) is taken as defining the "sequence". -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. Note that `out` is always -// buffered if ``mode='raise'``; use other modes for better performance. -// mode : {'raise' (default), 'wrap', 'clip'}, optional -// Specifies how indices outside ``[0, n-1]`` will be treated: +// from_ : dtype, dtype specifier, scalar, or array +// Data type, scalar, or array to cast from. +// to : dtype or dtype specifier +// Data type to cast to. +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional +// Controls what kind of data casting may occur. // -// * 'raise' : an exception is raised -// * 'wrap' : value becomes value mod ``n`` -// * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1 +// * 'no' means the data types should not be cast at all. +// * 'equiv' means only byte-order changes are allowed. +// * 'safe' means only casts which can preserve values are allowed. +// * 'same_kind' means only safe casts or casts within a kind, +// like float64 to float32, are allowed. +// * 'unsafe' means any data conversions may be done. // // Returns // ------- -// merged_array : array -// The merged result. -// -// Raises -// ------ -// ValueError: shape mismatch -// If `a` and each choice array are not all broadcastable to the same -// shape. -// -// See Also -// -------- -// ndarray.choose : equivalent method -// numpy.take_along_axis : Preferable if `choices` is an array +// out : bool +// True if cast can occur according to the casting rule. // // Notes // ----- -// To reduce the chance of misinterpretation, even though the following -// "abuse" is nominally supported, `choices` should neither be, nor be -// thought of as, a single array, i.e., the outermost sequence-like container -// should be either a list or a tuple. +// .. versionchanged:: 1.17.0 +// Casting between a simple data type and a structured one is possible only +// for "unsafe" casting. Casting to multiple fields is allowed, but +// casting from multiple fields is not. +// +// .. versionchanged:: 1.9.0 +// Casting from numeric to string types in 'safe' casting mode requires +// that the string dtype length is long enough to store the maximum +// integer/float value converted. +// +// See also +// -------- +// dtype, result_type // // Examples // -------- +// Basic examples // -// >>> import numpy as np -// >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], -// ... [20, 21, 22, 23], [30, 31, 32, 33]] -// >>> np.choose([2, 3, 1, 0], choices -// ... # the first element of the result will be the first element of the -// ... # third (2+1) "array" in choices, namely, 20; the second element -// ... # will be the second element of the fourth (3+1) choice array, i.e., -// ... # 31, etc. -// ... ) -// array([20, 31, 12, 3]) -// >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1) -// array([20, 31, 12, 3]) -// >>> # because there are 4 choice arrays -// >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4) -// array([20, 1, 12, 3]) -// >>> # i.e., 0 +// >>> np.can_cast(np.int32, np.int64) +// True +// >>> np.can_cast(np.float64, complex) +// True +// >>> np.can_cast(complex, float) +// False // -// A couple examples illustrating how choose broadcasts: +// >>> np.can_cast('i8', 'f8') +// True +// >>> np.can_cast('i8', 'f4') +// False +// >>> np.can_cast('i4', 'S4') +// False // -// >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]] -// >>> choices = [-10, 10] -// >>> np.choose(a, choices) -// array([[ 10, -10, 10], -// [-10, 10, -10], -// [ 10, -10, 10]]) +// Casting scalars // -// >>> # With thanks to Anne Archibald -// >>> a = np.array([0, 1]).reshape((2,1,1)) -// >>> c1 = np.array([1, 2, 3]).reshape((1,3,1)) -// >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5)) -// >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 -// array([[[ 1, 1, 1, 1, 1], -// [ 2, 2, 2, 2, 2], -// [ 3, 3, 3, 3, 3]], -// [[-1, -2, -3, -4, -5], -// [-1, -2, -3, -4, -5], -// [-1, -2, -3, -4, -5]]]) +// >>> np.can_cast(100, 'i1') +// True +// >>> np.can_cast(150, 'i1') +// False +// >>> np.can_cast(150, 'u1') +// True // +// >>> np.can_cast(3.5e100, np.float32) +// False +// >>> np.can_cast(1000.0, np.float32) +// True // +// Array scalar checks the value, array does not // -//go:linkname Choose py.choose -func Choose(a *py.Object, choices *py.Object, out *py.Object, mode *py.Object) *py.Object +// >>> np.can_cast(np.array(1000.0), np.float32) +// True +// >>> np.can_cast(np.array([1000.0]), np.float32) +// False // -// einsum_path(subscripts, *operands, optimize='greedy') +// Using the casting rules // -// Evaluates the lowest cost contraction order for an einsum expression by -// considering the creation of intermediate arrays. +// >>> np.can_cast('i8', 'i8', 'no') +// True +// >>> np.can_cast('i8', 'no') +// False // -// Parameters -// ---------- -// subscripts : str -// Specifies the subscripts for summation. -// *operands : list of array_like -// These are the arrays for the operation. -// optimize : {bool, list, tuple, 'greedy', 'optimal'} -// Choose the type of path. If a tuple is provided, the second argument is -// assumed to be the maximum intermediate size created. If only a single -// argument is provided the largest input or output array size is used -// as a maximum intermediate size. -// -// * if a list is given that starts with ``einsum_path``, uses this as the -// contraction path -// * if False no optimization is taken -// * if True defaults to the 'greedy' algorithm -// * 'optimal' An algorithm that combinatorially explores all possible -// ways of contracting the listed tensors and chooses the least costly -// path. Scales exponentially with the number of terms in the -// contraction. -// * 'greedy' An algorithm that chooses the best pair contraction -// at each step. Effectively, this algorithm searches the largest inner, -// Hadamard, and then outer products at each step. Scales cubically with -// the number of terms in the contraction. Equivalent to the 'optimal' -// path for most contractions. -// -// Default is 'greedy'. -// -// Returns -// ------- -// path : list of tuples -// A list representation of the einsum path. -// string_repr : str -// A printable representation of the einsum path. -// -// Notes -// ----- -// The resulting path indicates which terms of the input contraction should be -// contracted first, the result of this contraction is then appended to the -// end of the contraction list. This list can then be iterated over until all -// intermediate contractions are complete. -// -// See Also -// -------- -// einsum, linalg.multi_dot -// -// Examples -// -------- -// -// We can begin with a chain dot example. In this case, it is optimal to -// contract the ``b`` and ``c`` tensors first as represented by the first -// element of the path ``(1, 2)``. The resulting tensor is added to the end -// of the contraction and the remaining contraction ``(0, 1)`` is then -// completed. -// -// >>> np.random.seed(123) -// >>> a = np.random.rand(2, 2) -// >>> b = np.random.rand(2, 5) -// >>> c = np.random.rand(5, 2) -// >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy') -// >>> print(path_info[0]) -// ['einsum_path', (1, 2), (0, 1)] -// >>> print(path_info[1]) -// Complete contraction: ij,jk,kl->il # may vary -// Naive scaling: 4 -// Optimized scaling: 3 -// Naive FLOP count: 1.600e+02 -// Optimized FLOP count: 5.600e+01 -// Theoretical speedup: 2.857 -// Largest intermediate: 4.000e+00 elements -// ------------------------------------------------------------------------- -// scaling current remaining -// ------------------------------------------------------------------------- -// 3 kl,jk->jl ij,jl->il -// 3 jl,ij->il il->il +// >>> np.can_cast('i8', 'equiv') +// True +// >>> np.can_cast('i8', 'equiv') +// False // +// >>> np.can_cast('i8', 'safe') +// True +// >>> np.can_cast('i4', 'safe') +// False // -// A more complex index transformation example. +// >>> np.can_cast('i4', 'same_kind') +// True +// >>> np.can_cast('u4', 'same_kind') +// False // -// >>> I = np.random.rand(10, 10, 10, 10) -// >>> C = np.random.rand(10, 10) -// >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C, -// ... optimize='greedy') +// >>> np.can_cast('u4', 'unsafe') +// True // -// >>> print(path_info[0]) -// ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)] -// >>> print(path_info[1]) -// Complete contraction: ea,fb,abcd,gc,hd->efgh # may vary -// Naive scaling: 8 -// Optimized scaling: 5 -// Naive FLOP count: 8.000e+08 -// Optimized FLOP count: 8.000e+05 -// Theoretical speedup: 1000.000 -// Largest intermediate: 1.000e+04 elements -// -------------------------------------------------------------------------- -// scaling current remaining -// -------------------------------------------------------------------------- -// 5 abcd,ea->bcde fb,gc,hd,bcde->efgh -// 5 bcde,fb->cdef gc,hd,cdef->efgh -// 5 cdef,gc->defg hd,defg->efgh -// 5 defg,hd->efgh efgh->efgh // // -//go:linkname EinsumPath py.einsum_path -func EinsumPath(__llgo_va_list ...interface{}) *py.Object +//go:linkname CanCast py.can_cast +func CanCast(from_ *py.Object, to *py.Object, casting *py.Object) *py.Object // -// Modified Bessel function of the first kind, order 0. +// Return the identity array. // -// Usually denoted :math:`I_0`. +// The identity array is a square array with ones on +// the main diagonal. // // Parameters // ---------- -// x : array_like of float -// Argument of the Bessel function. +// n : int +// Number of rows (and columns) in `n` x `n` output. +// dtype : data-type, optional +// Data-type of the output. Defaults to ``float``. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // // Returns // ------- -// out : ndarray, shape = x.shape, dtype = float -// The modified Bessel function evaluated at each of the elements of `x`. -// -// See Also -// -------- -// scipy.special.i0, scipy.special.iv, scipy.special.ive -// -// Notes -// ----- -// The scipy implementation is recommended over this function: it is a -// proper ufunc written in C, and more than an order of magnitude faster. -// -// We use the algorithm published by Clenshaw [1]_ and referenced by -// Abramowitz and Stegun [2]_, for which the function domain is -// partitioned into the two intervals [0,8] and (8,inf), and Chebyshev -// polynomial expansions are employed in each interval. Relative error on -// the domain [0,30] using IEEE arithmetic is documented [3]_ as having a -// peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000). -// -// References -// ---------- -// .. [1] C. W. Clenshaw, "Chebyshev series for mathematical functions", in -// *National Physical Laboratory Mathematical Tables*, vol. 5, London: -// Her Majesty's Stationery Office, 1962. -// .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical -// Functions*, 10th printing, New York: Dover, 1964, pp. 379. -// https://personal.math.ubc.ca/~cbm/aands/page_379.htm -// .. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero +// out : ndarray +// `n` x `n` array with its main diagonal set to one, +// and all other elements 0. // // Examples // -------- -// >>> import numpy as np -// >>> np.i0(0.) -// array(1.0) -// >>> np.i0([0, 1, 2, 3]) -// array([1. , 1.26606588, 2.2795853 , 4.88079259]) -// +// >>> np.identity(3) +// array([[1., 0., 0.], +// [0., 1., 0.], +// [0., 0., 1.]]) // // -//go:linkname I0 py.i0 -func I0(x *py.Object) *py.Object // -// Return the derivative of the specified order of a polynomial. +//go:linkname Identity py.identity +func Identity(n *py.Object, dtype *py.Object) *py.Object // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. +// Remove axes of length one from `a`. // // Parameters // ---------- -// p : poly1d or sequence -// Polynomial to differentiate. -// A sequence is interpreted as polynomial coefficients, see `poly1d`. -// m : int, optional -// Order of differentiation (default: 1) +// a : array_like +// Input data. +// axis : None or int or tuple of ints, optional +// .. versionadded:: 1.7.0 +// +// Selects a subset of the entries of length one in the +// shape. If an axis is selected with shape entry greater than +// one, an error is raised. // // Returns // ------- -// der : poly1d -// A new polynomial representing the derivative. +// squeezed : ndarray +// The input array, but with all or a subset of the +// dimensions of length 1 removed. This is always `a` itself +// or a view into `a`. Note that if all axes are squeezed, +// the result is a 0d array and not a scalar. +// +// Raises +// ------ +// ValueError +// If `axis` is not None, and an axis being squeezed is not of length 1 // // See Also // -------- -// polyint : Anti-derivative of a polynomial. -// poly1d : Class for one-dimensional polynomials. +// expand_dims : The inverse operation, adding entries of length one +// reshape : Insert, remove, and combine dimensions, and resize existing ones // // Examples // -------- +// >>> x = np.array([[[0], [1], [2]]]) +// >>> x.shape +// (1, 3, 1) +// >>> np.squeeze(x).shape +// (3,) +// >>> np.squeeze(x, axis=0).shape +// (3, 1) +// >>> np.squeeze(x, axis=1).shape +// Traceback (most recent call last): +// ... +// ValueError: cannot select an axis to squeeze out which has size not equal to one +// >>> np.squeeze(x, axis=2).shape +// (1, 3) +// >>> x = np.array([[1234]]) +// >>> x.shape +// (1, 1) +// >>> np.squeeze(x) +// array(1234) # 0d array +// >>> np.squeeze(x).shape +// () +// >>> np.squeeze(x)[()] +// 1234 // -// The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is: // -// >>> import numpy as np // -// >>> p = np.poly1d([1,1,1,1]) -// >>> p2 = np.polyder(p) -// >>> p2 -// poly1d([3, 2, 1]) +//go:linkname Squeeze py.squeeze +func Squeeze(a *py.Object, axis *py.Object) *py.Object +// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// which evaluates to: +// Hyperbolic cosine, element-wise. // -// >>> p2(2.) -// 17.0 +// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. // -// We can verify this, approximating the derivative with -// ``(f(x + h) - f(x))/h``: +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> (p(2. + 0.001) - p(2.)) / 0.001 -// 17.007000999997857 +// Returns +// ------- +// out : ndarray or scalar +// Output array of same shape as `x`. +// This is a scalar if `x` is a scalar. // -// The fourth-order derivative of a 3rd-order polynomial is zero: -// -// >>> np.polyder(p, 2) -// poly1d([6, 2]) -// >>> np.polyder(p, 3) -// poly1d([6]) -// >>> np.polyder(p, 4) -// poly1d([0]) +// Examples +// -------- +// >>> np.cosh(0) +// 1.0 // +// The hyperbolic cosine describes the shape of a hanging cable: // +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-4, 4, 1000) +// >>> plt.plot(x, np.cosh(x)) +// >>> plt.show() // -//go:linkname Polyder py.polyder -func Polyder(__llgo_va_list ...interface{}) *py.Object +//go:linkname Cosh py.cosh +func Cosh(x *py.Object, out *py.Object) *py.Object // -// Split array into multiple sub-arrays along the 3rd axis (depth). +// Return the indices for the lower-triangle of arr. // -// Please refer to the `split` documentation. `dsplit` is equivalent -// to `split` with ``axis=2``, the array is always split along the third -// axis provided the array dimension is greater than or equal to 3. +// See `tril_indices` for full details. // -// See Also -// -------- -// split : Split an array into multiple sub-arrays of equal size. +// Parameters +// ---------- +// arr : array_like +// The indices will be valid for square arrays whose dimensions are +// the same as arr. +// k : int, optional +// Diagonal offset (see `tril` for details). // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(16.0).reshape(2, 2, 4) -// >>> x -// array([[[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.]], -// [[ 8., 9., 10., 11.], -// [12., 13., 14., 15.]]]) -// >>> np.dsplit(x, 2) -// [array([[[ 0., 1.], -// [ 4., 5.]], -// [[ 8., 9.], -// [12., 13.]]]), array([[[ 2., 3.], -// [ 6., 7.]], -// [[10., 11.], -// [14., 15.]]])] -// >>> np.dsplit(x, np.array([3, 6])) -// [array([[[ 0., 1., 2.], -// [ 4., 5., 6.]], -// [[ 8., 9., 10.], -// [12., 13., 14.]]]), -// array([[[ 3.], -// [ 7.]], -// [[11.], -// [15.]]]), -// array([], shape=(2, 2, 0), dtype=float64)] // +// Create a 4 by 4 array. // -//go:linkname Dsplit py.dsplit -func Dsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object -// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) // -// Calculate the absolute value element-wise. +// Pass the array to get the indices of the lower triangular elements. // -// ``np.abs`` is a shorthand for this function. +// >>> trili = np.tril_indices_from(a) +// >>> trili +// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) // -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> a[trili] +// array([ 0, 4, 5, 8, 9, 10, 12, 13, 14, 15]) // -// Returns -// ------- -// absolute : ndarray -// An ndarray containing the absolute value of -// each element in `x`. For complex input, ``a + ib``, the -// absolute value is :math:`\sqrt{ a^2 + b^2 }`. -// This is a scalar if `x` is a scalar. +// This is syntactic sugar for tril_indices(). // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([-1.2, 1.2]) -// >>> np.absolute(x) -// array([ 1.2, 1.2]) -// >>> np.absolute(1.2 + 1j) -// 1.5620499351813308 +// >>> np.tril_indices(a.shape[0]) +// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) // -// Plot the function over ``[-10, 10]``: +// Use the `k` parameter to return the indices for the lower triangular array +// up to the k-th diagonal. // -// >>> import matplotlib.pyplot as plt +// >>> trili1 = np.tril_indices_from(a, k=1) +// >>> a[trili1] +// array([ 0, 1, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15]) // -// >>> x = np.linspace(start=-10, stop=10, num=101) -// >>> plt.plot(x, np.absolute(x)) -// >>> plt.show() +// See Also +// -------- +// tril_indices, tril, triu_indices_from // -// Plot the function over the complex plane: +// Notes +// ----- +// .. versionadded:: 1.4.0 // -// >>> xx = x + 1j * x[:, np.newaxis] -// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') -// >>> plt.show() // -// The `abs` function can be used as a shorthand for ``np.absolute`` on -// ndarrays. // -// >>> x = np.array([-1.2, 1.2]) -// >>> abs(x) -// array([1.2, 1.2]) +//go:linkname TrilIndicesFrom py.tril_indices_from +func TrilIndicesFrom(arr *py.Object, k *py.Object) *py.Object // -//go:linkname Absolute py.absolute -func Absolute(x *py.Object, out *py.Object) *py.Object +// Difference (subtraction) of two polynomials. // -// Returns the indices of the minimum values along an axis. +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. +// +// Given two polynomials `a1` and `a2`, returns ``a1 - a2``. +// `a1` and `a2` can be either array_like sequences of the polynomials' +// coefficients (including coefficients equal to zero), or `poly1d` objects. // // Parameters // ---------- -// a : array_like -// Input array. -// axis : int, optional -// By default, the index is into the flattened array, otherwise -// along the specified axis. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. -// 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 array. -// -// .. versionadded:: 1.22.0 +// a1, a2 : array_like or poly1d +// Minuend and subtrahend polynomials, respectively. // // Returns // ------- -// index_array : ndarray of ints -// Array of indices into the array. It has the same shape as `a.shape` -// with the dimension along `axis` removed. If `keepdims` is set to True, -// then the size of `axis` will be 1 with the resulting array having same -// shape as `a.shape`. +// out : ndarray or poly1d +// Array or `poly1d` object of the difference polynomial's coefficients. // // See Also // -------- -// ndarray.argmin, argmax -// amin : The minimum value along a given axis. -// unravel_index : Convert a flat index into an index tuple. -// take_along_axis : Apply ``np.expand_dims(index_array, axis)`` -// from argmin to an array as if by calling min. -// -// Notes -// ----- -// In case of multiple occurrences of the minimum values, the indices -// corresponding to the first occurrence are returned. +// polyval, polydiv, polymul, polyadd // // Examples // -------- -// >>> import numpy as np -// >>> a = np.arange(6).reshape(2,3) + 10 -// >>> a -// array([[10, 11, 12], -// [13, 14, 15]]) -// >>> np.argmin(a) -// 0 -// >>> np.argmin(a, axis=0) -// array([0, 0, 0]) -// >>> np.argmin(a, axis=1) -// array([0, 0]) -// -// Indices of the minimum elements of a N-dimensional array: -// -// >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape) -// >>> ind -// (0, 0) -// >>> a[ind] -// 10 -// -// >>> b = np.arange(6) + 10 -// >>> b[4] = 10 -// >>> b -// array([10, 11, 12, 13, 10, 15]) -// >>> np.argmin(b) # Only the first occurrence is returned. -// 0 +// .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2) // -// >>> x = np.array([[4,2,3], [1,0,3]]) -// >>> index_array = np.argmin(x, axis=-1) -// >>> # Same as np.amin(x, axis=-1, keepdims=True) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) -// array([[2], -// [0]]) -// >>> # Same as np.amax(x, axis=-1) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), -// ... axis=-1).squeeze(axis=-1) -// array([2, 0]) +// >>> np.polysub([2, 10, -2], [3, 10, -4]) +// array([-1, 0, 2]) // -// Setting `keepdims` to `True`, // -// >>> x = np.arange(24).reshape((2, 3, 4)) -// >>> res = np.argmin(x, axis=1, keepdims=True) -// >>> res.shape -// (2, 1, 4) // +//go:linkname Polysub py.polysub +func Polysub(a1 *py.Object, a2 *py.Object) *py.Object // -//go:linkname Argmin py.argmin -func Argmin(a *py.Object, axis *py.Object, out *py.Object) *py.Object +// Counts the number of non-zero values in the array ``a``. // -// Gives a new shape to an array without changing its data. +// The word "non-zero" is in reference to the Python 2.x +// built-in method ``__nonzero__()`` (renamed ``__bool__()`` +// in Python 3.x) of Python objects that tests an object's +// "truthfulness". For example, any number is considered +// truthful if it is nonzero, whereas any string is considered +// truthful if it is not the empty string. Thus, this function +// (recursively) counts how many elements in ``a`` (and in +// sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()`` +// method evaluated to ``True``. // // Parameters // ---------- // a : array_like -// Array to be reshaped. -// shape : int or tuple of ints -// The new shape should be compatible with the original shape. If -// an integer, then the result will be a 1-D array of that length. -// One shape dimension can be -1. In this case, the value is -// inferred from the length of the array and remaining dimensions. -// order : {'C', 'F', 'A'}, optional -// Read the elements of ``a`` using this index order, and place the -// elements into the reshaped array using this index order. 'C' -// means to read / write the elements using C-like index order, -// with the last axis index changing fastest, back to the first -// axis index changing slowest. 'F' means to read / write the -// elements using Fortran-like index order, with the first index -// changing fastest, and the last index changing slowest. Note that -// the 'C' and 'F' options take no account of the memory layout of -// the underlying array, and only refer to the order of indexing. -// 'A' means to read / write the elements in Fortran-like index -// order if ``a`` is Fortran *contiguous* in memory, C-like order -// otherwise. -// newshape : int or tuple of ints -// .. deprecated:: 2.1 -// Replaced by ``shape`` argument. Retained for backward -// compatibility. -// copy : bool, optional -// If ``True``, then the array data is copied. If ``None``, a copy will -// only be made if it's required by ``order``. For ``False`` it raises -// a ``ValueError`` if a copy cannot be avoided. Default: ``None``. -// -// Returns -// ------- -// reshaped_array : ndarray -// This will be a new view object if possible; otherwise, it will -// be a copy. Note there is no guarantee of the *memory layout* (C- or -// Fortran- contiguous) of the returned array. -// -// See Also -// -------- -// ndarray.reshape : Equivalent method. -// -// Notes -// ----- -// It is not always possible to change the shape of an array without copying -// the data. -// -// The ``order`` keyword gives the index ordering both for *fetching* -// the values from ``a``, and then *placing* the values into the output -// array. For example, let's say you have an array: -// -// >>> a = np.arange(6).reshape((3, 2)) -// >>> a -// array([[0, 1], -// [2, 3], -// [4, 5]]) -// -// You can think of reshaping as first raveling the array (using the given -// index order), then inserting the elements from the raveled array into the -// new array using the same kind of index ordering as was used for the -// raveling. -// -// >>> np.reshape(a, (2, 3)) # C-like index ordering -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering -// array([[0, 4, 3], -// [2, 1, 5]]) -// >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F') -// array([[0, 4, 3], -// [2, 1, 5]]) -// -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1,2,3], [4,5,6]]) -// >>> np.reshape(a, 6) -// array([1, 2, 3, 4, 5, 6]) -// >>> np.reshape(a, 6, order='F') -// array([1, 4, 2, 5, 3, 6]) -// -// >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 -// array([[1, 2], -// [3, 4], -// [5, 6]]) -// -// -//go:linkname Reshape py.reshape -func Reshape(a *py.Object, shape *py.Object, order *py.Object) *py.Object -// -// Return the indices of the maximum values in the specified axis ignoring -// NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the -// results cannot be trusted if a slice contains only NaNs and -Infs. -// +// The array for which to count non-zeros. +// axis : int or tuple, optional +// Axis or tuple of axes along which to count non-zeros. +// Default is None, meaning that non-zeros will be counted +// along a flattened version of ``a``. // -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : int, optional -// Axis along which to operate. By default flattened input is used. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. +// .. versionadded:: 1.12.0 // -// .. versionadded:: 1.22.0 // keepdims : bool, optional -// If this is set to True, the axes which are reduced are left +// If this is set to True, the axes that are counted are left // in the result as dimensions with size one. With this option, -// the result will broadcast correctly against the array. +// the result will broadcast correctly against the input array. // -// .. versionadded:: 1.22.0 +// .. versionadded:: 1.19.0 // // Returns // ------- -// index_array : ndarray -// An array of indices or a single index value. +// count : int or array of int +// Number of non-zero values in the array along a given axis. +// Otherwise, the total number of non-zero values in the array +// is returned. // // See Also // -------- -// argmax, nanargmin +// nonzero : Return the coordinates of all the non-zero values. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[np.nan, 4], [2, 3]]) -// >>> np.argmax(a) -// 0 -// >>> np.nanargmax(a) -// 1 -// >>> np.nanargmax(a, axis=0) -// array([1, 0]) -// >>> np.nanargmax(a, axis=1) -// array([1, 1]) -// +// >>> np.count_nonzero(np.eye(4)) +// 4 +// >>> a = np.array([[0, 1, 7, 0], +// ... [3, 0, 2, 19]]) +// >>> np.count_nonzero(a) +// 5 +// >>> np.count_nonzero(a, axis=0) +// array([1, 1, 2, 1]) +// >>> np.count_nonzero(a, axis=1) +// array([2, 3]) +// >>> np.count_nonzero(a, axis=1, keepdims=True) +// array([[2], +// [3]]) // // -//go:linkname Nanargmax py.nanargmax -func Nanargmax(__llgo_va_list ...interface{}) *py.Object +//go:linkname CountNonzero py.count_nonzero +func CountNonzero(a *py.Object, axis *py.Object) *py.Object // -// Round to nearest integer towards zero. +// Return the product of array elements over a given axis. // -// Round an array of floats element-wise to nearest integer towards zero. -// The rounded values have the same data-type as the input. +// .. deprecated:: 1.25.0 +// ``product`` is deprecated as of NumPy 1.25.0, and will be +// removed in NumPy 2.0. Please use `prod` instead. // -// Parameters -// ---------- -// x : array_like -// An array to be rounded -// out : ndarray, optional -// A location into which the result is stored. If provided, it must have -// a shape that the input broadcasts to. If not provided or None, a -// freshly-allocated array is returned. +// See Also +// -------- +// prod : equivalent function; see for details. // -// Returns -// ------- -// out : ndarray of floats -// An array with the same dimensions and data-type as the input. -// If second argument is not supplied then a new array is returned -// with the rounded values. // -// If a second argument is supplied the result is stored there. -// The return value ``out`` is then a reference to that array. +//go:linkname Product py.product +func Product(__llgo_va_list ...interface{}) *py.Object // -// See Also -// -------- -// rint, trunc, floor, ceil -// around : Round to given number of decimals +// Round an array to the given number of decimals. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.fix(3.14) -// 3.0 -// >>> np.fix(3) -// 3 -// >>> np.fix([2.1, 2.9, -2.1, -2.9]) -// array([ 2., 2., -2., -2.]) +// `~numpy.round_` is a disrecommended backwards-compatibility +// alias of `~numpy.around` and `~numpy.round`. // +// .. deprecated:: 1.25.0 +// ``round_`` is deprecated as of NumPy 1.25.0, and will be +// removed in NumPy 2.0. Please use `round` instead. // +// See Also +// -------- +// around : equivalent function; see for details. // -//go:linkname Fix py.fix -func Fix(x *py.Object, out *py.Object) *py.Object // -// Interpret the input as a matrix. +//go:linkname Round_ py.round_ +func Round_(a *py.Object, decimals *py.Object, out *py.Object) *py.Object // -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// Return the shape of an array. // // Parameters // ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. +// a : array_like +// Input array. // // Returns // ------- -// mat : matrix -// `data` interpreted as a matrix. +// shape : tuple of ints +// The elements of the shape tuple give the lengths of the +// corresponding array dimensions. // -// Examples +// See Also // -------- -// >>> import numpy as np -// >>> x = np.array([[1, 2], [3, 4]]) +// len : ``len(a)`` is equivalent to ``np.shape(a)[0]`` for N-D arrays with +// ``N>=1``. +// ndarray.shape : Equivalent array method. // -// >>> m = np.asmatrix(x) +// Examples +// -------- +// >>> np.shape(np.eye(3)) +// (3, 3) +// >>> np.shape([[1, 3]]) +// (1, 2) +// >>> np.shape([0]) +// (1,) +// >>> np.shape(0) +// () // -// >>> x[0,0] = 5 +// >>> a = np.array([(1, 2), (3, 4), (5, 6)], +// ... dtype=[('x', 'i4'), ('y', 'i4')]) +// >>> np.shape(a) +// (3,) +// >>> a.shape +// (3,) // -// >>> m -// matrix([[5, 2], -// [3, 4]]) // // +//go:linkname Shape py.shape +func Shape(a *py.Object) *py.Object +// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname Asmatrix py.asmatrix -func Asmatrix(data *py.Object, dtype *py.Object) *py.Object -// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Natural logarithm, element-wise. // -// Inverse sine, element-wise. +// The natural logarithm `log` is the inverse of the exponential function, +// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base +// `e`. // // Parameters // ---------- // x : array_like -// `y`-coordinate on the unit circle. +// Input value. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -3993,1446 +3282,1068 @@ func Asmatrix(data *py.Object, dtype *py.Object) *py.Object // // Returns // ------- -// angle : ndarray -// The inverse sine of each element in `x`, in radians and in the -// closed interval ``[-pi/2, pi/2]``. +// y : ndarray +// The natural logarithm of `x`, element-wise. // This is a scalar if `x` is a scalar. // // See Also // -------- -// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin +// log10, log2, log1p, emath.log // // Notes // ----- -// `arcsin` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that :math:`sin(z) = x`. The convention is to -// return the angle `z` whose real part lies in [-pi/2, pi/2]. +// 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]`. // -// For real-valued input data types, *arcsin* always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. +// 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 +// yields ``nan`` and sets the `invalid` floating point error flag. // -// For complex-valued input, `arcsin` is a complex analytic function that -// has, by convention, the branch cuts [-inf, -1] and [1, inf] and is -// continuous from above on the former and from below on the latter. +// For complex-valued input, `log` is a complex analytical function that +// 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. // -// The inverse sine is also known as `asin` or sin^{-1}. +// 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 // ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79ff. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm // // Examples // -------- -// >>> import numpy as np -// >>> np.arcsin(1) # pi/2 -// 1.5707963267948966 -// >>> np.arcsin(-1) # -pi/2 -// -1.5707963267948966 -// >>> np.arcsin(0) -// 0.0 -// -//go:linkname Arcsin py.arcsin -func Arcsin(x *py.Object, out *py.Object) *py.Object -// -// Return the binary representation of the input number as a string. +// >>> np.log([1, np.e, np.e**2, 0]) +// array([ 0., 1., 2., -Inf]) // -// For negative numbers, if width is not given, a minus sign is added to the -// front. If width is given, the two's complement of the number is -// returned, with respect to that width. +//go:linkname Log py.log +func Log(x *py.Object, out *py.Object) *py.Object // -// In a two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit two's-complement -// system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. +// Return the scalar type of highest precision of the same kind as the input. // // Parameters // ---------- -// num : int -// Only an integer decimal number can be used. -// width : int, optional -// The length of the returned string if `num` is positive, or the length -// of the two's complement if `num` is negative, provided that `width` is -// at least a sufficient number of bits for `num` to be represented in -// the designated form. If the `width` value is insufficient, an error is -// raised. +// t : dtype or dtype specifier +// The input data type. This can be a `dtype` object or an object that +// is convertible to a `dtype`. // // Returns // ------- -// bin : str -// Binary representation of `num` or two's complement of `num`. +// out : dtype +// The highest precision data type of the same kind (`dtype.kind`) as `t`. // // See Also // -------- -// base_repr: Return a string representation of a number in the given base -// system. -// bin: Python's built-in binary representation generator of an integer. -// -// Notes -// ----- -// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x -// faster. -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement +// obj2sctype, mintypecode, sctype2char +// dtype // // Examples // -------- -// >>> import numpy as np -// >>> np.binary_repr(3) -// '11' -// >>> np.binary_repr(-3) -// '-11' -// >>> np.binary_repr(3, width=4) -// '0011' -// -// The two's complement is returned when the input number is negative and -// width is specified: -// -// >>> np.binary_repr(-3, width=3) -// '101' -// >>> np.binary_repr(-3, width=5) -// '11101' -// -// -// -//go:linkname BinaryRepr py.binary_repr -func BinaryRepr(num *py.Object, width *py.Object) *py.Object -// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Compute the bit-wise AND of two arrays element-wise. -// -// Computes the bit-wise AND of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``&``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and -// bitwise_or -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// >>> import numpy as np -// -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise AND of 13 and 17 is -// therefore ``000000001``, or 1: -// -// >>> np.bitwise_and(13, 17) -// 1 -// -// >>> np.bitwise_and(14, 13) -// 12 -// >>> np.binary_repr(12) -// '1100' -// >>> np.bitwise_and([14,3], 13) -// array([12, 1]) -// -// >>> np.bitwise_and([11,7], [4,25]) -// array([0, 1]) -// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) -// array([ 2, 4, 16]) -// >>> np.bitwise_and([True, True], [False, True]) -// array([False, True]) -// -// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([3, 14, 16]) -// >>> x1 & x2 -// array([ 2, 4, 16]) -// -//go:linkname BitwiseAnd py.bitwise_and -func BitwiseAnd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Hyperbolic cosine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> np.maximum_sctype(int) +// +// >>> np.maximum_sctype(np.uint8) +// +// >>> np.maximum_sctype(complex) +// # may vary // -// Returns -// ------- -// out : ndarray or scalar -// Output array of same shape as `x`. -// This is a scalar if `x` is a scalar. +// >>> np.maximum_sctype(str) +// // -// Examples -// -------- -// >>> import numpy as np -// >>> np.cosh(0) -// 1.0 +// >>> np.maximum_sctype('i2') +// +// >>> np.maximum_sctype('f4') +// # may vary // -// The hyperbolic cosine describes the shape of a hanging cable: // -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-4, 4, 1000) -// >>> plt.plot(x, np.cosh(x)) -// >>> plt.show() // -//go:linkname Cosh py.cosh -func Cosh(x *py.Object, out *py.Object) *py.Object +//go:linkname MaximumSctype py.maximum_sctype +func MaximumSctype(t *py.Object) *py.Object // -// Return a new array of given shape and type, filled with `fill_value`. +// Return a description for the given data type code. // // Parameters // ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// fill_value : scalar or array_like -// Fill value. -// dtype : data-type, optional -// The desired data-type for the array The default, None, means -// ``np.array(fill_value).dtype``. -// order : {'C', 'F'}, optional -// Whether to store multidimensional data in C- or Fortran-contiguous -// (row- or column-wise) order in memory. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. -// -// .. versionadded:: 2.0.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 +// char : str +// Data type code. // // Returns // ------- -// out : ndarray -// Array of `fill_value` with the given shape, dtype, and order. +// out : str +// Description of the input data type code. // // See Also // -------- -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. +// dtype, typecodes // // Examples // -------- -// >>> import numpy as np -// >>> np.full((2, 2), np.inf) -// array([[inf, inf], -// [inf, inf]]) -// >>> np.full((2, 2), 10) -// array([[10, 10], -// [10, 10]]) -// -// >>> np.full((2, 2), [1, 2]) -// array([[1, 2], -// [1, 2]]) +// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', +// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] +// >>> for typechar in typechars: +// ... print(typechar, ' : ', np.typename(typechar)) +// ... +// S1 : character +// ? : bool +// B : unsigned char +// D : complex double precision +// G : complex long double precision +// F : complex single precision +// I : unsigned integer +// H : unsigned short +// L : unsigned long integer +// O : object +// Q : unsigned long long integer +// S : string +// U : unicode +// V : void +// b : signed char +// d : double precision +// g : long precision +// f : single precision +// i : integer +// h : short +// l : long integer +// q : long long integer // // // -//go:linkname Full py.full -func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object -// promote_types(type1, type2) +//go:linkname Typename py.typename +func Typename(char *py.Object) *py.Object // -// 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 considered "canonical", this mainly -// means that the promoted dtype will always be in native byte order. +// Return the Kaiser window. // -// This function is symmetric, but rarely associative. +// The Kaiser window is a taper formed by using a Bessel function. // // Parameters // ---------- -// type1 : dtype or dtype specifier -// First data type. -// type2 : dtype or dtype specifier -// Second data type. +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. +// beta : float +// Shape parameter for window. // // Returns // ------- -// out : dtype -// The promoted data type. +// out : array +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). +// +// See Also +// -------- +// bartlett, blackman, hamming, hanning // // Notes // ----- -// Please see `numpy.result_type` for additional information about promotion. +// The Kaiser window is defined as // -// Starting in NumPy 1.9, promote_types function now returns a valid string -// length when given an integer or float dtype as one argument and a string -// dtype as another argument. Previously it always returned the input string -// 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 +// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} +// \right)/I_0(\beta) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.promote_types('f4', 'f8') -// dtype('float64') +// with // -// >>> np.promote_types('i8', 'f4') -// dtype('float64') +// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, // -// >>> np.promote_types('>i8', '>> np.promote_types('i4', 'S8') -// dtype('S11') +// The Kaiser was named for Jim Kaiser, who discovered a simple +// approximation to the DPSS window based on Bessel functions. The Kaiser +// window is a very good approximation to the Digital Prolate Spheroidal +// Sequence, or Slepian window, which is the transform which maximizes the +// energy in the main lobe of the window relative to total energy. // -// An example of a non-associative case: +// The Kaiser can approximate many other windows by varying the beta +// parameter. // -// >>> p = np.promote_types -// >>> p('S', p('i1', 'u1')) -// dtype('S6') -// >>> p(p('S', 'i1'), 'u1') -// dtype('S4') +// ==== ======================= +// beta Window shape +// ==== ======================= +// 0 Rectangular +// 5 Similar to a Hamming +// 6 Similar to a Hanning +// 8.6 Similar to a Blackman +// ==== ======================= // -//go:linkname PromoteTypes py.promote_types -func PromoteTypes(type1 *py.Object, type2 *py.Object) *py.Object +// A beta value of 14 is probably a good starting point. Note that as beta +// gets large, the window narrows, and so the number of samples needs to be +// large enough to sample the increasingly narrow spike, otherwise NaNs will +// get returned. // -// Interchange two axes of an array. +// Most references to the Kaiser window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. 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. // -// Parameters +// References // ---------- -// a : array_like -// Input array. -// axis1 : int -// First axis. -// axis2 : int -// Second axis. -// -// Returns -// ------- -// a_swapped : ndarray -// For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is -// returned; otherwise a new array is created. For earlier NumPy -// versions a view of `a` is returned only if the order of the -// axes is changed, otherwise the input array is returned. +// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by +// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. +// John Wiley and Sons, New York, (1966). +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 177-178. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function // // Examples // -------- -// >>> import numpy as np -// >>> x = np.array([[1,2,3]]) -// >>> np.swapaxes(x,0,1) -// array([[1], -// [2], -// [3]]) -// -// >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]]) -// >>> x -// array([[[0, 1], -// [2, 3]], -// [[4, 5], -// [6, 7]]]) +// >>> import matplotlib.pyplot as plt +// >>> np.kaiser(12, 14) +// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary +// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, +// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, +// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) // -// >>> np.swapaxes(x,0,2) -// array([[[0, 4], -// [2, 6]], -// [[1, 5], -// [3, 7]]]) // +// Plot the window and the frequency response: // +// >>> from numpy.fft import fft, fftshift +// >>> window = np.kaiser(51, 14) +// >>> plt.plot(window) +// [] +// >>> plt.title("Kaiser window") +// Text(0.5, 1.0, 'Kaiser window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() // -//go:linkname Swapaxes py.swapaxes -func Swapaxes(a *py.Object, axis1 *py.Object, axis2 *py.Object) *py.Object +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Kaiser window") +// Text(0.5, 1.0, 'Frequency response of Kaiser window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// (-0.5, 0.5, -100.0, ...) # may vary +// >>> plt.show() // -// Assemble an nd-array from nested lists of blocks. // -// Blocks in the innermost lists are concatenated (see `concatenate`) along -// the last dimension (-1), then these are concatenated along the -// second-last dimension (-2), and so on until the outermost list is reached. // -// Blocks can be of any dimension, but will not be broadcasted using -// the normal rules. Instead, leading axes of size 1 are inserted, -// to make ``block.ndim`` the same for all blocks. This is primarily useful -// for working with scalars, and means that code like ``np.block([v, 1])`` -// is valid, where ``v.ndim == 1``. +//go:linkname Kaiser py.kaiser +func Kaiser(M *py.Object, beta *py.Object) *py.Object // -// When the nested list is two levels deep, this allows block matrices to be -// constructed from their components. +// Return the minimum of an array or minimum along an axis. // // Parameters // ---------- -// arrays : nested list of array_like or scalars (but not tuples) -// If passed a single ndarray or scalar (a nested list of depth 0), this -// is returned unmodified (and not copied). +// a : array_like +// Input data. +// axis : None or int or tuple of ints, optional +// Axis or axes along which to operate. By default, flattened input is +// used. // -// Elements shapes must match along the appropriate axes (without -// broadcasting), but leading 1s will be prepended to the shape as -// necessary to make the dimensions match. +// .. versionadded:: 1.7.0 // -// Returns -// ------- -// block_array : ndarray -// The array assembled from the given blocks. +// 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 : ndarray, optional +// Alternative output array in which to place the result. Must +// be of the same shape and buffer length as the expected output. +// See :ref:`ufuncs-output-type` for more details. // -// The dimensionality of the output is equal to the greatest of: +// 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 input array. // -// * the dimensionality of all the inputs -// * the depth to which the input list is nested +// If the default value is passed, then `keepdims` will not be +// passed through to the ``min`` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. // -// Raises -// ------ -// ValueError -// * If list depths are mismatched - for instance, ``[[a, b], c]`` is -// illegal, and should be spelt ``[[a, b], [c]]`` -// * If lists are empty - for instance, ``[[a, b], []]`` +// initial : scalar, optional +// The maximum value of an output element. Must be present to allow +// computation on empty slice. See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.15.0 +// +// where : array_like of bool, optional +// Elements to compare for the minimum. See `~numpy.ufunc.reduce` +// for details. +// +// .. versionadded:: 1.17.0 +// +// Returns +// ------- +// min : ndarray or scalar +// Minimum of `a`. If `axis` is None, the result is a scalar value. +// 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 // -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// vstack : Stack arrays in sequence vertically (row wise). -// hstack : Stack arrays in sequence horizontally (column wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// vsplit : Split an array into multiple sub-arrays vertically (row-wise). -// unstack : Split an array into a tuple of sub-arrays along an axis. +// amax : +// The maximum value of an array along a given axis, propagating any NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignoring any NaNs. +// minimum : +// Element-wise minimum of two arrays, propagating any NaNs. +// fmin : +// Element-wise minimum of two arrays, ignoring any NaNs. +// argmin : +// Return the indices of the minimum values. +// +// nanmax, maximum, fmax // // Notes // ----- -// When called with only scalars, ``np.block`` is equivalent to an ndarray -// call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to -// ``np.array([[1, 2], [3, 4]])``. +// NaN values are propagated, that is if at least one item is NaN, the +// corresponding min value will be NaN as well. To ignore NaN values +// (MATLAB behavior), please use nanmin. // -// This function does not enforce that the blocks lie on a fixed grid. -// ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form:: +// Don't use `~numpy.min` for element-wise comparison of 2 arrays; when +// ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than +// ``min(a, axis=0)``. // -// AAAbb -// AAAbb -// cccDD +// Examples +// -------- +// >>> a = np.arange(4).reshape((2,2)) +// >>> a +// array([[0, 1], +// [2, 3]]) +// >>> np.min(a) # Minimum of the flattened array +// 0 +// >>> np.min(a, axis=0) # Minima along the first axis +// array([0, 1]) +// >>> np.min(a, axis=1) # Minima along the second axis +// array([0, 2]) +// >>> np.min(a, where=[False, True], initial=10, axis=0) +// array([10, 1]) // -// But is also allowed to produce, for some ``a, b, c, d``:: +// >>> b = np.arange(5, dtype=float) +// >>> b[2] = np.NaN +// >>> np.min(b) +// nan +// >>> np.min(b, where=~np.isnan(b), initial=10) +// 0.0 +// >>> np.nanmin(b) +// 0.0 // -// AAAbb -// AAAbb -// cDDDD +// >>> np.min([[-50], [10]], axis=-1, initial=0) +// array([-50, 0]) // -// Since concatenation happens along the last axis first, `block` is *not* -// capable of producing the following directly:: +// Notice that the initial value is used as one of the elements for which the +// minimum is determined, unlike for the default argument Python's max +// function, which is only used for empty iterables. // -// AAAbb -// cccbb -// cccDD -// -// Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is -// equivalent to ``np.block([[A, B, ...], [p, q, ...]])``. -// -// Examples -// -------- -// The most common use of this function is to build a block matrix: -// -// >>> import numpy as np -// >>> A = np.eye(2) * 2 -// >>> B = np.eye(3) * 3 -// >>> np.block([ -// ... [A, np.zeros((2, 3))], -// ... [np.ones((3, 2)), B ] -// ... ]) -// array([[2., 0., 0., 0., 0.], -// [0., 2., 0., 0., 0.], -// [1., 1., 3., 0., 0.], -// [1., 1., 0., 3., 0.], -// [1., 1., 0., 0., 3.]]) -// -// With a list of depth 1, `block` can be used as `hstack`: -// -// >>> np.block([1, 2, 3]) # hstack([1, 2, 3]) -// array([1, 2, 3]) -// -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.block([a, b, 10]) # hstack([a, b, 10]) -// array([ 1, 2, 3, 4, 5, 6, 10]) -// -// >>> A = np.ones((2, 2), int) -// >>> B = 2 * A -// >>> np.block([A, B]) # hstack([A, B]) -// array([[1, 1, 2, 2], -// [1, 1, 2, 2]]) -// -// With a list of depth 2, `block` can be used in place of `vstack`: -// -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.block([[a], [b]]) # vstack([a, b]) -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// >>> A = np.ones((2, 2), int) -// >>> B = 2 * A -// >>> np.block([[A], [B]]) # vstack([A, B]) -// array([[1, 1], -// [1, 1], -// [2, 2], -// [2, 2]]) -// -// It can also be used in place of `atleast_1d` and `atleast_2d`: -// -// >>> a = np.array(0) -// >>> b = np.array([1]) -// >>> np.block([a]) # atleast_1d(a) -// array([0]) -// >>> np.block([b]) # atleast_1d(b) -// array([1]) -// -// >>> np.block([[a]]) # atleast_2d(a) -// array([[0]]) -// >>> np.block([[b]]) # atleast_2d(b) -// array([[1]]) +// Notice that this isn't the same as Python's ``default`` argument. // +// >>> np.min([6], initial=5) +// 5 +// >>> min([6], default=5) +// 6 // // +//go:linkname Min py.min +func Min(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object // -//go:linkname Block py.block -func Block(arrays *py.Object) *py.Object -// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Compute the variance along the specified axis. // -// Return the cube-root of an array, element-wise. +// Returns the variance of the array elements, a measure of the spread of a +// distribution. The variance is computed for the flattened array by +// default, otherwise over the specified axis. // -// Parameters -// ---------- -// x : array_like -// The values whose cube-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Parameters +// ---------- +// a : array_like +// Array containing numbers whose variance is desired. If `a` is not an +// array, a conversion is attempted. +// axis : None or int or tuple of ints, optional +// Axis or axes along which the variance is computed. The default is to +// compute the variance of the flattened array. // -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the -// cube root of each element in `x`. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. +// .. versionadded:: 1.7.0 // +// If this is a tuple of ints, a variance is performed over multiple axes, +// instead of a single axis or all the axes as before. +// dtype : data-type, optional +// Type to use in computing the variance. For arrays of integer type +// the default is `float64`; for arrays of float types it is the same as +// the array type. +// out : ndarray, optional +// Alternate output array in which to place the result. It must have +// the same shape as the expected output, but the type is cast if +// necessary. +// ddof : int, optional +// "Delta Degrees of Freedom": the divisor used in the calculation is +// ``N - ddof``, where ``N`` represents the number of elements. By +// default `ddof` is zero. +// 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 input array. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.cbrt([1,8,27]) -// array([ 1., 2., 3.]) +// If the default value is passed, then `keepdims` will not be +// passed through to the `var` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. // -//go:linkname Cbrt py.cbrt -func Cbrt(x *py.Object, out *py.Object) *py.Object +// where : array_like of bool, optional +// Elements to include in the variance. See `~numpy.ufunc.reduce` for +// details. // -// Return the current print options. +// .. versionadded:: 1.20.0 // // Returns // ------- -// print_opts : dict -// Dictionary of current print options with keys -// -// - precision : int -// - threshold : int -// - edgeitems : int -// - linewidth : int -// - suppress : bool -// - nanstr : str -// - infstr : str -// - sign : str -// - formatter : dict of callables -// - floatmode : str -// - legacy : str or False -// -// For a full description of these options, see `set_printoptions`. +// variance : ndarray, see dtype parameter above +// If ``out=None``, returns a new array containing the variance; +// otherwise, a reference to the output array is returned. // // See Also // -------- -// set_printoptions, printoptions -// -// Examples -// -------- -// >>> import numpy as np -// -// >>> np.get_printoptions() -// {'edgeitems': 3, 'threshold': 1000, ..., 'override_repr': None} -// -// >>> np.get_printoptions()['linewidth'] -// 75 -// >>> np.set_printoptions(linewidth=100) -// >>> np.get_printoptions()['linewidth'] -// 100 -// -// -// -//go:linkname GetPrintoptions py.get_printoptions -func GetPrintoptions() *py.Object -// -// lexsort(keys, axis=-1) -// -// Perform an indirect stable sort using a sequence of keys. +// std, mean, nanmean, nanstd, nanvar +// :ref:`ufuncs-output-type` // -// Given multiple sorting keys, lexsort returns an array of integer indices -// that describes the sort order by multiple keys. The last key in the -// sequence is used for the primary sort order, ties are broken by the -// second-to-last key, and so on. +// Notes +// ----- +// The variance is the average of the squared deviations from the mean, +// i.e., ``var = mean(x)``, where ``x = abs(a - a.mean())**2``. // -// Parameters -// ---------- -// keys : (k, m, n, ...) array-like -// The `k` keys to be sorted. The *last* key (e.g, the last -// row if `keys` is a 2D array) is the primary sort key. -// Each element of `keys` along the zeroth axis must be -// an array-like object of the same shape. -// axis : int, optional -// Axis to be indirectly sorted. By default, sort over the last axis -// of each sequence. Separate slices along `axis` sorted over -// independently; see last example. +// The mean is typically calculated as ``x.sum() / N``, where ``N = len(x)``. +// If, however, `ddof` is specified, the divisor ``N - ddof`` is used +// instead. In standard statistical practice, ``ddof=1`` provides an +// unbiased estimator of the variance of a hypothetical infinite population. +// ``ddof=0`` provides a maximum likelihood estimate of the variance for +// normally distributed variables. // -// Returns -// ------- -// indices : (m, n, ...) ndarray of ints -// Array of indices that sort the keys along the specified axis. +// Note that for complex numbers, the absolute value is taken before +// squaring, so that the result is always real and nonnegative. // -// See Also -// -------- -// argsort : Indirect sort. -// ndarray.sort : In-place sort. -// sort : Return a sorted copy of an array. +// For floating-point input, the variance is computed using the same +// precision the input has. Depending on the input data, this can cause +// the results to be inaccurate, especially for `float32` (see example +// below). Specifying a higher-accuracy accumulator using the ``dtype`` +// keyword can alleviate this issue. // // Examples // -------- -// Sort names: first by surname, then by name. +// >>> a = np.array([[1, 2], [3, 4]]) +// >>> np.var(a) +// 1.25 +// >>> np.var(a, axis=0) +// array([1., 1.]) +// >>> np.var(a, axis=1) +// array([0.25, 0.25]) // -// >>> import numpy as np -// >>> surnames = ('Hertz', 'Galilei', 'Hertz') -// >>> first_names = ('Heinrich', 'Galileo', 'Gustav') -// >>> ind = np.lexsort((first_names, surnames)) -// >>> ind -// array([1, 2, 0]) +// In single precision, var() can be inaccurate: // -// >>> [surnames[i] + ", " + first_names[i] for i in ind] -// ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich'] +// >>> a = np.zeros((2, 512*512), dtype=np.float32) +// >>> a[0, :] = 1.0 +// >>> a[1, :] = 0.1 +// >>> np.var(a) +// 0.20250003 // -// Sort according to two numerical keys, first by elements -// of ``a``, then breaking ties according to elements of ``b``: +// Computing the variance in float64 is more accurate: // -// >>> a = [1, 5, 1, 4, 3, 4, 4] # First sequence -// >>> b = [9, 4, 0, 4, 0, 2, 1] # Second sequence -// >>> ind = np.lexsort((b, a)) # Sort by `a`, then by `b` -// >>> ind -// array([2, 0, 4, 6, 5, 3, 1]) -// >>> [(a[i], b[i]) for i in ind] -// [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)] +// >>> np.var(a, dtype=np.float64) +// 0.20249999932944759 # may vary +// >>> ((1-0.55)**2 + (0.1-0.55)**2)/2 +// 0.2025 // -// Compare against `argsort`, which would sort each key independently. +// Specifying a where argument: // -// >>> np.argsort((b, a), kind='stable') -// array([[2, 4, 6, 5, 1, 3, 0], -// [0, 2, 4, 3, 5, 6, 1]]) +// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) +// >>> np.var(a) +// 6.833333333333333 # may vary +// >>> np.var(a, where=[[True], [True], [False]]) +// 4.0 // -// To sort lexicographically with `argsort`, we would need to provide a -// structured array. // -// >>> x = np.array([(ai, bi) for ai, bi in zip(a, b)], -// ... dtype = np.dtype([('x', int), ('y', int)])) -// >>> np.argsort(x) # or np.argsort(x, order=('x', 'y')) -// array([2, 0, 4, 6, 5, 3, 1]) // -// The zeroth axis of `keys` always corresponds with the sequence of keys, -// so 2D arrays are treated just like other sequences of keys. +//go:linkname Var py.var +func Var(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object // -// >>> arr = np.asarray([b, a]) -// >>> ind2 = np.lexsort(arr) -// >>> np.testing.assert_equal(ind2, ind) +// Reverse the order of elements in an array along the given axis. // -// Accordingly, the `axis` parameter refers to an axis of *each* key, not of -// the `keys` argument itself. For instance, the array ``arr`` is treated as -// a sequence of two 1-D keys, so specifying ``axis=0`` is equivalent to -// using the default axis, ``axis=-1``. +// The shape of the array is preserved, but the elements are reordered. // -// >>> np.testing.assert_equal(np.lexsort(arr, axis=0), -// ... np.lexsort(arr, axis=-1)) +// .. versionadded:: 1.12.0 // -// For higher-dimensional arrays, the axis parameter begins to matter. The -// resulting array has the same shape as each key, and the values are what -// we would expect if `lexsort` were performed on corresponding slices -// of the keys independently. For instance, +// Parameters +// ---------- +// m : array_like +// Input array. +// axis : None or int or tuple of ints, optional +// Axis or axes along which to flip over. The default, +// axis=None, will flip over all of the axes of the input array. +// If axis is negative it counts from the last to the first axis. // -// >>> x = [[1, 2, 3, 4], -// ... [4, 3, 2, 1], -// ... [2, 1, 4, 3]] -// >>> y = [[2, 2, 1, 1], -// ... [1, 2, 1, 2], -// ... [1, 1, 2, 1]] -// >>> np.lexsort((x, y), axis=1) -// array([[2, 3, 0, 1], -// [2, 0, 3, 1], -// [1, 0, 3, 2]]) +// If axis is a tuple of ints, flipping is performed on all of the axes +// specified in the tuple. // -// Each row of the result is what we would expect if we were to perform -// `lexsort` on the corresponding row of the keys: +// .. versionchanged:: 1.15.0 +// None and tuples of axes are supported // -// >>> for i in range(3): -// ... print(np.lexsort((x[i], y[i]))) -// [2 3 0 1] -// [2 0 3 1] -// [1 0 3 2] +// Returns +// ------- +// out : array_like +// A view of `m` with the entries of axis reversed. Since a view is +// returned, this operation is done in constant time. // +// See Also +// -------- +// flipud : Flip an array vertically (axis=0). +// fliplr : Flip an array horizontally (axis=1). // +// Notes +// ----- +// flip(m, 0) is equivalent to flipud(m). // -//go:linkname Lexsort py.lexsort -func Lexsort(keys *py.Object, axis *py.Object) *py.Object +// flip(m, 1) is equivalent to fliplr(m). // -// Roll array elements along a given axis. +// flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n. // -// Elements that roll beyond the last position are re-introduced at -// the first. +// flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all +// positions. // -// Parameters -// ---------- -// a : array_like -// Input array. -// shift : int or tuple of ints -// The number of places by which elements are shifted. If a tuple, -// then `axis` must be a tuple of the same size, and each of the -// given axes is shifted by the corresponding number. If an int -// while `axis` is a tuple of ints, then the same value is used for -// all given axes. -// axis : int or tuple of ints, optional -// Axis or axes along which elements are shifted. By default, the -// array is flattened before shifting, after which the original -// shape is restored. -// -// Returns -// ------- -// res : ndarray -// Output array, with the same shape as `a`. +// flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at +// position 0 and position 1. // -// See Also +// Examples // -------- -// rollaxis : Roll the specified axis backwards, until it lies in a -// given position. +// >>> A = np.arange(8).reshape((2,2,2)) +// >>> A +// array([[[0, 1], +// [2, 3]], +// [[4, 5], +// [6, 7]]]) +// >>> np.flip(A, 0) +// array([[[4, 5], +// [6, 7]], +// [[0, 1], +// [2, 3]]]) +// >>> np.flip(A, 1) +// array([[[2, 3], +// [0, 1]], +// [[6, 7], +// [4, 5]]]) +// >>> np.flip(A) +// array([[[7, 6], +// [5, 4]], +// [[3, 2], +// [1, 0]]]) +// >>> np.flip(A, (0, 2)) +// array([[[5, 4], +// [7, 6]], +// [[1, 0], +// [3, 2]]]) +// >>> A = np.random.randn(3,4,5) +// >>> np.all(np.flip(A,2) == A[:,:,::-1,...]) +// True // -// Notes -// ----- -// Supports rolling over multiple dimensions simultaneously. // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.arange(10) -// >>> np.roll(x, 2) -// array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) -// >>> np.roll(x, -2) -// array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]) +//go:linkname Flip py.flip +func Flip(m *py.Object, axis *py.Object) *py.Object // -// >>> x2 = np.reshape(x, (2, 5)) -// >>> x2 -// array([[0, 1, 2, 3, 4], -// [5, 6, 7, 8, 9]]) -// >>> np.roll(x2, 1) -// array([[9, 0, 1, 2, 3], -// [4, 5, 6, 7, 8]]) -// >>> np.roll(x2, -1) -// array([[1, 2, 3, 4, 5], -// [6, 7, 8, 9, 0]]) -// >>> np.roll(x2, 1, axis=0) -// array([[5, 6, 7, 8, 9], -// [0, 1, 2, 3, 4]]) -// >>> np.roll(x2, -1, axis=0) -// array([[5, 6, 7, 8, 9], -// [0, 1, 2, 3, 4]]) -// >>> np.roll(x2, 1, axis=1) -// array([[4, 0, 1, 2, 3], -// [9, 5, 6, 7, 8]]) -// >>> np.roll(x2, -1, axis=1) -// array([[1, 2, 3, 4, 0], -// [6, 7, 8, 9, 5]]) -// >>> np.roll(x2, (1, 1), axis=(1, 0)) -// array([[9, 5, 6, 7, 8], -// [4, 0, 1, 2, 3]]) -// >>> np.roll(x2, (2, 1), axis=(1, 0)) -// array([[8, 9, 5, 6, 7], -// [3, 4, 0, 1, 2]]) +// Split an array into multiple sub-arrays. // +// Please refer to the ``split`` documentation. The only difference +// between these functions is that ``array_split`` allows +// `indices_or_sections` to be an integer that does *not* equally +// divide the axis. For an array of length l that should be split +// into n sections, it returns l % n sub-arrays of size l//n + 1 +// and the rest of size l//n. // +// See Also +// -------- +// split : Split array into multiple sub-arrays of equal size. // -//go:linkname Roll py.roll -func Roll(__llgo_va_list ...interface{}) *py.Object +// Examples +// -------- +// >>> x = np.arange(8.0) +// >>> np.array_split(x, 3) +// [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])] // -// Join a sequence of arrays along a new axis. +// >>> x = np.arange(9) +// >>> np.array_split(x, 4) +// [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])] // -// The ``axis`` parameter specifies the index of the new axis in the -// dimensions of the result. For example, if ``axis=0`` it will be the first -// dimension and if ``axis=-1`` it will be the last dimension. // -// Parameters -// ---------- -// arrays : sequence of ndarrays -// Each array must have the same shape. In the case of a single ndarray -// array_like input, it will be treated as a sequence of arrays; i.e., -// each element along the zeroth axis is treated as a separate array. // -// axis : int, optional -// The axis in the result array along which the input arrays are stacked. +//go:linkname ArraySplit py.array_split +func ArraySplit(ary *py.Object, indicesOrSections *py.Object, axis *py.Object) *py.Object // -// out : ndarray, optional -// If provided, the destination to place the result. The shape must be -// correct, matching that of what stack would have returned if no -// out argument were specified. +// Evaluate a polynomial at specific values. // -// dtype : str or dtype -// If provided, the destination array will have this dtype. Cannot be -// provided together with `out`. +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. // -// .. versionadded:: 1.24 +// If `p` is of length N, this function returns the value: // -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Defaults to 'same_kind'. +// ``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]`` // -// .. versionadded:: 1.24 +// If `x` is a sequence, then ``p(x)`` is returned for each element of ``x``. +// If `x` is another polynomial then the composite polynomial ``p(x(t))`` +// is returned. // +// Parameters +// ---------- +// p : array_like or poly1d object +// 1D array of polynomial coefficients (including coefficients equal +// to zero) from highest degree to the constant term, or an +// instance of poly1d. +// x : array_like or poly1d object +// A number, an array of numbers, or an instance of poly1d, at +// which to evaluate `p`. // // Returns // ------- -// stacked : ndarray -// The stacked array has one more dimension than the input arrays. +// values : ndarray or poly1d +// If `x` is a poly1d instance, the result is the composition of the two +// polynomials, i.e., `x` is "substituted" in `p` and the simplified +// result is returned. In addition, the type of `x` - array_like or +// poly1d - governs the type of the output: `x` array_like => `values` +// array_like, `x` a poly1d object => `values` is also. // // See Also // -------- -// concatenate : Join a sequence of arrays along an existing axis. -// block : Assemble an nd-array from nested lists of blocks. -// split : Split array into a list of multiple sub-arrays of equal size. -// unstack : Split an array into a tuple of sub-arrays along an axis. -// -// Examples -// -------- -// >>> import numpy as np -// >>> rng = np.random.default_rng() -// >>> arrays = [rng.normal(size=(3,4)) for _ in range(10)] -// >>> np.stack(arrays, axis=0).shape -// (10, 3, 4) -// -// >>> np.stack(arrays, axis=1).shape -// (3, 10, 4) +// poly1d: A polynomial class. // -// >>> np.stack(arrays, axis=2).shape -// (3, 4, 10) +// Notes +// ----- +// Horner's scheme [1]_ is used to evaluate the polynomial. Even so, +// for polynomials of high degree the values may be inaccurate due to +// rounding errors. Use carefully. // -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.stack((a, b)) -// array([[1, 2, 3], -// [4, 5, 6]]) +// If `x` is a subtype of `ndarray` the return value will be of the same type. // -// >>> np.stack((a, b), axis=-1) -// array([[1, 4], -// [2, 5], -// [3, 6]]) +// References +// ---------- +// .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng. +// trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand +// Reinhold Co., 1985, pg. 720. // +// Examples +// -------- +// >>> np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1 +// 76 +// >>> np.polyval([3,0,1], np.poly1d(5)) +// poly1d([76]) +// >>> np.polyval(np.poly1d([3,0,1]), 5) +// 76 +// >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5)) +// poly1d([76]) // // -//go:linkname Stack py.stack -func Stack(arrays *py.Object, axis *py.Object, out *py.Object) *py.Object // -// Stack arrays in sequence vertically (row wise). +//go:linkname Polyval py.polyval +func Polyval(p *py.Object, x *py.Object) *py.Object // -// This is equivalent to concatenation along the first axis after 1-D arrays -// of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by -// `vsplit`. +// Return the indices of the maximum values in the specified axis ignoring +// NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the +// results cannot be trusted if a slice contains only NaNs and -Infs. // -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// and r/g/b channels (third axis). The functions `concatenate`, `stack` and -// `block` provide more general stacking and concatenation operations. // // 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. In the case of a single -// array_like input, it will be treated as a sequence of arrays; i.e., -// each element along the zeroth axis is treated as a separate array. -// -// dtype : str or dtype -// If provided, the destination array will have this dtype. Cannot be -// provided together with `out`. -// -// .. versionadded:: 1.24 +// a : array_like +// Input data. +// axis : int, optional +// Axis along which to operate. By default flattened input is used. +// out : array, optional +// If provided, the result will be inserted into this array. It should +// be of the appropriate shape and dtype. // -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Defaults to 'same_kind'. +// .. versionadded:: 1.22.0 +// 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 array. // -// .. versionadded:: 1.24 +// .. versionadded:: 1.22.0 // // Returns // ------- -// stacked : ndarray -// The array formed by stacking the given arrays, will be at least 2-D. +// index_array : ndarray +// An array of indices or a single index value. // // See Also // -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// hstack : Stack arrays in sequence horizontally (column wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// vsplit : Split an array into multiple sub-arrays vertically (row-wise). -// unstack : Split an array into a tuple of sub-arrays along an axis. +// argmax, nanargmin // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.vstack((a,b)) -// array([[1, 2, 3], -// [4, 5, 6]]) +// >>> a = np.array([[np.nan, 4], [2, 3]]) +// >>> np.argmax(a) +// 0 +// >>> np.nanargmax(a) +// 1 +// >>> np.nanargmax(a, axis=0) +// array([1, 0]) +// >>> np.nanargmax(a, axis=1) +// array([1, 1]) // -// >>> a = np.array([[1], [2], [3]]) -// >>> b = np.array([[4], [5], [6]]) -// >>> np.vstack((a,b)) -// array([[1], -// [2], -// [3], -// [4], -// [5], -// [6]]) // // +//go:linkname Nanargmax py.nanargmax +func Nanargmax(a *py.Object, axis *py.Object, out *py.Object) *py.Object // -//go:linkname RowStack py.row_stack -func RowStack(tup *py.Object) *py.Object +// Move axes of an array to new positions. // -// Copies an array to a specified data type. +// Other axes remain in their original order. // -// This function is an Array API compatible alternative to -// `numpy.ndarray.astype`. +// .. versionadded:: 1.11.0 // // Parameters // ---------- -// x : ndarray -// Input NumPy array to cast. ``array_likes`` are explicitly not -// supported here. -// dtype : dtype -// Data type of the result. -// copy : bool, optional -// Specifies whether to copy an array when the specified dtype matches -// the data type of the input array ``x``. If ``True``, a newly allocated -// array must always be returned. If ``False`` and the specified dtype -// matches the data type of the input array, the input array must be -// returned; otherwise, a newly allocated array must be returned. -// Defaults to ``True``. -// device : str, optional -// The device on which to place the returned array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. -// -// .. versionadded:: 2.1.0 +// a : np.ndarray +// The array whose axes should be reordered. +// source : int or sequence of int +// Original positions of the axes to move. These must be unique. +// destination : int or sequence of int +// Destination positions for each of the original axes. These must also be +// unique. // // Returns // ------- -// out : ndarray -// An array having the specified data type. +// result : np.ndarray +// Array with moved axes. This array is a view of the input array. // // See Also // -------- -// ndarray.astype +// transpose : Permute the dimensions of an array. +// swapaxes : Interchange two axes of an array. // // Examples // -------- -// >>> import numpy as np -// >>> arr = np.array([1, 2, 3]); arr -// array([1, 2, 3]) -// >>> np.astype(arr, np.float64) -// array([1., 2., 3.]) +// >>> x = np.zeros((3, 4, 5)) +// >>> np.moveaxis(x, 0, -1).shape +// (4, 5, 3) +// >>> np.moveaxis(x, -1, 0).shape +// (5, 3, 4) // -// Non-copy case: +// These all achieve the same result: // -// >>> arr = np.array([1, 2, 3]) -// >>> arr_noncpy = np.astype(arr, arr.dtype, copy=False) -// >>> np.shares_memory(arr, arr_noncpy) -// True +// >>> np.transpose(x).shape +// (5, 4, 3) +// >>> np.swapaxes(x, 0, -1).shape +// (5, 4, 3) +// >>> np.moveaxis(x, [0, 1], [-1, -2]).shape +// (5, 4, 3) +// >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape +// (5, 4, 3) // // // -//go:linkname Astype py.astype -func Astype(x *py.Object, dtype *py.Object) *py.Object +//go:linkname Moveaxis py.moveaxis +func Moveaxis(a *py.Object, source *py.Object, destination *py.Object) *py.Object // -// Counts the number of non-zero values in the array ``a``. +// Replace NaN with zero and infinity with large finite numbers (default +// behaviour) or with the numbers defined by the user using the `nan`, +// `posinf` and/or `neginf` keywords. // -// The word "non-zero" is in reference to the Python 2.x -// built-in method ``__nonzero__()`` (renamed ``__bool__()`` -// in Python 3.x) of Python objects that tests an object's -// "truthfulness". For example, any number is considered -// truthful if it is nonzero, whereas any string is considered -// truthful if it is not the empty string. Thus, this function -// (recursively) counts how many elements in ``a`` (and in -// sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()`` -// method evaluated to ``True``. +// 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 +// value in `neginf` keyword. +// +// For complex dtypes, the above is applied to each of the real and +// imaginary components of `x` separately. +// +// If `x` is not inexact, then no replacements are made. // // Parameters // ---------- -// a : array_like -// The array for which to count non-zeros. -// axis : int or tuple, optional -// Axis or tuple of axes along which to count non-zeros. -// Default is None, meaning that non-zeros will be counted -// along a flattened version of ``a``. -// keepdims : bool, optional -// If this is set to True, the axes that are counted are left -// in the result as dimensions with size one. With this option, -// the result will broadcast correctly against the input array. +// x : scalar or array_like +// Input data. +// copy : bool, optional +// Whether to create a copy of `x` (True) or to replace values +// 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 +// 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 +// 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 +// passed then negative infinity values will be replaced with a very +// small (or negative) number. +// +// .. versionadded:: 1.17 +// +// // // Returns // ------- -// count : int or array of int -// Number of non-zero values in the array along a given axis. -// Otherwise, the total number of non-zero values in the array -// is returned. +// out : ndarray +// `x`, with the non-finite values replaced. If `copy` is False, this may +// be `x` itself. // // See Also // -------- -// nonzero : Return the coordinates of all the non-zero values. +// isinf : Shows which elements are positive or negative infinity. +// isneginf : Shows which elements are negative infinity. +// isposinf : Shows which elements are positive infinity. +// isnan : Shows which elements are Not a Number (NaN). +// isfinite : Shows which elements are finite (not NaN, not infinity) +// +// Notes +// ----- +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). This means that Not a Number is not equivalent to infinity. // // Examples // -------- -// >>> import numpy as np -// >>> np.count_nonzero(np.eye(4)) -// 4 -// >>> a = np.array([[0, 1, 7, 0], -// ... [3, 0, 2, 19]]) -// >>> np.count_nonzero(a) -// 5 -// >>> np.count_nonzero(a, axis=0) -// array([1, 1, 2, 1]) -// >>> np.count_nonzero(a, axis=1) -// array([2, 3]) -// >>> np.count_nonzero(a, axis=1, keepdims=True) -// array([[2], -// [3]]) -// +// >>> np.nan_to_num(np.inf) +// 1.7976931348623157e+308 +// >>> np.nan_to_num(-np.inf) +// -1.7976931348623157e+308 +// >>> np.nan_to_num(np.nan) +// 0.0 +// >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128]) +// >>> np.nan_to_num(x) +// 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, +// -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 +// -1.28000000e+002, 1.28000000e+002]) +// >>> np.nan_to_num(y) +// array([ 1.79769313e+308 +0.00000000e+000j, # may vary +// 0.00000000e+000 +0.00000000e+000j, +// 0.00000000e+000 +1.79769313e+308j]) +// >>> np.nan_to_num(y, nan=111111, posinf=222222) +// array([222222.+111111.j, 111111. +0.j, 111111.+222222.j]) // -//go:linkname CountNonzero py.count_nonzero -func CountNonzero(a *py.Object, axis *py.Object) *py.Object -// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Return element-wise quotient and remainder simultaneously. +//go:linkname NanToNum py.nan_to_num +func NanToNum(x *py.Object, copy *py.Object, nan *py.Object, posinf *py.Object, neginf *py.Object) *py.Object // -// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster -// because it avoids redundant work. It is used to implement the Python -// built-in function ``divmod`` on NumPy arrays. +// Return the Hamming window. // -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// The Hamming window is a taper formed by using a weighted cosine. // -// Returns -// ------- -// out1 : ndarray -// Element-wise quotient resulting from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// out2 : ndarray -// Element-wise remainder from floor division. -// This is a scalar if both `x1` and `x2` are scalars. +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. // -// See Also -// -------- -// floor_divide : Equivalent to Python's ``//`` operator. -// remainder : Equivalent to Python's ``%`` operator. -// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return -// values switched. +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value +// one appears only if the number of samples is odd). // -// Examples -// -------- -// >>> import numpy as np -// >>> np.divmod(np.arange(5), 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// See Also +// -------- +// bartlett, blackman, hanning, kaiser // -// The `divmod` function can be used as a shorthand for ``np.divmod`` on -// ndarrays. +// Notes +// ----- +// The Hamming window is defined as // -// >>> x = np.arange(5) -// >>> divmod(x, 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) +// .. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right) +// \qquad 0 \leq n \leq M-1 // -//go:linkname Divmod py.divmod -func Divmod(x1 *py.Object, x2 *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object +// The Hamming was named for R. W. Hamming, an associate of J. W. Tukey +// and is described in Blackman and Tukey. It was recommended for +// smoothing the truncated autocovariance function in the time domain. +// Most references to the Hamming window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. 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. // -// empty_like(prototype, dtype=None, order='K', subok=True, shape=None, *, -// device=None) -// -// Return a new array with the same shape and type as a given array. -// -// Parameters +// References // ---------- -// prototype : array_like -// The shape and data-type of `prototype` define these same attributes -// of the returned array. -// dtype : data-type, optional -// Overrides the data type of the result. -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `prototype` is Fortran -// contiguous, 'C' otherwise. 'K' means match the layout of `prototype` -// as closely as possible. -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `prototype`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. -// -// .. versionadded:: 2.0.0 -// -// Returns -// ------- -// out : ndarray -// Array of uninitialized (arbitrary) data with the same -// shape and type as `prototype`. +// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power +// spectra, Dover Publications, New York. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The +// University of Alberta Press, 1975, pp. 109-110. +// .. [3] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 425. // -// See Also +// Examples // -------- -// ones_like : Return an array of ones with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. +// >>> np.hamming(12) +// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary +// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, +// 0.15302337, 0.08 ]) // -// Notes -// ----- -// Unlike other array creation functions (e.g. `zeros_like`, `ones_like`, -// `full_like`), `empty_like` does not initialize the values of the array, -// and may therefore be marginally faster. However, the values stored in the -// newly allocated array are arbitrary. For reproducible behavior, be sure -// to set each element of the array before reading. +// Plot the window and the frequency response: // -// Examples -// -------- -// >>> import numpy as np -// >>> a = ([1,2,3], [4,5,6]) # a is array-like -// >>> np.empty_like(a) -// array([[-1073741821, -1073741821, 3], # uninitialized -// [ 0, 0, -1073741821]]) -// >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) -// >>> np.empty_like(a) -// array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], # uninitialized -// [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]]) +// >>> import matplotlib.pyplot as plt +// >>> from numpy.fft import fft, fftshift +// >>> window = np.hamming(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Hamming window") +// Text(0.5, 1.0, 'Hamming window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() // +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> response = 20 * np.log10(mag) +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Hamming window") +// Text(0.5, 1.0, 'Frequency response of Hamming window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> plt.axis('tight') +// ... +// >>> plt.show() // // -//go:linkname EmptyLike py.empty_like -func EmptyLike(prototype *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object -// fromstring(string, dtype=float, count=-1, *, sep, like=None) // -// A new 1-D array initialized from text data in a string. +//go:linkname Hamming py.hamming +func Hamming(M *py.Object) *py.Object +// +// Return the indices of the minimum values in the specified axis ignoring +// NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results +// cannot be trusted if a slice contains only NaNs and Infs. // // Parameters // ---------- -// string : str -// A string containing the data. -// dtype : data-type, optional -// The data type of the array; default: float. For binary input data, -// the data must be in exactly this format. Most builtin numeric types are -// supported and extension types may be supported. -// count : int, optional -// Read this number of `dtype` elements from the data. If this is -// negative (the default), the count will be determined from the -// length of the data. -// sep : str, optional -// The string separating numbers in the data; extra whitespace between -// elements is also ignored. -// -// .. deprecated:: 1.14 -// Passing ``sep=''``, the default, is deprecated since it will -// trigger the deprecated binary mode of this function. This mode -// interprets `string` as binary bytes, rather than ASCII text with -// 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 utf-8, which will not produce sane results. +// a : array_like +// Input data. +// axis : int, optional +// Axis along which to operate. By default flattened input is used. +// out : array, optional +// If provided, the result will be inserted into this array. It should +// be of the appropriate shape and dtype. // -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// .. versionadded:: 1.22.0 +// 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 array. // -// .. versionadded:: 1.20.0 +// .. versionadded:: 1.22.0 // // Returns // ------- -// arr : ndarray -// The constructed array. -// -// Raises -// ------ -// ValueError -// If the string is not the correct size to satisfy the requested -// `dtype` and `count`. +// index_array : ndarray +// An array of indices or a single index value. // // See Also // -------- -// frombuffer, fromfile, fromiter +// argmin, nanargmax // // Examples // -------- -// >>> import numpy as np -// >>> np.fromstring('1 2', dtype=int, sep=' ') -// array([1, 2]) -// >>> np.fromstring('1, 2', dtype=int, sep=',') -// array([1, 2]) -// -//go:linkname Fromstring py.fromstring -func Fromstring(string *py.Object, dtype *py.Object, count *py.Object) *py.Object -// -// Find the unique elements of an array. -// -// Returns the sorted unique elements of an array. There are three optional -// outputs in addition to the unique elements: -// -// * the indices of the input array that give the unique values -// * the indices of the unique array that reconstruct the input array -// * the number of times each unique value comes up in the input array -// -// Parameters -// ---------- -// ar : array_like -// Input array. Unless `axis` is specified, this will be flattened if it -// is not already 1-D. -// return_index : bool, optional -// If True, also return the indices of `ar` (along the specified axis, -// if provided, or in the flattened array) that result in the unique array. -// return_inverse : bool, optional -// If True, also return the indices of the unique array (for the specified -// axis, if provided) that can be used to reconstruct `ar`. -// return_counts : bool, optional -// If True, also return the number of times each unique item appears -// in `ar`. -// 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 -// as the elements of a 1-D array with the dimension of the given axis, -// see the notes for more details. Object arrays or structured arrays -// that contain objects are not supported if the `axis` kwarg is used. The -// default is None. -// -// equal_nan : bool, optional -// If True, collapses multiple NaN values in the return array into one. +// >>> a = np.array([[np.nan, 4], [2, 3]]) +// >>> np.argmin(a) +// 0 +// >>> np.nanargmin(a) +// 2 +// >>> np.nanargmin(a, axis=0) +// array([1, 1]) +// >>> np.nanargmin(a, axis=1) +// array([1, 0]) // -// .. versionadded:: 1.24 // -// sorted : bool, optional -// If True, the unique elements are sorted. Elements may be sorted in -// practice even if ``sorted=False``, but this could change without -// notice. // -// .. versionadded:: 2.3 +//go:linkname Nanargmin py.nanargmin +func Nanargmin(a *py.Object, axis *py.Object, out *py.Object) *py.Object // -// Returns -// ------- -// unique : ndarray -// The sorted unique values. -// unique_indices : ndarray, optional -// The indices of the first occurrences of the unique values in the -// original array. Only provided if `return_index` is True. -// unique_inverse : ndarray, optional -// The indices to reconstruct the original array from the -// unique array. Only provided if `return_inverse` is True. -// unique_counts : ndarray, optional -// The number of times each of the unique values comes up in the -// original array. Only provided if `return_counts` is True. +// copyto(dst, src, casting='same_kind', where=True) // -// See Also -// -------- -// repeat : Repeat elements of an array. -// sort : Return a sorted copy of an array. +// Copies values from one array to another, broadcasting as necessary. // -// Notes -// ----- -// When an axis is specified the subarrays indexed by the axis are sorted. -// This is done by making the specified axis the first dimension of the array -// (move the axis to the first dimension to keep the order of the other axes) -// and then flattening the subarrays in C order. The flattened subarrays are -// then viewed as a structured type with each element given a label, with the -// effect that we end up with a 1-D array of structured types that can be -// treated in the same way as any other 1-D array. The result is that the -// flattened subarrays are sorted in lexicographic order starting with the -// first element. +// Raises a TypeError if the `casting` rule is violated, and if +// `where` is provided, it selects which elements to copy. // -// .. versionchanged:: 1.21 -// Like np.sort, NaN will sort to the end of the values. -// For complex arrays all NaN values are considered equivalent -// (no matter whether the NaN is in the real or imaginary part). -// As the representant for the returned array the smallest one in the -// lexicographical order is chosen - see np.sort for how the lexicographical -// order is defined for complex arrays. +// .. versionadded:: 1.7.0 // -// .. versionchanged:: 2.0 -// For multi-dimensional inputs, ``unique_inverse`` is reshaped -// such that the input can be reconstructed using -// ``np.take(unique, unique_inverse, axis=axis)``. The result is -// now not 1-dimensional when ``axis=None``. +// Parameters +// ---------- +// dst : ndarray +// The array into which values are copied. +// src : array_like +// The array from which values are copied. +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional +// Controls what kind of data casting may occur when copying. // -// Note that in NumPy 2.0.0 a higher dimensional array was returned also -// when ``axis`` was not ``None``. This was reverted, but -// ``inverse.reshape(-1)`` can be used to ensure compatibility with both -// versions. +// * 'no' means the data types should not be cast at all. +// * 'equiv' means only byte-order changes are allowed. +// * 'safe' means only casts which can preserve values are allowed. +// * 'same_kind' means only safe casts or casts within a kind, +// like float64 to float32, are allowed. +// * 'unsafe' means any data conversions may be done. +// where : array_like of bool, optional +// 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 // -------- -// >>> import numpy as np -// >>> np.unique([1, 1, 2, 2, 3, 3]) -// array([1, 2, 3]) -// >>> a = np.array([[1, 1], [2, 3]]) -// >>> np.unique(a) +// >>> A = np.array([4, 5, 6]) +// >>> B = [1, 2, 3] +// >>> np.copyto(A, B) +// >>> A // array([1, 2, 3]) // -// Return the unique rows of a 2D array +// >>> 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]]) // -// >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]]) -// >>> np.unique(a, axis=0) -// array([[1, 0, 0], [2, 3, 4]]) // -// Return the indices of the original array that give the unique values: // -// >>> a = np.array(['a', 'b', 'b', 'c', 'a']) -// >>> u, indices = np.unique(a, return_index=True) -// >>> u -// array(['a', 'b', 'c'], dtype='>> indices -// array([0, 1, 3]) -// >>> a[indices] -// array(['a', 'b', 'c'], dtype='>> a = np.array([1, 2, 6, 4, 2, 3, 2]) -// >>> u, indices = np.unique(a, return_inverse=True) -// >>> u -// array([1, 2, 3, 4, 6]) -// >>> indices -// array([0, 1, 4, 3, 1, 2, 1]) -// >>> u[indices] -// array([1, 2, 6, 4, 2, 3, 2]) -// -// Reconstruct the input values from the unique values and counts: -// -// >>> a = np.array([1, 2, 6, 4, 2, 3, 2]) -// >>> values, counts = np.unique(a, return_counts=True) -// >>> values -// array([1, 2, 3, 4, 6]) -// >>> counts -// array([1, 3, 1, 1, 1]) -// >>> np.repeat(values, counts) -// array([1, 2, 2, 2, 3, 4, 6]) # original order not preserved -// -// -// -//go:linkname Unique py.unique -func Unique(ar *py.Object, returnIndex *py.Object, returnInverse *py.Object, returnCounts *py.Object, axis *py.Object) *py.Object -// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Copyto py.copyto +func Copyto(dst *py.Object, src *py.Object, casting *py.Object, where *py.Object) *py.Object +// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Inverse hyperbolic sine element-wise. +// Compute the truth value of x1 AND x2 element-wise. // // Parameters // ---------- -// x : array_like -// Input array. +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -5451,120 +4362,96 @@ func Unique(ar *py.Object, returnIndex *py.Object, returnInverse *py.Object, ret // // Returns // ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `arcsinh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `sinh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arcsinh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// returns ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arcsinh` is a complex analytical function that -// has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from -// the right on the former and from the left on the latter. -// -// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. +// y : ndarray or bool +// Boolean result of the logical AND operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. // -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arcsinh +// See Also +// -------- +// logical_or, logical_not, logical_xor +// bitwise_and // // Examples // -------- -// >>> import numpy as np -// >>> np.arcsinh(np.array([np.e, 10.0])) -// array([ 1.72538256, 2.99822295]) -// -//go:linkname Asinh py.asinh -func Asinh(__llgo_va_list ...interface{}) *py.Object -// frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None) +// >>> np.logical_and(True, False) +// False +// >>> np.logical_and([True, False], [False, False]) +// array([False, False]) // -// Interpret a buffer as a 1-dimensional array. +// >>> x = np.arange(5) +// >>> np.logical_and(x>1, x<4) +// array([False, False, True, True, False]) // -// Parameters -// ---------- -// buffer : buffer_like -// An object that exposes the buffer interface. -// dtype : data-type, optional -// Data-type of the returned array; default: float. -// count : int, optional -// Number of items to read. ``-1`` means all data in the buffer. -// offset : int, optional -// Start reading the buffer from this offset (in bytes); default: 0. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. // -// .. versionadded:: 1.20.0 +// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on +// boolean ndarrays. // -// Returns -// ------- -// out : ndarray +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a & b +// array([False, False]) // -// See also -// -------- -// ndarray.tobytes -// Inverse of this operation, construct Python bytes from the raw data -// bytes in the array. +//go:linkname LogicalAnd py.logical_and +func LogicalAnd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Notes -// ----- -// If the buffer has data that is not in machine byte-order, this should -// be specified as part of the data-type, e.g.:: +// Numerical negative, element-wise. // -// >>> dt = np.dtype(int) -// >>> dt = dt.newbyteorder('>') -// >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP +// Parameters +// ---------- +// x : array_like or scalar +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// The data of the resulting array will not be byteswapped, but will be -// interpreted correctly. +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = -x`. +// This is a scalar if `x` is a scalar. // -// 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 +// -------- +// >>> np.negative([1.,-1.]) +// array([-1., 1.]) // -// Examples -// -------- -// >>> import numpy as np -// >>> s = b'hello world' -// >>> np.frombuffer(s, dtype='S1', count=5, offset=6) -// array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1') +// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on +// ndarrays. // -// >>> np.frombuffer(b'\x01\x02', dtype=np.uint8) -// array([1, 2], dtype=uint8) -// >>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3) -// array([1, 2, 3], dtype=uint8) +// >>> x1 = np.array(([1., -1.])) +// >>> -x1 +// array([-1., 1.]) // -//go:linkname Frombuffer py.frombuffer -func Frombuffer(buffer *py.Object, dtype *py.Object, count *py.Object, offset *py.Object) *py.Object -// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Negative py.negative +func Negative(x *py.Object, out *py.Object) *py.Object +// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Element-wise maximum of array elements. +// Shift the bits of an integer to the right. // -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. +// Bits are shifted to the right `x2`. Because the internal +// representation of numbers is in binary format, this operation is +// equivalent to dividing `x1` by ``2**x2``. // // Parameters // ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. +// x1 : array_like, int +// Input values. +// x2 : array_like, int +// Number of bits to remove at the right of `x1`. // If ``x1.shape != x2.shape``, they must be broadcastable to a common // shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional @@ -5585,2443 +4472,2331 @@ func Frombuffer(buffer *py.Object, dtype *py.Object, count *py.Object, offset *p // // Returns // ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. +// out : ndarray, int +// Return `x1` with bits shifted `x2` times to the right. // This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// fmin, amin, nanmin -// -// Notes -// ----- -// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when -// neither x1 nor x2 are nans, but it is faster and does proper -// broadcasting. +// left_shift : Shift the bits of an integer to the left. +// binary_repr : Return the binary representation of the input number +// as a string. // // Examples // -------- -// >>> import numpy as np -// >>> np.maximum([2, 3, 4], [1, 5, 2]) -// array([2, 5, 4]) -// -// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) +// >>> np.binary_repr(10) +// '1010' +// >>> np.right_shift(10, 1) +// 5 +// >>> np.binary_repr(5) +// '101' // -// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.maximum(np.inf, 1) -// inf +// >>> np.right_shift(10, [1,2,3]) +// array([5, 2, 1]) // -//go:linkname Maximum py.maximum -func Maximum(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on +// ndarrays. // -// may_share_memory(a, b, /, max_work=None) +// >>> x1 = 10 +// >>> x2 = np.array([1,2,3]) +// >>> x1 >> x2 +// array([5, 2, 1]) // -// Determine if two arrays might share memory +//go:linkname RightShift py.right_shift +func RightShift(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// A return of True does not necessarily mean that the two arrays -// share any element. It just means that they *might*. +// Set how floating-point errors are handled. // -// Only the memory bounds of a and b are checked by default. +// Note that operations on integer scalar types (such as `int16`) are +// handled like floating point, and are affected by these settings. // // Parameters // ---------- -// a, b : ndarray -// Input arrays -// max_work : int, optional -// Effort to spend on solving the overlap problem. See -// `shares_memory` for details. Default for ``may_share_memory`` -// is to do a bounds check. +// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Set treatment for all types of floating-point errors at once: +// +// - ignore: Take no action when the exception occurs. +// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). +// - raise: Raise a `FloatingPointError`. +// - call: Call a function specified using the `seterrcall` function. +// - print: Print a warning directly to ``stdout``. +// - log: Record error in a Log object specified by `seterrcall`. +// +// The default is not to change the current behavior. +// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for division by zero. +// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point overflow. +// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for floating-point underflow. +// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional +// Treatment for invalid floating-point operation. // // Returns // ------- -// out : bool +// old_settings : dict +// Dictionary containing the old settings. // -// See Also +// See also // -------- -// shares_memory +// seterrcall : Set a callback function for the 'call' mode. +// geterr, geterrcall, errstate +// +// Notes +// ----- +// The floating-point exceptions are defined in the IEEE 754 standard [1]_: +// +// - Division by zero: infinite result obtained from finite numbers. +// - Overflow: result too large to be expressed. +// - Underflow: result so close to zero that some precision +// was lost. +// - Invalid operation: result is not an expressible number, typically +// indicates that a NaN was produced. +// +// .. [1] https://en.wikipedia.org/wiki/IEEE_754 // // Examples // -------- -// >>> import numpy as np -// >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9])) -// False -// >>> x = np.zeros([3, 4]) -// >>> np.may_share_memory(x[:,0], x[:,1]) -// True +// >>> old_settings = np.seterr(all='ignore') #seterr to known value +// >>> np.seterr(over='raise') +// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} +// >>> np.seterr(**old_settings) # reset to default +// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} // +// >>> np.int16(32000) * np.int16(3) +// 30464 +// >>> old_settings = np.seterr(all='warn', over='raise') +// >>> np.int16(32000) * np.int16(3) +// Traceback (most recent call last): +// File "", line 1, in +// FloatingPointError: overflow encountered in scalar multiply // +// >>> old_settings = np.seterr(all='print') +// >>> np.geterr() +// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} +// >>> np.int16(32000) * np.int16(3) +// 30464 // -//go:linkname MayShareMemory py.may_share_memory -func MayShareMemory(a *py.Object, b *py.Object, maxWork *py.Object) *py.Object // -// Broadcast any number of arrays against each other. +// +//go:linkname Seterr py.seterr +func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object +// +// Assemble an nd-array from nested lists of blocks. +// +// Blocks in the innermost lists are concatenated (see `concatenate`) along +// the last dimension (-1), then these are concatenated along the +// second-last dimension (-2), and so on until the outermost list is reached. +// +// Blocks can be of any dimension, but will not be broadcasted using the normal +// rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim`` +// the same for all blocks. This is primarily useful for working with scalars, +// and means that code like ``np.block([v, 1])`` is valid, where +// ``v.ndim == 1``. +// +// When the nested list is two levels deep, this allows block matrices to be +// constructed from their components. +// +// .. versionadded:: 1.13.0 // // Parameters // ---------- -// *args : array_likes -// The arrays to broadcast. +// arrays : nested list of array_like or scalars (but not tuples) +// If passed a single ndarray or scalar (a nested list of depth 0), this +// is returned unmodified (and not copied). // -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise -// the returned arrays will be forced to be a base-class array (default). +// Elements shapes must match along the appropriate axes (without +// broadcasting), but leading 1s will be prepended to the shape as +// necessary to make the dimensions match. // // Returns // ------- -// broadcasted : tuple of arrays -// These arrays are views on the original arrays. They are typically -// not contiguous. Furthermore, more than one element of a -// broadcasted array may refer to a single memory location. If you need -// to write to the arrays, make copies first. While you can set the -// ``writable`` flag True, writing to a single output value may end up -// changing more than one location in the output array. +// block_array : ndarray +// The array assembled from the given blocks. // -// .. deprecated:: 1.17 -// The output is currently marked so that if written to, a deprecation -// warning will be emitted. A future version will set the -// ``writable`` flag False so writing to it will raise an error. +// The dimensionality of the output is equal to the greatest of: +// * the dimensionality of all the inputs +// * the depth to which the input list is nested +// +// Raises +// ------ +// ValueError +// * If list depths are mismatched - for instance, ``[[a, b], c]`` is +// illegal, and should be spelt ``[[a, b], [c]]`` +// * If lists are empty - for instance, ``[[a, b], []]`` // // See Also // -------- -// broadcast -// broadcast_to -// broadcast_shapes +// concatenate : Join a sequence of arrays along an existing axis. +// stack : Join a sequence of arrays along a new axis. +// vstack : Stack arrays in sequence vertically (row wise). +// hstack : Stack arrays in sequence horizontally (column wise). +// dstack : Stack arrays in sequence depth wise (along third axis). +// column_stack : Stack 1-D arrays as columns into a 2-D array. +// vsplit : Split an array into multiple sub-arrays vertically (row-wise). // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([[1,2,3]]) -// >>> y = np.array([[4],[5]]) -// >>> np.broadcast_arrays(x, y) -// (array([[1, 2, 3], -// [1, 2, 3]]), -// array([[4, 4, 4], -// [5, 5, 5]])) +// Notes +// ----- // -// Here is a useful idiom for getting contiguous copies instead of -// non-contiguous views. +// When called with only scalars, ``np.block`` is equivalent to an ndarray +// call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to +// ``np.array([[1, 2], [3, 4]])``. // -// >>> [np.array(a) for a in np.broadcast_arrays(x, y)] -// [array([[1, 2, 3], -// [1, 2, 3]]), -// array([[4, 4, 4], -// [5, 5, 5]])] +// This function does not enforce that the blocks lie on a fixed grid. +// ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form:: // +// AAAbb +// AAAbb +// cccDD // +// But is also allowed to produce, for some ``a, b, c, d``:: // -//go:linkname BroadcastArrays py.broadcast_arrays -func BroadcastArrays(__llgo_va_list ...interface{}) *py.Object +// AAAbb +// AAAbb +// cDDDD // -// Returns True if two arrays are element-wise equal within a tolerance. +// Since concatenation happens along the last axis first, `block` is _not_ +// capable of producing the following directly:: // -// The tolerance values are positive, typically very small numbers. The -// relative difference (`rtol` * abs(`b`)) and the absolute difference -// `atol` are added together to compare against the absolute difference -// between `a` and `b`. +// AAAbb +// cccbb +// cccDD // -// .. warning:: The default `atol` is not appropriate for comparing numbers -// with magnitudes much smaller than one (see Notes). +// Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is +// equivalent to ``np.block([[A, B, ...], [p, q, ...]])``. // -// NaNs are treated as equal if they are in the same place and if -// ``equal_nan=True``. Infs are treated as equal if they are in the same -// place and of the same sign in both arrays. +// Examples +// -------- +// The most common use of this function is to build a block matrix // -// Parameters -// ---------- -// a, b : array_like -// Input arrays to compare. -// rtol : array_like -// The relative tolerance parameter (see Notes). -// atol : array_like -// The absolute tolerance parameter (see Notes). -// equal_nan : bool -// Whether to compare NaN's as equal. If True, NaN's in `a` will be -// considered equal to NaN's in `b` in the output array. +// >>> A = np.eye(2) * 2 +// >>> B = np.eye(3) * 3 +// >>> np.block([ +// ... [A, np.zeros((2, 3))], +// ... [np.ones((3, 2)), B ] +// ... ]) +// array([[2., 0., 0., 0., 0.], +// [0., 2., 0., 0., 0.], +// [1., 1., 3., 0., 0.], +// [1., 1., 0., 3., 0.], +// [1., 1., 0., 0., 3.]]) // -// Returns -// ------- -// allclose : bool -// Returns True if the two arrays are equal within the given -// tolerance; False otherwise. +// With a list of depth 1, `block` can be used as `hstack` // -// See Also -// -------- -// isclose, all, any, equal +// >>> np.block([1, 2, 3]) # hstack([1, 2, 3]) +// array([1, 2, 3]) // -// Notes -// ----- -// If the following equation is element-wise True, then allclose returns -// True.:: +// >>> a = np.array([1, 2, 3]) +// >>> b = np.array([4, 5, 6]) +// >>> np.block([a, b, 10]) # hstack([a, b, 10]) +// array([ 1, 2, 3, 4, 5, 6, 10]) // -// absolute(a - b) <= (atol + rtol * absolute(b)) +// >>> A = np.ones((2, 2), int) +// >>> B = 2 * A +// >>> np.block([A, B]) # hstack([A, B]) +// array([[1, 1, 2, 2], +// [1, 1, 2, 2]]) // -// The above equation is not symmetric in `a` and `b`, so that -// ``allclose(a, b)`` might be different from ``allclose(b, a)`` in -// some rare cases. +// With a list of depth 2, `block` can be used in place of `vstack`: // -// The default value of `atol` is not appropriate when the reference value -// `b` has magnitude smaller than one. For example, it is unlikely that -// ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet -// ``allclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure -// to select `atol` for the use case at hand, especially for defining the -// threshold below which a non-zero value in `a` will be considered "close" -// to a very small or zero value in `b`. +// >>> a = np.array([1, 2, 3]) +// >>> b = np.array([4, 5, 6]) +// >>> np.block([[a], [b]]) # vstack([a, b]) +// array([[1, 2, 3], +// [4, 5, 6]]) // -// The comparison of `a` and `b` uses standard broadcasting, which -// means that `a` and `b` need not have the same shape in order for -// ``allclose(a, b)`` to evaluate to True. The same is true for -// `equal` but not `array_equal`. +// >>> A = np.ones((2, 2), int) +// >>> B = 2 * A +// >>> np.block([[A], [B]]) # vstack([A, B]) +// array([[1, 1], +// [1, 1], +// [2, 2], +// [2, 2]]) // -// `allclose` is not defined for non-numeric data types. -// `bool` is considered a numeric data-type for this purpose. +// It can also be used in places of `atleast_1d` and `atleast_2d` // -// Examples -// -------- -// >>> import numpy as np -// >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8]) -// False +// >>> a = np.array(0) +// >>> b = np.array([1]) +// >>> np.block([a]) # atleast_1d(a) +// array([0]) +// >>> np.block([b]) # atleast_1d(b) +// array([1]) // -// >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9]) -// True +// >>> np.block([[a]]) # atleast_2d(a) +// array([[0]]) +// >>> np.block([[b]]) # atleast_2d(b) +// array([[1]]) // -// >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9]) -// False // -// >>> np.allclose([1.0, np.nan], [1.0, np.nan]) -// False // -// >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) -// True // +//go:linkname Block py.block +func Block(arrays *py.Object) *py.Object // +// One-dimensional linear interpolation for monotonically increasing sample points. // +// Returns the one-dimensional piecewise linear interpolant to a function +// with given discrete data points (`xp`, `fp`), evaluated at `x`. // -//go:linkname Allclose py.allclose -func Allclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object -// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Parameters +// ---------- +// x : array_like +// The x-coordinates at which to evaluate the interpolated values. // -// Inverse hyperbolic tangent element-wise. +// xp : 1-D sequence of floats +// The x-coordinates of the data points, must be increasing if argument +// `period` is not specified. Otherwise, `xp` is internally sorted after +// normalizing the periodic boundaries with ``xp = xp % period``. // -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// fp : 1-D sequence of float or complex +// The y-coordinates of the data points, same length as `xp`. // -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. +// left : optional float or complex corresponding to fp +// Value to return for `x < xp[0]`, default is `fp[0]`. // -// See Also -// -------- -// emath.arctanh +// right : optional float or complex corresponding to fp +// Value to return for `x > xp[-1]`, default is `fp[-1]`. // -// Notes -// ----- -// `arctanh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``tanh(z) = x``. The convention is to return -// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. +// period : None or float, optional +// A period for the x-coordinates. This parameter allows the proper +// interpolation of angular x-coordinates. Parameters `left` and `right` +// are ignored if `period` is specified. // -// For real-valued input data types, `arctanh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. +// .. versionadded:: 1.10.0 // -// For complex-valued input, `arctanh` is a complex analytical function -// that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from -// above on the former and from below on the latter. +// Returns +// ------- +// y : float or complex (corresponding to fp) or ndarray +// The interpolated values, same shape as `x`. // -// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. +// Raises +// ------ +// ValueError +// If `xp` and `fp` have different length +// If `xp` or `fp` are not 1-D sequences +// If `period == 0` // -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arctanh +// See Also +// -------- +// scipy.interpolate // -// Examples -// -------- -// >>> import numpy as np -// >>> np.arctanh([0, -0.5]) -// array([ 0. , -0.54930614]) +// Warnings +// -------- +// The x-coordinate sequence is expected to be increasing, but this is not +// explicitly enforced. However, if the sequence `xp` is non-increasing, +// interpolation results are meaningless. // -//go:linkname Atanh py.atanh -func Atanh(__llgo_va_list ...interface{}) *py.Object -// empty(shape, dtype=float, order='C', *, device=None, like=None) +// Note that, since NaN is unsortable, `xp` also cannot contain NaNs. // -// Return a new array of given shape and type, without initializing entries. +// A simple check for `xp` being strictly increasing is:: // -// Parameters -// ---------- -// shape : int or tuple of int -// Shape of the empty array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// Desired output data-type for the array, e.g, `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: 'C' -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// device : str, optional -// The device on which to place the created array. Default: ``None``. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. +// np.all(np.diff(xp) > 0) // -// .. versionadded:: 2.0.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// Examples +// -------- +// >>> xp = [1, 2, 3] +// >>> fp = [3, 2, 0] +// >>> np.interp(2.5, xp, fp) +// 1.0 +// >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp) +// array([3. , 3. , 2.5 , 0.56, 0. ]) +// >>> UNDEF = -99.0 +// >>> np.interp(3.14, xp, fp, right=UNDEF) +// -99.0 // -// .. versionadded:: 1.20.0 +// Plot an interpolant to the sine function: // -// Returns -// ------- -// out : ndarray -// Array of uninitialized (arbitrary) data of the given shape, dtype, and -// order. Object arrays will be initialized to None. +// >>> x = np.linspace(0, 2*np.pi, 10) +// >>> y = np.sin(x) +// >>> xvals = np.linspace(0, 2*np.pi, 50) +// >>> yinterp = np.interp(xvals, x, y) +// >>> import matplotlib.pyplot as plt +// >>> plt.plot(x, y, 'o') +// [] +// >>> plt.plot(xvals, yinterp, '-x') +// [] +// >>> plt.show() // -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. +// Interpolation with periodic x-coordinates: // -// Notes -// ----- -// Unlike other array creation functions (e.g. `zeros`, `ones`, `full`), -// `empty` does not initialize the values of the array, and may therefore be -// marginally faster. However, the values stored in the newly allocated array -// are arbitrary. For reproducible behavior, be sure to set each element of -// the array before reading. +// >>> x = [-180, -170, -185, 185, -10, -5, 0, 365] +// >>> xp = [190, -190, 350, -350] +// >>> fp = [5, 10, 3, 4] +// >>> np.interp(x, xp, fp, period=360) +// array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75]) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.empty([2, 2]) -// array([[ -9.74499359e+001, 6.69583040e-309], -// [ 2.13182611e-314, 3.06959433e-309]]) #uninitialized +// Complex interpolation: // -// >>> np.empty([2, 2], dtype=int) -// array([[-1073741821, -1067949133], -// [ 496041986, 19249760]]) #uninitialized +// >>> x = [1.5, 4.0] +// >>> xp = [2,3,5] +// >>> fp = [1.0j, 0, 2+3j] +// >>> np.interp(x, xp, fp) +// array([0.+1.j , 1.+1.5j]) // -//go:linkname Empty py.empty -func Empty(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object -// zeros(shape, dtype=float, order='C', *, like=None) // -// Return a new array of given shape and type, filled with zeros. +// +//go:linkname Interp py.interp +func Interp(x *py.Object, xp *py.Object, fp *py.Object, left *py.Object, right *py.Object, period *py.Object) *py.Object +// +// Put values into the destination array by matching 1d index and data slices. +// +// This iterates over matching 1d slices oriented along the specified axis in +// the index and data arrays, and uses the former to place values into the +// latter. These slices can be different lengths. +// +// Functions returning an index along an axis, like `argsort` and +// `argpartition`, produce suitable indices for this function. +// +// .. versionadded:: 1.15.0 // // Parameters // ---------- -// shape : int or tuple of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// The desired data-type for the array, e.g., `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: 'C' -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// arr : ndarray (Ni..., M, Nk...) +// Destination array. +// indices : ndarray (Ni..., J, Nk...) +// Indices to change along each 1d slice of `arr`. This must match the +// dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast +// against `arr`. +// values : array_like (Ni..., J, Nk...) +// values to insert at those indices. Its shape and dimension are +// broadcast to match that of `indices`. +// axis : int +// The axis to take 1d slices along. If axis is None, the destination +// array is treated as if a flattened 1d view had been created of it. // -// .. versionadded:: 1.20.0 +// Notes +// ----- +// This is equivalent to (but faster than) the following use of `ndindex` and +// `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: // -// Returns -// ------- -// out : ndarray -// Array of zeros with the given shape, dtype, and order. +// Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] +// J = indices.shape[axis] # Need not equal M +// +// for ii in ndindex(Ni): +// for kk in ndindex(Nk): +// a_1d = a [ii + s_[:,] + kk] +// indices_1d = indices[ii + s_[:,] + kk] +// values_1d = values [ii + s_[:,] + kk] +// for j in range(J): +// a_1d[indices_1d[j]] = values_1d[j] +// +// Equivalently, eliminating the inner loop, the last two lines would be:: +// +// a_1d[indices_1d] = values_1d // // See Also // -------- -// zeros_like : Return an array of zeros with shape and type of input. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// full : Return a new array of given shape filled with value. +// take_along_axis : +// Take values from the input array by matching 1d index and data slices // // Examples // -------- -// >>> import numpy as np -// >>> np.zeros(5) -// array([ 0., 0., 0., 0., 0.]) // -// >>> np.zeros((5,), dtype=int) -// array([0, 0, 0, 0, 0]) +// For this sample array // -// >>> np.zeros((2, 1)) -// array([[ 0.], -// [ 0.]]) +// >>> a = np.array([[10, 30, 20], [60, 40, 50]]) // -// >>> s = (2,2) -// >>> np.zeros(s) -// array([[ 0., 0.], -// [ 0., 0.]]) +// We can replace the maximum values with: // -// >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype -// array([(0, 0), (0, 0)], -// dtype=[('x', '>> ai = np.argmax(a, axis=1, keepdims=True) +// >>> ai +// array([[1], +// [0]]) +// >>> np.put_along_axis(a, ai, 99, axis=1) +// >>> a +// array([[10, 99, 20], +// [99, 40, 50]]) // -// Find the sum of two polynomials. // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. // -// Returns the polynomial resulting from the sum of two input polynomials. -// Each input must be either a poly1d object or a 1D sequence of polynomial -// coefficients, from highest to lowest degree. +//go:linkname PutAlongAxis py.put_along_axis +func PutAlongAxis(arr *py.Object, indices *py.Object, values *py.Object, axis *py.Object) *py.Object // -// Parameters -// ---------- -// a1, a2 : array_like or poly1d object -// Input polynomials. +// Return the minimum of an array or minimum along an axis. // -// Returns -// ------- -// out : ndarray or poly1d object -// The sum of the inputs. If either input is a poly1d object, then the -// output is also a poly1d object. Otherwise, it is a 1D array of -// polynomial coefficients from highest to lowest degree. +// `amin` is an alias of `~numpy.min`. // // See Also // -------- -// poly1d : A one-dimensional polynomial class. -// poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval +// min : alias of this function +// ndarray.min : equivalent method // -// Examples -// -------- -// >>> import numpy as np -// >>> np.polyadd([1, 2], [9, 5, 4]) -// array([9, 6, 6]) // -// Using poly1d objects: +//go:linkname Amin py.amin +func Amin(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object // -// >>> p1 = np.poly1d([1, 2]) -// >>> p2 = np.poly1d([9, 5, 4]) -// >>> print(p1) -// 1 x + 2 -// >>> print(p2) -// 2 -// 9 x + 5 x + 4 -// >>> print(np.polyadd(p1, p2)) -// 2 -// 9 x + 6 x + 6 +// Return the maximum of an array or maximum along an axis. +// +// Parameters +// ---------- +// a : array_like +// Input data. +// axis : None or int or tuple of ints, optional +// Axis or axes along which to operate. By default, 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 : ndarray, optional +// Alternative output array in which to place the result. Must +// be of the same shape and buffer length as the expected output. +// See :ref:`ufuncs-output-type` for more details. // -//go:linkname Polyadd py.polyadd -func Polyadd(__llgo_va_list ...interface{}) *py.Object +// 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 input array. // -// Return the indices to access (n, n) arrays, given a masking function. +// If the default value is passed, then `keepdims` will not be +// passed through to the ``max`` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. // -// Assume `mask_func` is a function that, for a square array a of size -// ``(n, n)`` with a possible offset argument `k`, when called as -// ``mask_func(a, k)`` returns a new array with zeros in certain locations -// (functions like `triu` or `tril` do precisely this). Then this function -// returns the indices where the non-zero values would be located. +// initial : scalar, optional +// The minimum value of an output element. Must be present to allow +// computation on empty slice. See `~numpy.ufunc.reduce` for details. // -// Parameters -// ---------- -// n : int -// The returned indices will be valid to access arrays of shape (n, n). -// mask_func : callable -// A function whose call signature is similar to that of `triu`, `tril`. -// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. -// `k` is an optional argument to the function. -// k : scalar -// An optional argument which is passed through to `mask_func`. Functions -// like `triu`, `tril` take a second argument that is interpreted as an -// offset. +// .. versionadded:: 1.15.0 +// +// where : array_like of bool, optional +// Elements to compare for the maximum. See `~numpy.ufunc.reduce` +// for details. +// +// .. versionadded:: 1.17.0 // // Returns // ------- -// indices : tuple of arrays. -// The `n` arrays of indices corresponding to the locations where -// ``mask_func(np.ones((n, n)), k)`` is True. +// max : ndarray or scalar +// Maximum of `a`. If `axis` is None, the result is a scalar value. +// 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 // -------- -// triu, tril, triu_indices, tril_indices -// -// Examples -// -------- -// >>> import numpy as np +// amin : +// The minimum value of an array along a given axis, propagating any NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignoring any NaNs. +// maximum : +// Element-wise maximum of two arrays, propagating any NaNs. +// fmax : +// Element-wise maximum of two arrays, ignoring any NaNs. +// argmax : +// Return the indices of the maximum values. // -// These are the indices that would allow you to access the upper triangular -// part of any 3x3 array: +// nanmin, minimum, fmin // -// >>> iu = np.mask_indices(3, np.triu) +// Notes +// ----- +// NaN values are propagated, that is if at least one item is NaN, the +// corresponding max value will be NaN as well. To ignore NaN values +// (MATLAB behavior), please use nanmax. // -// For example, if `a` is a 3x3 array: +// Don't use `~numpy.max` for element-wise comparison of 2 arrays; when +// ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than +// ``max(a, axis=0)``. // -// >>> a = np.arange(9).reshape(3, 3) +// Examples +// -------- +// >>> a = np.arange(4).reshape((2,2)) // >>> a -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// >>> a[iu] -// array([0, 1, 2, 4, 5, 8]) -// -// An offset can be passed also to the masking function. This gets us the -// indices starting on the first diagonal right of the main one: +// array([[0, 1], +// [2, 3]]) +// >>> np.max(a) # Maximum of the flattened array +// 3 +// >>> np.max(a, axis=0) # Maxima along the first axis +// array([2, 3]) +// >>> np.max(a, axis=1) # Maxima along the second axis +// array([1, 3]) +// >>> np.max(a, where=[False, True], initial=-1, axis=0) +// array([-1, 3]) +// >>> b = np.arange(5, dtype=float) +// >>> b[2] = np.NaN +// >>> np.max(b) +// nan +// >>> np.max(b, where=~np.isnan(b), initial=-1) +// 4.0 +// >>> np.nanmax(b) +// 4.0 // -// >>> iu1 = np.mask_indices(3, np.triu, 1) +// You can use an initial value to compute the maximum of an empty slice, or +// to initialize it to a different value: // -// with which we now extract only three elements: +// >>> np.max([[-50], [10]], axis=-1, initial=0) +// array([ 0, 10]) // -// >>> a[iu1] -// array([1, 2, 5]) +// Notice that the initial value is used as one of the elements for which the +// maximum is determined, unlike for the default argument Python's max +// function, which is only used for empty iterables. // +// >>> np.max([5], initial=6) +// 6 +// >>> max([5], default=6) +// 5 // // -//go:linkname MaskIndices py.mask_indices -func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object +//go:linkname Max py.max +func Max(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object // -// Return the current callback function used on floating-point errors. +// Test element-wise for negative infinity, return result as bool array. // -// When the error handling for a floating-point error (one of "divide", -// "over", "under", or "invalid") is set to 'call' or 'log', the function -// that is called or the log instance that is written to is returned by -// `geterrcall`. This function or log instance has been set with -// `seterrcall`. +// Parameters +// ---------- +// x : array_like +// The input array. +// out : array_like, optional +// A location into which the result is stored. If provided, it must have a +// shape that the input broadcasts to. If not provided or None, a +// freshly-allocated boolean array is returned. // // Returns // ------- -// errobj : callable, log instance or None -// The current error handler. If no handler was set through `seterrcall`, -// ``None`` is returned. +// out : ndarray +// A boolean array with the same dimensions as the input. +// If second argument is not supplied then a numpy boolean array is +// returned with values True where the corresponding element of the +// input is negative infinity and values False where the element of +// the input is not negative infinity. +// +// If a second argument is supplied the result is stored there. If the +// type of that array is a numeric type the result is represented as +// zeros and ones, if the type is boolean then as False and True. The +// return value `out` is then a reference to that array. // // See Also // -------- -// seterrcall, seterr, geterr +// isinf, isposinf, isnan, isfinite // // Notes // ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). +// +// Errors result if the second argument is also supplied when x is a scalar +// input, if first and second arguments have different shapes, or if the +// first argument has complex values. // // Examples // -------- -// >>> import numpy as np -// >>> np.geterrcall() # we did not yet set a handler, returns None -// -// >>> orig_settings = np.seterr(all='call') -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// >>> old_handler = np.seterrcall(err_handler) -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> cur_handler = np.geterrcall() -// >>> cur_handler is err_handler +// >>> np.isneginf(np.NINF) // True -// >>> old_settings = np.seterr(**orig_settings) # restore original -// >>> old_handler = np.seterrcall(None) # restore original +// >>> np.isneginf(np.inf) +// False +// >>> np.isneginf(np.PINF) +// False +// >>> np.isneginf([-np.inf, 0., np.inf]) +// array([ True, False, False]) // +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isneginf(x, y) +// array([1, 0, 0]) +// >>> y +// array([1, 0, 0]) // // -//go:linkname Geterrcall py.geterrcall -func Geterrcall() *py.Object -// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Test element-wise for positive or negative infinity. +//go:linkname Isneginf py.isneginf +func Isneginf(x *py.Object, out *py.Object) *py.Object // -// Returns a boolean array of the same shape as `x`, True where ``x == -// +/-inf``, otherwise False. -// -// Parameters -// ---------- -// x : array_like -// Input values -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool (scalar) or boolean ndarray -// True where ``x`` is positive or negative infinity, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isneginf, isposinf, isnan, isfinite -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). -// -// Errors result if the second argument is supplied when the first -// argument is a scalar, or if the first and second arguments have -// different shapes. +// Returns the quotient and remainder of polynomial division. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.isinf(np.inf) -// True -// >>> np.isinf(np.nan) -// False -// >>> np.isinf(-np.inf) -// True -// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) -// array([ True, True, False, False]) +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. // -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isinf(x, y) -// array([1, 0, 1]) -// >>> y -// array([1, 0, 1]) +// The input arrays are the coefficients (including any coefficients +// equal to zero) of the "numerator" (dividend) and "denominator" +// (divisor) polynomials, respectively. // -//go:linkname Isinf py.isinf -func Isinf(x *py.Object, out *py.Object) *py.Object -//go:linkname Remainder py.remainder -func Remainder(__llgo_va_list ...interface{}) *py.Object -// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Parameters +// ---------- +// u : array_like or poly1d +// Dividend polynomial's coefficients. // -// Returns an element-wise indication of the sign of a number. +// v : array_like or poly1d +// Divisor polynomial's coefficients. // -// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan -// is returned for nan inputs. +// Returns +// ------- +// q : ndarray +// Coefficients, including those equal to zero, of the quotient. +// r : ndarray +// Coefficients, including those equal to zero, of the remainder. // -// For complex inputs, the `sign` function returns ``x / abs(x)``, the -// generalization of the above (and ``0 if x==0``). +// See Also +// -------- +// poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub +// polyval // -// .. versionchanged:: 2.0.0 -// Definition of complex sign changed to follow the Array API standard. +// Notes +// ----- +// Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need +// not equal `v.ndim`. In other words, all four possible combinations - +// ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``, +// ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work. // -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Examples +// -------- +// .. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25 // -// Returns -// ------- -// y : ndarray -// The sign of `x`. -// This is a scalar if `x` is a scalar. +// >>> x = np.array([3.0, 5.0, 2.0]) +// >>> y = np.array([2.0, 1.0]) +// >>> np.polydiv(x, y) +// (array([1.5 , 1.75]), array([0.25])) // -// Notes -// ----- -// There is more than one definition of sign in common use for complex -// numbers. The definition used here, :math:`x/|x|`, is the more common -// and useful one, but is different from the one used in numpy prior to -// version 2.0, :math:`x/\sqrt{x*x}`, which is equivalent to -// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.sign([-5., 4.5]) -// array([-1., 1.]) -// >>> np.sign(0) -// 0 -// >>> np.sign([3-4j, 8j]) -// array([0.6-0.8j, 0. +1.j ]) // -//go:linkname Sign py.sign -func Sign(x *py.Object, out *py.Object) *py.Object +//go:linkname Polydiv py.polydiv +func Polydiv(u *py.Object, v *py.Object) *py.Object // -// Return the cross product of two (arrays of) vectors. +// Determine if a class is a subclass of a second class. // -// The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular -// to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors -// are defined by the last axis of `a` and `b` by default, and these axes -// can have dimensions 2 or 3. Where the dimension of either `a` or `b` is -// 2, the third component of the input vector is assumed to be zero and the -// cross product calculated accordingly. In cases where both input vectors -// have dimension 2, the z-component of the cross product is returned. +// `issubclass_` is equivalent to the Python built-in ``issubclass``, +// except that it returns False instead of raising a TypeError if one +// of the arguments is not a class. // // Parameters // ---------- -// a : array_like -// Components of the first vector(s). -// b : array_like -// Components of the second vector(s). -// axisa : int, optional -// Axis of `a` that defines the vector(s). By default, the last axis. -// axisb : int, optional -// Axis of `b` that defines the vector(s). By default, the last axis. -// axisc : int, optional -// Axis of `c` containing the cross product vector(s). Ignored if -// both input vectors have dimension 2, as the return is scalar. -// By default, the last axis. -// axis : int, optional -// If defined, the axis of `a`, `b` and `c` that defines the vector(s) -// and cross product(s). Overrides `axisa`, `axisb` and `axisc`. +// arg1 : class +// Input class. True is returned if `arg1` is a subclass of `arg2`. +// arg2 : class or tuple of classes. +// Input class. If a tuple of classes, True is returned if `arg1` is a +// subclass of any of the tuple elements. // // Returns // ------- -// c : ndarray -// Vector cross product(s). -// -// Raises -// ------ -// ValueError -// When the dimension of the vector(s) in `a` and/or `b` does not -// equal 2 or 3. +// out : bool +// Whether `arg1` is a subclass of `arg2` or not. // // See Also // -------- -// inner : Inner product -// outer : Outer product. -// linalg.cross : An Array API compatible variation of ``np.cross``, -// which accepts (arrays of) 3-element vectors only. -// ix_ : Construct index arrays. -// -// Notes -// ----- -// Supports full broadcasting of the inputs. -// -// Dimension-2 input arrays were deprecated in 2.0.0. If you do need this -// functionality, you can use:: -// -// def cross2d(x, y): -// return x[..., 0] * y[..., 1] - x[..., 1] * y[..., 0] +// issubsctype, issubdtype, issctype // // Examples // -------- -// Vector cross-product. -// -// >>> import numpy as np -// >>> x = [1, 2, 3] -// >>> y = [4, 5, 6] -// >>> np.cross(x, y) -// array([-3, 6, -3]) -// -// One vector with dimension 2. -// -// >>> x = [1, 2] -// >>> y = [4, 5, 6] -// >>> np.cross(x, y) -// array([12, -6, -3]) -// -// Equivalently: -// -// >>> x = [1, 2, 0] -// >>> y = [4, 5, 6] -// >>> np.cross(x, y) -// array([12, -6, -3]) +// >>> np.issubclass_(np.int32, int) +// False +// >>> np.issubclass_(np.int32, float) +// False +// >>> np.issubclass_(np.float64, float) +// True // -// Both vectors with dimension 2. // -// >>> x = [1,2] -// >>> y = [4,5] -// >>> np.cross(x, y) -// array(-3) // -// Multiple vector cross-products. Note that the direction of the cross -// product vector is defined by the *right-hand rule*. +//go:linkname Issubclass_ py.issubclass_ +func Issubclass_(arg1 *py.Object, arg2 *py.Object) *py.Object // -// >>> x = np.array([[1,2,3], [4,5,6]]) -// >>> y = np.array([[4,5,6], [1,2,3]]) -// >>> np.cross(x, y) -// array([[-3, 6, -3], -// [ 3, -6, 3]]) +// Determine if the first argument is a subclass of the second argument. // -// The orientation of `c` can be changed using the `axisc` keyword. +// Parameters +// ---------- +// arg1, arg2 : dtype or dtype specifier +// Data-types. // -// >>> np.cross(x, y, axisc=0) -// array([[-3, 3], -// [ 6, -6], -// [-3, 3]]) +// Returns +// ------- +// out : bool +// The result. // -// Change the vector definition of `x` and `y` using `axisa` and `axisb`. +// See Also +// -------- +// issctype, issubdtype, obj2sctype // -// >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]]) -// >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]]) -// >>> np.cross(x, y) -// array([[ -6, 12, -6], -// [ 0, 0, 0], -// [ 6, -12, 6]]) -// >>> np.cross(x, y, axisa=0, axisb=0) -// array([[-24, 48, -24], -// [-30, 60, -30], -// [-36, 72, -36]]) +// Examples +// -------- +// >>> np.issubsctype('S8', str) +// False +// >>> np.issubsctype(np.array([1]), int) +// True +// >>> np.issubsctype(np.array([1]), float) +// False // // // -//go:linkname Cross py.cross -func Cross(a *py.Object, b *py.Object, axisa *py.Object, axisb *py.Object, axisc *py.Object, axis *py.Object) *py.Object +//go:linkname Issubsctype py.issubsctype +func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object // -// Return the cumulative product of elements along a given axis. +// Return the maximum of an array or maximum along an axis, ignoring any +// NaNs. When all-NaN slices are encountered a ``RuntimeWarning`` is +// raised and NaN is returned for that slice. // // Parameters // ---------- // a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative product is computed. By default -// the input is flattened. -// dtype : dtype, optional -// Type of the returned array, as well as of the accumulator in which -// the elements are multiplied. If *dtype* is not specified, it -// defaults to the dtype of `a`, unless `a` has an integer dtype with -// a precision less than that of the default platform integer. In -// that case, the default platform integer is used instead. +// Array containing numbers whose maximum is desired. If `a` is not an +// array, a conversion is attempted. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the maximum is computed. The default is to compute +// the maximum of the flattened array. // out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type of the resulting values will be cast if necessary. +// Alternate output array in which to place the result. The default +// is ``None``; if provided, it must have the same shape as the +// expected output, but the type will be cast if necessary. See +// :ref:`ufuncs-output-type` for more details. +// +// .. versionadded:: 1.8.0 +// 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`. +// +// If the value is anything but the default, then +// `keepdims` will be passed through to the `max` method +// of sub-classes of `ndarray`. If the sub-classes methods +// does not implement `keepdims` any exceptions will be raised. +// +// .. versionadded:: 1.8.0 +// initial : scalar, optional +// The minimum value of an output element. Must be present to allow +// computation on empty slice. See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.22.0 +// where : array_like of bool, optional +// Elements to compare for the maximum. See `~numpy.ufunc.reduce` +// for details. +// +// .. versionadded:: 1.22.0 // // Returns // ------- -// cumprod : ndarray -// A new array holding the result is returned unless `out` is -// specified, in which case a reference to out is returned. +// nanmax : ndarray +// An array with the same shape as `a`, with the specified axis removed. +// If `a` is a 0-d array, or if axis is None, an ndarray scalar is +// returned. The same dtype as `a` is returned. // // See Also // -------- -// cumulative_prod : Array API compatible alternative for ``cumprod``. -// :ref:`ufuncs-output-type` +// nanmin : +// The minimum value of an array along a given axis, ignoring any NaNs. +// amax : +// The maximum value of an array along a given axis, propagating any NaNs. +// fmax : +// Element-wise maximum of two arrays, ignoring any NaNs. +// maximum : +// Element-wise maximum of two arrays, propagating any NaNs. +// isnan : +// Shows which elements are Not a Number (NaN). +// isfinite: +// Shows which elements are neither NaN nor infinity. +// +// amin, fmin, minimum // // Notes // ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). This means that Not a Number is not equivalent to infinity. +// Positive infinity is treated as a very large number and negative +// infinity is treated as a very small (i.e. negative) number. +// +// If the input has a integer type the function is equivalent to np.max. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([1,2,3]) -// >>> np.cumprod(a) # intermediate results 1, 1*2 -// ... # total product 1*2*3 = 6 -// array([1, 2, 6]) -// >>> a = np.array([[1, 2, 3], [4, 5, 6]]) -// >>> np.cumprod(a, dtype=float) # specify type of output -// array([ 1., 2., 6., 24., 120., 720.]) +// >>> a = np.array([[1, 2], [3, np.nan]]) +// >>> np.nanmax(a) +// 3.0 +// >>> np.nanmax(a, axis=0) +// array([3., 2.]) +// >>> np.nanmax(a, axis=1) +// array([2., 3.]) // -// The cumulative product for each column (i.e., over the rows) of `a`: +// When positive infinity and negative infinity are present: // -// >>> np.cumprod(a, axis=0) -// array([[ 1, 2, 3], -// [ 4, 10, 18]]) +// >>> np.nanmax([1, 2, np.nan, np.NINF]) +// 2.0 +// >>> np.nanmax([1, 2, np.nan, np.inf]) +// inf // -// The cumulative product for each row (i.e. over the columns) of `a`: // -// >>> np.cumprod(a,axis=1) -// array([[ 1, 2, 6], -// [ 4, 20, 120]]) // +//go:linkname Nanmax py.nanmax +func Nanmax(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object // +// Compute the arithmetic mean along the specified axis, ignoring NaNs. // -//go:linkname Cumprod py.cumprod -func Cumprod(__llgo_va_list ...interface{}) *py.Object -// nested_iters(op, axes, flags=None, op_flags=None, op_dtypes=None, order="K", casting="safe", buffersize=0) +// Returns the average of the array elements. The average is taken over +// the flattened array by default, otherwise over the specified axis. +// `float64` intermediate and return values are used for integer inputs. // -// Create nditers for use in nested loops +// For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised. // -// Create a tuple of `nditer` objects which iterate in nested loops over -// different axes of the op argument. The first iterator is used in the -// outermost loop, the last in the innermost loop. Advancing one will change -// the subsequent iterators to point at its new element. +// .. versionadded:: 1.8.0 // // Parameters // ---------- -// op : ndarray or sequence of array_like -// The array(s) to iterate over. +// a : array_like +// Array containing numbers whose mean is desired. If `a` is not an +// array, a conversion is attempted. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the means are computed. The default is to compute +// the mean of the flattened array. +// dtype : data-type, optional +// Type to use in computing the mean. For integer inputs, the default +// is `float64`; for inexact inputs, it is the same as the input +// dtype. +// out : ndarray, optional +// Alternate output array in which to place the result. The default +// is ``None``; if provided, it must have the same shape as the +// expected output, but the type will be cast if necessary. See +// :ref:`ufuncs-output-type` for more details. +// 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`. // -// axes : list of list of int -// Each item is used as an "op_axes" argument to an nditer +// If the value is anything but the default, then +// `keepdims` will be passed through to the `mean` or `sum` methods +// of sub-classes of `ndarray`. If the sub-classes methods +// does not implement `keepdims` any exceptions will be raised. +// where : array_like of bool, optional +// Elements to include in the mean. See `~numpy.ufunc.reduce` for details. // -// flags, op_flags, op_dtypes, order, casting, buffersize (optional) -// See `nditer` parameters of the same name +// .. versionadded:: 1.22.0 // // Returns // ------- -// iters : tuple of nditer -// An nditer for each item in `axes`, outermost first +// m : ndarray, see dtype parameter above +// If `out=None`, returns a new array containing the mean values, +// otherwise a reference to the output array is returned. Nan is +// returned for slices that contain only NaNs. // // See Also // -------- -// nditer +// average : Weighted average +// mean : Arithmetic mean taken while not ignoring NaNs +// var, nanvar +// +// Notes +// ----- +// The arithmetic mean is the sum of the non-NaN elements along the axis +// divided by the number of non-NaN elements. +// +// Note that for floating-point input, the mean is computed using the same +// precision the input has. Depending on the input data, this can cause +// the results to be inaccurate, especially for `float32`. Specifying a +// higher-precision accumulator using the `dtype` keyword can alleviate +// this issue. // // Examples // -------- +// >>> a = np.array([[1, np.nan], [3, 4]]) +// >>> np.nanmean(a) +// 2.6666666666666665 +// >>> np.nanmean(a, axis=0) +// array([2., 4.]) +// >>> np.nanmean(a, axis=1) +// array([1., 3.5]) # may vary // -// Basic usage. Note how y is the "flattened" version of -// [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified -// the first iter's axes as [1] // -// >>> import numpy as np -// >>> a = np.arange(12).reshape(2, 3, 2) -// >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=["multi_index"]) -// >>> for x in i: -// ... print(i.multi_index) -// ... for y in j: -// ... print('', j.multi_index, y) -// (0,) -// (0, 0) 0 -// (0, 1) 1 -// (1, 0) 6 -// (1, 1) 7 -// (1,) -// (0, 0) 2 -// (0, 1) 3 -// (1, 0) 8 -// (1, 1) 9 -// (2,) -// (0, 0) 4 -// (0, 1) 5 -// (1, 0) 10 -// (1, 1) 11 // -//go:linkname NestedIters py.nested_iters -func NestedIters(op *py.Object, axes *py.Object, flags *py.Object, opFlags *py.Object, opDtypes *py.Object, order *py.Object, casting *py.Object, buffersize *py.Object) *py.Object +//go:linkname Nanmean py.nanmean +func Nanmean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object) *py.Object // -// Stack arrays in sequence vertically (row wise). +// putmask(a, mask, values) // -// This is equivalent to concatenation along the first axis after 1-D arrays -// of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by -// `vsplit`. +// Changes elements of an array based on conditional and input values. // -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// and r/g/b channels (third axis). The functions `concatenate`, `stack` and -// `block` provide more general stacking and concatenation operations. +// Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``. +// +// If `values` is not the same size as `a` and `mask` then it will repeat. +// This gives behavior different from ``a[mask] = values``. // // 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. In the case of a single -// array_like input, it will be treated as a sequence of arrays; i.e., -// each element along the zeroth axis is treated as a separate array. -// -// 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 -// The array formed by stacking the given arrays, will be at least 2-D. +// a : ndarray +// Target array. +// mask : array_like +// Boolean mask array. It has to be the same shape as `a`. +// values : array_like +// Values to put into `a` where `mask` is True. If `values` is smaller +// than `a` it will be repeated. // // See Also // -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// hstack : Stack arrays in sequence horizontally (column wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// vsplit : Split an array into multiple sub-arrays vertically (row-wise). -// unstack : Split an array into a tuple of sub-arrays along an axis. +// place, put, take, copyto // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.vstack((a,b)) -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// >>> a = np.array([[1], [2], [3]]) -// >>> b = np.array([[4], [5], [6]]) -// >>> np.vstack((a,b)) -// array([[1], -// [2], -// [3], -// [4], -// [5], -// [6]]) -// +// >>> x = np.arange(6).reshape(2, 3) +// >>> np.putmask(x, x>2, x**2) +// >>> x +// array([[ 0, 1, 2], +// [ 9, 16, 25]]) // +// If `values` is smaller than `a` it is repeated: // -//go:linkname Vstack py.vstack -func Vstack(__llgo_va_list ...interface{}) *py.Object +// >>> x = np.arange(5) +// >>> np.putmask(x, x>1, [-33, -44]) +// >>> x +// array([ 0, 1, -33, -44, -33]) // -// einsum(subscripts, *operands, out=None, dtype=None, order='K', -// casting='safe', optimize=False) // -// Evaluates the Einstein summation convention on the operands. // -// Using the Einstein summation convention, many common multi-dimensional, -// linear algebraic array operations can be represented in a simple fashion. -// In *implicit* mode `einsum` computes these values. +//go:linkname Putmask py.putmask +func Putmask(a *py.Object, mask *py.Object, values *py.Object) *py.Object // -// In *explicit* mode, `einsum` provides further flexibility to compute -// other array operations that might not be considered classical Einstein -// summation operations, by disabling, or forcing summation over specified -// subscript labels. +// Returns the indices that would sort an array. // -// See the notes and examples for clarification. +// Perform an indirect sort along the given axis using the algorithm specified +// by the `kind` keyword. It returns an array of indices of the same shape as +// `a` that index data along the given axis in sorted order. // // Parameters // ---------- -// subscripts : str -// Specifies the subscripts for summation as comma separated list of -// subscript labels. An implicit (classical Einstein summation) -// calculation is performed unless the explicit indicator '->' is -// included as well as subscript labels of the precise output form. -// operands : list of array_like -// These are the arrays for the operation. -// out : ndarray, optional -// If provided, the calculation is done into this array. -// dtype : {data-type, None}, optional -// If provided, forces the calculation to use the data type specified. -// Note that you may have to also give a more liberal `casting` -// parameter to allow the conversions. Default is None. -// order : {'C', 'F', 'A', 'K'}, optional -// Controls the memory layout of the output. 'C' means it should -// be C contiguous. 'F' means it should be Fortran contiguous, -// 'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise. -// 'K' means it should be as close to the layout as the inputs as -// is possible, including arbitrarily permuted axes. -// Default is 'K'. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Setting this to -// 'unsafe' is not recommended, as it can adversely affect accumulations. -// -// * 'no' means the data types should not be cast at all. -// * 'equiv' means only byte-order changes are allowed. -// * 'safe' means only casts which can preserve values are allowed. -// * 'same_kind' means only safe casts or casts within a kind, -// like float64 to float32, are allowed. -// * 'unsafe' means any data conversions may be done. +// a : array_like +// Array to sort. +// axis : int or None, optional +// Axis along which to sort. The default is -1 (the last axis). If None, +// the flattened array is used. +// kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional +// Sorting algorithm. The default is 'quicksort'. Note that both 'stable' +// and 'mergesort' use timsort under the covers and, in general, the +// actual implementation will vary with data type. The 'mergesort' option +// is retained for backwards compatibility. // -// Default is 'safe'. -// optimize : {False, True, 'greedy', 'optimal'}, optional -// Controls if intermediate optimization should occur. No optimization -// will occur if False and True will default to the 'greedy' algorithm. -// Also accepts an explicit contraction list from the ``np.einsum_path`` -// function. See ``np.einsum_path`` for more details. Defaults to False. +// .. versionchanged:: 1.15.0. +// The 'stable' option was added. +// order : str or list of str, optional +// When `a` is an array with fields defined, this argument specifies +// which fields to compare first, second, etc. A single field can +// be specified as a string, and not all fields need be specified, +// but unspecified fields will still be used, in the order in which +// they come up in the dtype, to break ties. // // Returns // ------- -// output : ndarray -// The calculation based on the Einstein summation convention. +// index_array : ndarray, int +// Array of indices that sort `a` along the specified `axis`. +// If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`. +// More generally, ``np.take_along_axis(a, index_array, axis=axis)`` +// always yields the sorted `a`, irrespective of dimensionality. // // See Also // -------- -// einsum_path, dot, inner, outer, tensordot, linalg.multi_dot -// einsum: -// Similar verbose interface is provided by the -// `einops `_ package to cover -// additional operations: transpose, reshape/flatten, repeat/tile, -// squeeze/unsqueeze and reductions. -// The `opt_einsum `_ -// optimizes contraction order for einsum-like expressions -// in backend-agnostic manner. +// sort : Describes sorting algorithms used. +// lexsort : Indirect stable sort with multiple keys. +// ndarray.sort : Inplace sort. +// argpartition : Indirect partial sort. +// take_along_axis : Apply ``index_array`` from argsort +// to an array as if by calling sort. // // Notes // ----- -// The Einstein summation convention can be used to compute -// many multi-dimensional, linear algebraic array operations. `einsum` -// provides a succinct way of representing these. +// See `sort` for notes on the different sorting algorithms. // -// A non-exhaustive list of these operations, -// which can be computed by `einsum`, is shown below along with examples: +// As of NumPy 1.4.0 `argsort` works with real/complex arrays containing +// nan values. The enhanced sort order is documented in `sort`. // -// * Trace of an array, :py:func:`numpy.trace`. -// * Return a diagonal, :py:func:`numpy.diag`. -// * Array axis summations, :py:func:`numpy.sum`. -// * Transpositions and permutations, :py:func:`numpy.transpose`. -// * Matrix multiplication and dot product, :py:func:`numpy.matmul` -// :py:func:`numpy.dot`. -// * Vector inner and outer products, :py:func:`numpy.inner` -// :py:func:`numpy.outer`. -// * Broadcasting, element-wise and scalar multiplication, -// :py:func:`numpy.multiply`. -// * Tensor contractions, :py:func:`numpy.tensordot`. -// * Chained array operations, in efficient calculation order, -// :py:func:`numpy.einsum_path`. +// Examples +// -------- +// One dimensional array: // -// The subscripts string is a comma-separated list of subscript labels, -// where each label refers to a dimension of the corresponding operand. -// Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)`` -// is equivalent to :py:func:`np.inner(a,b) `. If a label -// appears only once, it is not summed, so ``np.einsum('i', a)`` -// produces a view of ``a`` with no changes. A further example -// ``np.einsum('ij,jk', a, b)`` describes traditional matrix multiplication -// and is equivalent to :py:func:`np.matmul(a,b) `. -// Repeated subscript labels in one operand take the diagonal. -// For example, ``np.einsum('ii', a)`` is equivalent to -// :py:func:`np.trace(a) `. +// >>> x = np.array([3, 1, 2]) +// >>> np.argsort(x) +// array([1, 2, 0]) // -// In *implicit mode*, the chosen subscripts are important -// since the axes of the output are reordered alphabetically. This -// means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while -// ``np.einsum('ji', a)`` takes its transpose. Additionally, -// ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while, -// ``np.einsum('ij,jh', a, b)`` returns the transpose of the -// multiplication since subscript 'h' precedes subscript 'i'. +// Two-dimensional array: // -// In *explicit mode* the output can be directly controlled by -// specifying output subscript labels. This requires the -// identifier '->' as well as the list of output subscript labels. -// This feature increases the flexibility of the function since -// summing can be disabled or forced when required. The call -// ``np.einsum('i->', a)`` is like :py:func:`np.sum(a) ` -// if ``a`` is a 1-D array, and ``np.einsum('ii->i', a)`` -// is like :py:func:`np.diag(a) ` if ``a`` is a square 2-D array. -// The difference is that `einsum` does not allow broadcasting by default. -// Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the -// order of the output subscript labels and therefore returns matrix -// multiplication, unlike the example above in implicit mode. +// >>> x = np.array([[0, 3], [2, 2]]) +// >>> x +// array([[0, 3], +// [2, 2]]) // -// To enable and control broadcasting, use an ellipsis. Default -// NumPy-style broadcasting is done by adding an ellipsis -// to the left of each term, like ``np.einsum('...ii->...i', a)``. -// ``np.einsum('...i->...', a)`` is like -// :py:func:`np.sum(a, axis=-1) ` for array ``a`` of any shape. -// To take the trace along the first and last axes, -// you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix -// product with the left-most indices instead of rightmost, one can do -// ``np.einsum('ij...,jk...->ik...', a, b)``. +// >>> ind = np.argsort(x, axis=0) # sorts along first axis (down) +// >>> ind +// array([[0, 1], +// [1, 0]]) +// >>> np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0) +// array([[0, 2], +// [2, 3]]) // -// When there is only one operand, no axes are summed, and no output -// parameter is provided, a view into the operand is returned instead -// of a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)`` -// produces a view (changed in version 1.10.0). +// >>> ind = np.argsort(x, axis=1) # sorts along last axis (across) +// >>> ind +// array([[0, 1], +// [0, 1]]) +// >>> np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1) +// array([[0, 3], +// [2, 2]]) // -// `einsum` also provides an alternative way to provide the subscripts and -// operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. -// If the output shape is not provided in this format `einsum` will be -// calculated in implicit mode, otherwise it will be performed explicitly. -// The examples below have corresponding `einsum` calls with the two -// parameter methods. +// Indices of the sorted elements of a N-dimensional array: // -// Views returned from einsum are now writeable whenever the input array -// is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now -// have the same effect as :py:func:`np.swapaxes(a, 0, 2) ` -// and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal -// of a 2D array. +// >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape) +// >>> ind +// (array([0, 1, 1, 0]), array([0, 0, 1, 1])) +// >>> x[ind] # same as np.sort(x, axis=None) +// array([0, 2, 2, 3]) // -// Added the ``optimize`` argument which will optimize the contraction order -// of an einsum expression. For a contraction with three or more operands -// this can greatly increase the computational efficiency at the cost of -// a larger memory footprint during computation. +// Sorting with keys: // -// Typically a 'greedy' algorithm is applied which empirical tests have shown -// returns the optimal path in the majority of cases. In some cases 'optimal' -// will return the superlative path through a more expensive, exhaustive -// search. For iterative calculations it may be advisable to calculate -// the optimal path once and reuse that path by supplying it as an argument. -// An example is given below. +// >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '>> x +// array([(1, 0), (0, 1)], +// dtype=[('x', '>> np.argsort(x, order=('x','y')) +// array([1, 0]) // -// Examples -// -------- -// >>> a = np.arange(25).reshape(5,5) -// >>> b = np.arange(5) -// >>> c = np.arange(6).reshape(2,3) +// >>> np.argsort(x, order=('y','x')) +// array([0, 1]) // -// Trace of a matrix: // -// >>> np.einsum('ii', a) -// 60 -// >>> np.einsum(a, [0,0]) -// 60 -// >>> np.trace(a) -// 60 // -// Extract the diagonal (requires explicit form): +//go:linkname Argsort py.argsort +func Argsort(a *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object +// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// >>> np.einsum('ii->i', a) -// array([ 0, 6, 12, 18, 24]) -// >>> np.einsum(a, [0,0], [0]) -// array([ 0, 6, 12, 18, 24]) -// >>> np.diag(a) -// array([ 0, 6, 12, 18, 24]) +// Given the "legs" of a right triangle, return its hypotenuse. // -// Sum over an axis (requires explicit form): +// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. If `x1` or +// `x2` is scalar_like (i.e., unambiguously cast-able to a scalar type), +// it is broadcast for use with each element of the other argument. +// (See Examples) // -// >>> np.einsum('ij->i', a) -// array([ 10, 35, 60, 85, 110]) -// >>> np.einsum(a, [0,1], [0]) -// array([ 10, 35, 60, 85, 110]) -// >>> np.sum(a, axis=1) -// array([ 10, 35, 60, 85, 110]) +// Parameters +// ---------- +// x1, x2 : array_like +// Leg of the triangle(s). +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// For higher dimensional arrays summing a single axis can be done -// with ellipsis: +// Returns +// ------- +// z : ndarray +// The hypotenuse of the triangle(s). +// This is a scalar if both `x1` and `x2` are scalars. // -// >>> np.einsum('...j->...', a) -// array([ 10, 35, 60, 85, 110]) -// >>> np.einsum(a, [Ellipsis,1], [Ellipsis]) -// array([ 10, 35, 60, 85, 110]) -// -// Compute a matrix transpose, or reorder any number of axes: -// -// >>> np.einsum('ji', c) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// >>> np.einsum('ij->ji', c) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// >>> np.einsum(c, [1,0]) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// >>> np.transpose(c) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// -// Vector inner products: -// -// >>> np.einsum('i,i', b, b) -// 30 -// >>> np.einsum(b, [0], b, [0]) -// 30 -// >>> np.inner(b,b) -// 30 -// -// Matrix vector multiplication: -// -// >>> np.einsum('ij,j', a, b) -// array([ 30, 80, 130, 180, 230]) -// >>> np.einsum(a, [0,1], b, [1]) -// array([ 30, 80, 130, 180, 230]) -// >>> np.dot(a, b) -// array([ 30, 80, 130, 180, 230]) -// >>> np.einsum('...j,j', a, b) -// array([ 30, 80, 130, 180, 230]) -// -// Broadcasting and scalar multiplication: -// -// >>> np.einsum('..., ...', 3, c) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// >>> np.einsum(',ij', 3, c) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// >>> np.einsum(3, [Ellipsis], c, [Ellipsis]) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// >>> np.multiply(3, c) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// -// Vector outer product: -// -// >>> np.einsum('i,j', np.arange(2)+1, b) -// array([[0, 1, 2, 3, 4], -// [0, 2, 4, 6, 8]]) -// >>> np.einsum(np.arange(2)+1, [0], b, [1]) -// array([[0, 1, 2, 3, 4], -// [0, 2, 4, 6, 8]]) -// >>> np.outer(np.arange(2)+1, b) -// array([[0, 1, 2, 3, 4], -// [0, 2, 4, 6, 8]]) -// -// Tensor contraction: -// -// >>> a = np.arange(60.).reshape(3,4,5) -// >>> b = np.arange(24.).reshape(4,3,2) -// >>> np.einsum('ijk,jil->kl', a, b) -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) -// >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) -// >>> np.tensordot(a,b, axes=([1,0],[0,1])) -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) +// Examples +// -------- +// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) // -// Writeable returned arrays (since version 1.10.0): +// Example showing broadcast of scalar_like argument: // -// >>> a = np.zeros((3, 3)) -// >>> np.einsum('ii->i', a)[:] = 1 -// >>> a -// array([[1., 0., 0.], -// [0., 1., 0.], -// [0., 0., 1.]]) +// >>> np.hypot(3*np.ones((3, 3)), [4]) +// array([[ 5., 5., 5.], +// [ 5., 5., 5.], +// [ 5., 5., 5.]]) // -// Example of ellipsis use: +//go:linkname Hypot py.hypot +func Hypot(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// >>> a = np.arange(6).reshape((3,2)) -// >>> b = np.arange(12).reshape((4,3)) -// >>> np.einsum('ki,jk->ij', a, b) -// array([[10, 28, 46, 64], -// [13, 40, 67, 94]]) -// >>> np.einsum('ki,...k->i...', a, b) -// array([[10, 28, 46, 64], -// [13, 40, 67, 94]]) -// >>> np.einsum('k...,jk', a, b) -// array([[10, 28, 46, 64], -// [13, 40, 67, 94]]) +// Test element-wise for positive infinity, return result as bool array. // -// Chained array operations. For more complicated contractions, speed ups -// might be achieved by repeatedly computing a 'greedy' path or pre-computing -// the 'optimal' path and repeatedly applying it, using an `einsum_path` -// insertion (since version 1.12.0). Performance improvements can be -// particularly significant with larger arrays: +// Parameters +// ---------- +// x : array_like +// The input array. +// out : array_like, optional +// A location into which the result is stored. If provided, it must have a +// shape that the input broadcasts to. If not provided or None, a +// freshly-allocated boolean array is returned. // -// >>> a = np.ones(64).reshape(2,4,8) +// Returns +// ------- +// out : ndarray +// A boolean array with the same dimensions as the input. +// If second argument is not supplied then a boolean array is returned +// with values True where the corresponding element of the input is +// positive infinity and values False where the element of the input is +// not positive infinity. // -// Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.) +// If a second argument is supplied the result is stored there. If the +// type of that array is a numeric type the result is represented as zeros +// and ones, if the type is boolean then as False and True. +// The return value `out` is then a reference to that array. // -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a) +// See Also +// -------- +// isinf, isneginf, isfinite, isnan // -// Sub-optimal `einsum` (due to repeated path calculation time): ~330ms +// Notes +// ----- +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). // -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, -// ... optimize='optimal') +// Errors result if the second argument is also supplied when x is a scalar +// input, if first and second arguments have different shapes, or if the +// first argument has complex values // -// Greedy `einsum` (faster optimal path approximation): ~160ms +// Examples +// -------- +// >>> np.isposinf(np.PINF) +// True +// >>> np.isposinf(np.inf) +// True +// >>> np.isposinf(np.NINF) +// False +// >>> np.isposinf([-np.inf, 0., np.inf]) +// array([False, False, True]) // -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy') +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isposinf(x, y) +// array([0, 0, 1]) +// >>> y +// array([0, 0, 1]) // -// Optimal `einsum` (best usage pattern in some use cases): ~110ms // -// >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, -// ... optimize='optimal')[0] -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path) // +//go:linkname Isposinf py.isposinf +func Isposinf(x *py.Object, out *py.Object) *py.Object // +// Returns True if two arrays are element-wise equal within a tolerance. // -//go:linkname Einsum py.einsum -func Einsum(subscripts *py.Object, __llgo_va_list ...interface{}) *py.Object +// The tolerance values are positive, typically very small numbers. The +// relative difference (`rtol` * abs(`b`)) and the absolute difference +// `atol` are added together to compare against the absolute difference +// between `a` and `b`. // -// Returns True if the type of `element` is a scalar type. +// NaNs are treated as equal if they are in the same place and if +// ``equal_nan=True``. Infs are treated as equal if they are in the same +// place and of the same sign in both arrays. // // Parameters // ---------- -// element : any -// Input argument, can be of any type and shape. +// a, b : array_like +// Input arrays to compare. +// rtol : float +// The relative tolerance parameter (see Notes). +// atol : float +// The absolute tolerance parameter (see Notes). +// equal_nan : bool +// Whether to compare NaN's as equal. If True, NaN's in `a` will be +// considered equal to NaN's in `b` in the output array. +// +// .. versionadded:: 1.10.0 // // Returns // ------- -// val : bool -// True if `element` is a scalar type, False if it is not. +// allclose : bool +// Returns True if the two arrays are equal within the given +// tolerance; False otherwise. // // See Also // -------- -// ndim : Get the number of dimensions of an array +// isclose, all, any, equal // // Notes // ----- -// If you need a stricter way to identify a *numerical* scalar, use -// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most -// non-numerical elements such as strings. +// If the following equation is element-wise True, then allclose returns +// True. // -// In most cases ``np.ndim(x) == 0`` should be used instead of this function, -// as that will also return true for 0d arrays. This is how numpy overloads -// functions in the style of the ``dx`` arguments to `gradient` and -// the ``bins`` argument to `histogram`. Some key differences: -// -// +------------------------------------+---------------+-------------------+ -// | x |``isscalar(x)``|``np.ndim(x) == 0``| -// +====================================+===============+===================+ -// | PEP 3141 numeric objects | ``True`` | ``True`` | -// | (including builtins) | | | -// +------------------------------------+---------------+-------------------+ -// | builtin string and buffer objects | ``True`` | ``True`` | -// +------------------------------------+---------------+-------------------+ -// | other builtin objects, like | ``False`` | ``True`` | -// | `pathlib.Path`, `Exception`, | | | -// | the result of `re.compile` | | | -// +------------------------------------+---------------+-------------------+ -// | third-party objects like | ``False`` | ``True`` | -// | `matplotlib.figure.Figure` | | | -// +------------------------------------+---------------+-------------------+ -// | zero-dimensional numpy arrays | ``False`` | ``True`` | -// +------------------------------------+---------------+-------------------+ -// | other numpy arrays | ``False`` | ``False`` | -// +------------------------------------+---------------+-------------------+ -// | `list`, `tuple`, and other | ``False`` | ``False`` | -// | sequence objects | | | -// +------------------------------------+---------------+-------------------+ +// absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`)) // -// Examples -// -------- -// >>> import numpy as np +// The above equation is not symmetric in `a` and `b`, so that +// ``allclose(a, b)`` might be different from ``allclose(b, a)`` in +// some rare cases. // -// >>> np.isscalar(3.1) -// True +// The comparison of `a` and `b` uses standard broadcasting, which +// means that `a` and `b` need not have the same shape in order for +// ``allclose(a, b)`` to evaluate to True. The same is true for +// `equal` but not `array_equal`. // -// >>> np.isscalar(np.array(3.1)) -// False +// `allclose` is not defined for non-numeric data types. +// `bool` is considered a numeric data-type for this purpose. // -// >>> np.isscalar([3.1]) +// Examples +// -------- +// >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8]) // False -// -// >>> np.isscalar(False) +// >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9]) // True -// -// >>> np.isscalar('numpy') +// >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9]) +// False +// >>> np.allclose([1.0, np.nan], [1.0, np.nan]) +// False +// >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) // True // -// NumPy supports PEP 3141 numbers: // -// >>> from fractions import Fraction -// >>> np.isscalar(Fraction(5, 17)) -// True -// >>> from numbers import Number -// >>> np.isscalar(Number()) -// True // +//go:linkname Allclose py.allclose +func Allclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object // +// Compute the variance along the specified axis, while ignoring NaNs. // -//go:linkname Isscalar py.isscalar -func Isscalar(element *py.Object) *py.Object -// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Returns the variance of the array elements, a measure of the spread of +// a distribution. The variance is computed for the flattened array by +// default, otherwise over the specified axis. // -// Return the reciprocal of the argument, element-wise. +// For all-NaN slices or slices with zero degrees of freedom, NaN is +// returned and a `RuntimeWarning` is raised. // -// Calculates ``1/x``. +// .. versionadded:: 1.8.0 // -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Parameters +// ---------- +// a : array_like +// Array containing numbers whose variance is desired. If `a` is not an +// array, a conversion is attempted. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the variance is computed. The default is to compute +// the variance of the flattened array. +// dtype : data-type, optional +// Type to use in computing the variance. For arrays of integer type +// the default is `float64`; for arrays of float types it is the same as +// the array type. +// out : ndarray, optional +// Alternate output array in which to place the result. It must have +// the same shape as the expected output, but the type is cast if +// necessary. +// ddof : int, optional +// "Delta Degrees of Freedom": the divisor used in the calculation is +// ``N - ddof``, where ``N`` represents the number of non-NaN +// elements. By default `ddof` is zero. +// 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`. +// where : array_like of bool, optional +// Elements to include in the variance. See `~numpy.ufunc.reduce` for +// details. // -// Returns -// ------- -// y : ndarray -// Return array. -// This is a scalar if `x` is a scalar. +// .. versionadded:: 1.22.0 // -// Notes -// ----- -// .. note:: -// This function is not designed to work with integers. +// Returns +// ------- +// variance : ndarray, see dtype parameter above +// If `out` is None, return a new array containing the variance, +// otherwise return a reference to the output array. If ddof is >= the +// number of non-NaN elements in a slice or the slice contains only +// NaNs, then the result for that slice is NaN. // -// For integer arguments with absolute value larger than 1 the result is -// always zero because of the way Python handles integer division. For -// integer zero the result is an overflow. +// See Also +// -------- +// std : Standard deviation +// mean : Average +// var : Variance while not ignoring NaNs +// nanstd, nanmean +// :ref:`ufuncs-output-type` // -// Examples -// -------- -// >>> import numpy as np -// >>> np.reciprocal(2.) -// 0.5 -// >>> np.reciprocal([1, 2., 3.33]) -// array([ 1. , 0.5 , 0.3003003]) +// Notes +// ----- +// The variance is the average of the squared deviations from the mean, +// i.e., ``var = mean(abs(x - x.mean())**2)``. // -//go:linkname Reciprocal py.reciprocal -func Reciprocal(x *py.Object, out *py.Object) *py.Object +// The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``. +// If, however, `ddof` is specified, the divisor ``N - ddof`` is used +// instead. In standard statistical practice, ``ddof=1`` provides an +// unbiased estimator of the variance of a hypothetical infinite +// population. ``ddof=0`` provides a maximum likelihood estimate of the +// variance for normally distributed variables. // -// Estimate a covariance matrix, given data and weights. +// Note that for complex numbers, the absolute value is taken before +// squaring, so that the result is always real and nonnegative. // -// Covariance indicates the level to which two variables vary together. -// If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`, -// then 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`. +// For floating-point input, the variance is computed using the same +// precision the input has. Depending on the input data, this can cause +// the results to be inaccurate, especially for `float32` (see example +// below). Specifying a higher-accuracy accumulator using the ``dtype`` +// keyword can alleviate this issue. // -// See the notes for an outline of the algorithm. +// For this function to work on sub-classes of ndarray, they must define +// `sum` with the kwarg `keepdims` +// +// Examples +// -------- +// >>> a = np.array([[1, np.nan], [3, 4]]) +// >>> np.nanvar(a) +// 1.5555555555555554 +// >>> np.nanvar(a, axis=0) +// array([1., 0.]) +// >>> np.nanvar(a, axis=1) +// array([0., 0.25]) # may vary +// +// +// +//go:linkname Nanvar py.nanvar +func Nanvar(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object +// +// Cross-correlation of two 1-dimensional sequences. +// +// This function computes the correlation as generally defined in signal +// processing texts: +// +// .. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n +// +// with a and v sequences being zero-padded where necessary and +// :math:`\overline x` denoting complex conjugation. // // Parameters // ---------- -// m : array_like -// A 1-D or 2-D array containing multiple variables and observations. -// Each row of `m` represents a variable, and each column a single -// observation of all those variables. Also see `rowvar` below. -// y : array_like, optional -// An additional set of variables and observations. `y` has the same form -// as that of `m`. -// rowvar : bool, optional -// If `rowvar` is True (default), then each row represents a -// variable, with observations in the columns. Otherwise, the relationship -// is transposed: each column represents a variable, while the rows -// contain observations. -// bias : bool, optional -// Default normalization (False) is by ``(N - 1)``, where ``N`` is the -// number of observations given (unbiased estimate). If `bias` is True, -// then normalization is by ``N``. These values can be overridden by using -// the keyword ``ddof`` in numpy versions >= 1.5. -// ddof : int, optional -// If not ``None`` the default value implied by `bias` is overridden. -// Note that ``ddof=1`` will return the unbiased estimate, even if both -// `fweights` and `aweights` are specified, and ``ddof=0`` will return -// the simple average. See the notes for the details. The default value -// is ``None``. -// fweights : array_like, int, optional -// 1-D array of integer frequency weights; the number of times each -// observation vector should be repeated. -// aweights : array_like, optional -// 1-D array of observation vector weights. These relative weights are -// typically large for observations considered "important" and smaller for -// observations considered less "important". If ``ddof=0`` the array of -// weights can be used to assign probabilities to observation vectors. -// dtype : data-type, optional -// Data-type of the result. By default, the return data-type will have -// at least `numpy.float64` precision. -// -// .. versionadded:: 1.20 +// a, v : array_like +// Input sequences. +// mode : {'valid', 'same', 'full'}, optional +// Refer to the `convolve` docstring. Note that the default +// is 'valid', unlike `convolve`, which uses 'full'. +// old_behavior : bool +// `old_behavior` was removed in NumPy 1.10. If you need the old +// behavior, use `multiarray.correlate`. // // Returns // ------- // out : ndarray -// The covariance matrix of the variables. +// Discrete cross-correlation of `a` and `v`. // // See Also // -------- -// corrcoef : Normalized covariance matrix +// convolve : Discrete, linear convolution of two one-dimensional sequences. +// multiarray.correlate : Old, no conjugate, version of correlate. +// scipy.signal.correlate : uses FFT which has superior performance on large arrays. // // Notes // ----- -// Assume that the observations are in the columns of the observation -// array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The -// steps to compute the weighted covariance are as follows:: +// The definition of correlation above is not unique and sometimes correlation +// may be defined differently. Another common definition is: // -// >>> m = np.arange(10, dtype=np.float64) -// >>> f = np.arange(10) * 2 -// >>> a = np.arange(10) ** 2. -// >>> ddof = 1 -// >>> w = f * a -// >>> v1 = np.sum(w) -// >>> v2 = np.sum(w * a) -// >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1 -// >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2) +// .. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}} // -// Note that when ``a == 1``, the normalization factor -// ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)`` -// as it should. +// which is related to :math:`c_k` by :math:`c'_k = c_{-k}`. // -// Examples -// -------- -// >>> import numpy as np +// `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 +// be preferable. // -// Consider two variables, :math:`x_0` and :math:`x_1`, which -// correlate perfectly, but in opposite directions: // -// >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T -// >>> x -// array([[0, 1, 2], -// [2, 1, 0]]) +// Examples +// -------- +// >>> np.correlate([1, 2, 3], [0, 1, 0.5]) +// array([3.5]) +// >>> np.correlate([1, 2, 3], [0, 1, 0.5], "same") +// array([2. , 3.5, 3. ]) +// >>> np.correlate([1, 2, 3], [0, 1, 0.5], "full") +// array([0.5, 2. , 3.5, 3. , 0. ]) // -// Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance -// matrix shows this clearly: +// Using complex sequences: // -// >>> np.cov(x) -// array([[ 1., -1.], -// [-1., 1.]]) +// >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full') +// array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ]) // -// Note that element :math:`C_{0,1}`, which shows the correlation between -// :math:`x_0` and :math:`x_1`, is negative. +// Note that you get the time reversed, complex conjugated result +// (:math:`\overline{c_{-k}}`) when the two input sequences a and v change +// places: // -// Further, note how `x` and `y` are combined: +// >>> 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]) // -// >>> x = [-2.1, -1, 4.3] -// >>> y = [3, 1.1, 0.12] -// >>> X = np.stack((x, y), axis=0) -// >>> np.cov(X) -// array([[11.71 , -4.286 ], # may vary -// [-4.286 , 2.144133]]) -// >>> np.cov(x, y) -// array([[11.71 , -4.286 ], # may vary -// [-4.286 , 2.144133]]) -// >>> np.cov(x) -// array(11.71) // // +//go:linkname Correlate py.correlate +func Correlate(a *py.Object, v *py.Object, mode *py.Object) *py.Object // -//go:linkname Cov py.cov -func Cov(m *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object, fweights *py.Object, aweights *py.Object) *py.Object +// Compute the arithmetic mean along the specified axis. // -// Compute the standard deviation along the specified axis, while -// ignoring NaNs. -// -// Returns the standard deviation, a measure of the spread of a -// distribution, of the non-NaN array elements. The standard deviation is -// computed for the flattened array by default, otherwise over the -// specified axis. -// -// For all-NaN slices or slices with zero degrees of freedom, NaN is -// returned and a `RuntimeWarning` is raised. +// Returns the average of the array elements. The average is taken over +// the flattened array by default, otherwise over the specified axis. +// `float64` intermediate and return values are used for integer inputs. // // Parameters // ---------- // a : array_like -// Calculate the standard deviation of the non-NaN values. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the standard deviation is computed. The default is -// to compute the standard deviation of the flattened array. -// dtype : dtype, optional -// Type to use in computing the standard deviation. For arrays of -// integer type the default is float64, for arrays of float types it -// is the same as the array type. +// Array containing numbers whose mean is desired. If `a` is not an +// array, a conversion is attempted. +// axis : None or int or tuple of ints, optional +// Axis or axes along which the means are computed. The default is to +// compute the mean of the flattened array. +// +// .. versionadded:: 1.7.0 +// +// If this is a tuple of ints, a mean is performed over multiple axes, +// instead of a single axis or all the axes as before. +// dtype : data-type, optional +// Type to use in computing the mean. For integer inputs, the default +// is `float64`; for floating point inputs, it is the same as the +// input dtype. // out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output but the type (of the -// calculated values) will be cast if necessary. -// ddof : {int, float}, optional -// Means Delta Degrees of Freedom. The divisor used in calculations -// is ``N - ddof``, where ``N`` represents the number of non-NaN -// elements. By default `ddof` is zero. +// Alternate output array in which to place the result. The default +// is ``None``; if provided, it must have the same shape as the +// expected output, but the type will be cast if necessary. +// See :ref:`ufuncs-output-type` for more details. // // 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`. -// -// If this value is anything but the default it is passed through -// as-is to the relevant functions of the sub-classes. If these -// functions do not have a `keepdims` kwarg, a RuntimeError will -// be raised. -// where : array_like of bool, optional -// Elements to include in the standard deviation. -// See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// -// mean : array_like, optional -// Provide the mean to prevent its recalculation. The mean should have -// a shape as if it was calculated with ``keepdims=True``. -// The axis for the calculation of the mean should be the same as used in -// the call to this std function. +// the result will broadcast correctly against the input array. // -// .. versionadded:: 2.0.0 +// If the default value is passed, then `keepdims` will not be +// passed through to the `mean` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. // -// correction : {int, float}, optional -// Array API compatible name for the ``ddof`` parameter. Only one of them -// can be provided at the same time. +// where : array_like of bool, optional +// Elements to include in the mean. See `~numpy.ufunc.reduce` for details. // -// .. versionadded:: 2.0.0 +// .. versionadded:: 1.20.0 // // Returns // ------- -// standard_deviation : ndarray, see dtype parameter above. -// If `out` is None, return a new array containing the standard -// deviation, otherwise return a reference to the output array. If -// ddof is >= the number of non-NaN elements in a slice or the slice -// contains only NaNs, then the result for that slice is NaN. +// m : ndarray, see dtype parameter above +// If `out=None`, returns a new array containing the mean values, +// otherwise a reference to the output array is returned. // // See Also // -------- -// var, mean, std -// nanvar, nanmean -// :ref:`ufuncs-output-type` +// average : Weighted average +// std, var, nanmean, nanstd, nanvar // // Notes // ----- -// The standard deviation is the square root of the average of the squared -// deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``. -// -// The average squared deviation is normally calculated as -// ``x.sum() / N``, where ``N = len(x)``. If, however, `ddof` is -// specified, the divisor ``N - ddof`` is used instead. In standard -// statistical practice, ``ddof=1`` provides an unbiased estimator of the -// variance of the infinite population. ``ddof=0`` provides a maximum -// likelihood estimate of the variance for normally distributed variables. -// The standard deviation computed in this function is the square root of -// the estimated variance, so even with ``ddof=1``, it will not be an -// unbiased estimate of the standard deviation per se. +// The arithmetic mean is the sum of the elements along the axis divided +// by the number of elements. // -// Note that, for complex numbers, `std` takes the absolute value before -// squaring, so that the result is always real and nonnegative. +// Note that for floating-point input, the mean is computed using the +// same precision the input has. Depending on the input data, this can +// cause the results to be inaccurate, especially for `float32` (see +// example below). Specifying a higher-precision accumulator using the +// `dtype` keyword can alleviate this issue. // -// For floating-point input, the *std* is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for float32 (see example -// below). Specifying a higher-accuracy accumulator using the `dtype` -// keyword can alleviate this issue. +// By default, `float16` results are computed using `float32` intermediates +// for extra precision. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1, np.nan], [3, 4]]) -// >>> np.nanstd(a) -// 1.247219128924647 -// >>> np.nanstd(a, axis=0) -// array([1., 0.]) -// >>> np.nanstd(a, axis=1) -// array([0., 0.5]) # may vary +// >>> a = np.array([[1, 2], [3, 4]]) +// >>> np.mean(a) +// 2.5 +// >>> np.mean(a, axis=0) +// array([2., 3.]) +// >>> np.mean(a, axis=1) +// array([1.5, 3.5]) // +// In single precision, `mean` can be inaccurate: // +// >>> a = np.zeros((2, 512*512), dtype=np.float32) +// >>> a[0, :] = 1.0 +// >>> a[1, :] = 0.1 +// >>> np.mean(a) +// 0.54999924 // -//go:linkname Nanstd py.nanstd -func Nanstd(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object +// Computing the mean in float64 is more accurate: // -// Check for a complex type or an array of complex numbers. +// >>> np.mean(a, dtype=np.float64) +// 0.55000000074505806 # may vary // -// The type of the input is checked, not the value. Even if the input -// has an imaginary part equal to zero, `iscomplexobj` evaluates to True. +// Specifying a where argument: // -// Parameters -// ---------- -// x : any -// The input can be of any type and shape. +// >>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]]) +// >>> np.mean(a) +// 12.0 +// >>> np.mean(a, where=[[True], [False], [False]]) +// 9.0 // -// Returns -// ------- -// iscomplexobj : bool -// The return value, True if `x` is of a complex type or has at least -// one complex element. // -// See Also -// -------- -// isrealobj, iscomplex // -// Examples -// -------- -// >>> import numpy as np -// >>> np.iscomplexobj(1) -// False -// >>> np.iscomplexobj(1+0j) -// True -// >>> np.iscomplexobj([3, 1+0j, True]) -// True +//go:linkname Mean py.mean +func Mean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object) *py.Object +// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // +// Inverse hyperbolic sine element-wise. // +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -//go:linkname Iscomplexobj py.iscomplexobj -func Iscomplexobj(x *py.Object) *py.Object +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. // -// Return the product of array elements over a given axis. +// Notes +// ----- +// `arcsinh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that `sinh(z) = x`. The convention is to return the +// `z` whose imaginary part lies in `[-pi/2, pi/2]`. // -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a product is performed. The default, -// axis=None, will calculate the product of all the elements in the -// input array. If axis is negative it counts from the last to the -// first axis. +// For real-valued input data types, `arcsinh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, it +// returns ``nan`` and sets the `invalid` floating point error flag. // -// If axis is a tuple of ints, a product is performed on all of the -// axes specified in the tuple instead of a single axis or all the -// axes as before. -// dtype : dtype, optional -// The type of the returned array, as well as of the accumulator in -// which the elements are multiplied. The dtype of `a` is used by -// default unless `a` has an integer dtype of less precision than the -// default platform integer. In that case, if `a` is signed then the -// platform integer is used while if `a` is unsigned then an unsigned -// integer of the same precision as the platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output, but the type of the output -// values will be cast if necessary. -// 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 input array. +// For complex-valued input, `arccos` is a complex analytical function that +// has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from +// the right on the former and from the left on the latter. // -// If the default value is passed, then `keepdims` will not be -// passed through to the `prod` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// initial : scalar, optional -// The starting value for this product. See `~numpy.ufunc.reduce` -// for details. -// where : array_like of bool, optional -// Elements to include in the product. See `~numpy.ufunc.reduce` -// for details. +// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. // -// Returns -// ------- -// product_along_axis : ndarray, see `dtype` parameter above. -// An array shaped as `a` but with the specified axis removed. -// Returns a reference to `out` if specified. +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arcsinh // -// See Also -// -------- -// ndarray.prod : equivalent method -// :ref:`ufuncs-output-type` +// Examples +// -------- +// >>> np.arcsinh(np.array([np.e, 10.0])) +// array([ 1.72538256, 2.99822295]) // -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. That means that, on a 32-bit platform: -// -// >>> x = np.array([536870910, 536870910, 536870910, 536870910]) -// >>> np.prod(x) -// 16 # may vary +//go:linkname Arcsinh py.arcsinh +func Arcsinh(x *py.Object, out *py.Object) *py.Object +// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// The product of an empty array is the neutral element 1: +// Return the floor of the input, element-wise. // -// >>> np.prod([]) -// 1.0 +// The floor of the scalar `x` is the largest integer `i`, such that +// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. // -// Examples -// -------- -// By default, calculate the product of all elements: +// Parameters +// ---------- +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> import numpy as np -// >>> np.prod([1.,2.]) -// 2.0 +// Returns +// ------- +// y : ndarray or scalar +// The floor of each element in `x`. +// This is a scalar if `x` is a scalar. // -// Even when the input array is two-dimensional: +// See Also +// -------- +// ceil, trunc, rint, fix // -// >>> a = np.array([[1., 2.], [3., 4.]]) -// >>> np.prod(a) -// 24.0 +// Notes +// ----- +// Some spreadsheet programs calculate the "floor-towards-zero", where +// ``floor(-2.5) == -2``. NumPy instead uses the definition of +// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" +// function is called ``fix`` in NumPy. // -// But we can also specify the axis over which to multiply: +// Examples +// -------- +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.floor(a) +// array([-2., -2., -1., 0., 1., 1., 2.]) // -// >>> np.prod(a, axis=1) -// array([ 2., 12.]) -// >>> np.prod(a, axis=0) -// array([3., 8.]) +//go:linkname Floor py.floor +func Floor(x *py.Object, out *py.Object) *py.Object +// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Or select specific elements to include: +// Return the non-negative square-root of an array, element-wise. // -// >>> np.prod([1., np.nan, 3.], where=[True, False, True]) -// 3.0 +// Parameters +// ---------- +// x : array_like +// The values whose square-roots are required. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// If the type of `x` is unsigned, then the output type is -// the unsigned platform integer: +// Returns +// ------- +// y : ndarray +// An array of the same shape as `x`, containing the positive +// square-root of each element in `x`. If any element in `x` is +// complex, a complex array is returned (and the square-roots of +// negative reals are calculated). If all of the elements in `x` +// are real, so is `y`, with negative elements returning ``nan``. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. // -// >>> x = np.array([1, 2, 3], dtype=np.uint8) -// >>> np.prod(x).dtype == np.uint -// True +// See Also +// -------- +// emath.sqrt +// A version which returns complex numbers when given negative reals. +// Note that 0.0 and -0.0 are handled differently for complex inputs. // -// If `x` is of a signed integer type, then the output type -// is the default platform integer: +// Notes +// ----- +// *sqrt* has--consistent with common convention--as its branch cut the +// real "interval" [`-inf`, 0), and is continuous from above on it. +// A branch cut is a curve in the complex plane across which a given +// complex function fails to be continuous. // -// >>> x = np.array([1, 2, 3], dtype=np.int8) -// >>> np.prod(x).dtype == int -// True +// Examples +// -------- +// >>> np.sqrt([1,4,9]) +// array([ 1., 2., 3.]) // -// You can also start the product with a value other than one: +// >>> np.sqrt([4, -1, -3+4J]) +// array([ 2.+0.j, 0.+1.j, 1.+2.j]) // -// >>> np.prod([1, 2], initial=5) -// 10 +// >>> np.sqrt([4, -1, np.inf]) +// array([ 2., nan, inf]) // +//go:linkname Sqrt py.sqrt +func Sqrt(x *py.Object, out *py.Object) *py.Object // -//go:linkname Prod py.prod -func Prod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// Return numbers spaced evenly on a log scale. // -// Set the floating-point error callback function or log object. +// In linear space, the sequence starts at ``base ** start`` +// (`base` to the power of `start`) and ends with ``base ** stop`` +// (see `endpoint` below). // -// There are two ways to capture floating-point error messages. The first -// is to set the error-handler to 'call', using `seterr`. Then, set -// the function to call using this function. +// .. versionchanged:: 1.16.0 +// Non-scalar `start` and `stop` are now supported. // -// The second is to set the error-handler to 'log', using `seterr`. -// Floating-point errors then trigger a call to the 'write' method of -// the provided object. +// .. versionchanged:: 1.25.0 +// Non-scalar 'base` is now supported // // Parameters // ---------- -// func : callable f(err, flag) or object with write method -// Function to call upon floating-point errors ('call'-mode) or -// object whose 'write' method is used to log such message ('log'-mode). -// -// The call function takes two arguments. The first is a string describing -// the type of error (such as "divide by zero", "overflow", "underflow", -// or "invalid value"), and the second is the status flag. The flag is a -// byte, whose four least-significant bits indicate the type of error, one -// of "divide", "over", "under", "invalid":: -// -// [0 0 0 0 divide over under invalid] +// start : array_like +// ``base ** start`` is the starting value of the sequence. +// stop : array_like +// ``base ** stop`` is the final value of the sequence, unless `endpoint` +// is False. In that case, ``num + 1`` values are spaced over the +// interval in log-space, of which all but the last (a sequence of +// length `num`) are returned. +// num : integer, optional +// Number of samples to generate. Default is 50. +// endpoint : boolean, optional +// If true, `stop` is the last sample. Otherwise, it is not included. +// Default is True. +// base : array_like, optional +// The base of the log space. The step size between the elements in +// ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform. +// Default is 10.0. +// dtype : dtype +// The type of the output array. If `dtype` is not given, the data type +// is inferred from `start` and `stop`. The inferred type will never be +// an integer; `float` is chosen even if the arguments would produce an +// array of integers. +// axis : int, optional +// The axis in the result to store the samples. Relevant only if start, +// stop, or base are array-like. By default (0), the samples will be +// along a new axis inserted at the beginning. Use -1 to get an axis at +// the end. // -// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. +// .. versionadded:: 1.16.0 // -// If an object is provided, its write method should take one argument, -// a string. // // Returns // ------- -// h : callable, log instance or None -// The old error handler. +// samples : ndarray +// `num` samples, equally spaced on a log scale. // // See Also // -------- -// seterr, geterr, geterrcall +// arange : Similar to linspace, with the step size specified instead of the +// number of samples. Note that, when used with a float endpoint, the +// endpoint may or may not be included. +// 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 +// ----- +// If base is a scalar, logspace is equivalent to the code +// +// >>> y = np.linspace(start, stop, num=num, endpoint=endpoint) +// ... # doctest: +SKIP +// >>> power(base, y).astype(dtype) +// ... # doctest: +SKIP // // Examples // -------- -// Callback upon error: +// >>> np.logspace(2.0, 3.0, num=4) +// array([ 100. , 215.443469 , 464.15888336, 1000. ]) +// >>> np.logspace(2.0, 3.0, num=4, endpoint=False) +// array([100. , 177.827941 , 316.22776602, 562.34132519]) +// >>> np.logspace(2.0, 3.0, num=4, base=2.0) +// array([4. , 5.0396842 , 6.34960421, 8. ]) +// >>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1) +// array([[ 4. , 5.0396842 , 6.34960421, 8. ], +// [ 9. , 12.98024613, 18.72075441, 27. ]]) // -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// ... +// Graphical illustration: // -// >>> import numpy as np +// >>> import matplotlib.pyplot as plt +// >>> N = 10 +// >>> x1 = np.logspace(0.1, 1, N, endpoint=True) +// >>> x2 = np.logspace(0.1, 1, N, endpoint=False) +// >>> y = np.zeros(N) +// >>> plt.plot(x1, y, 'o') +// [] +// >>> plt.plot(x2, y + 0.5, 'o') +// [] +// >>> plt.ylim([-0.5, 1]) +// (-0.5, 1) +// >>> plt.show() // -// >>> orig_handler = np.seterrcall(err_handler) -// >>> orig_err = np.seterr(all='call') // -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) // -// >>> np.seterrcall(orig_handler) -// -// >>> np.seterr(**orig_err) -// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} +//go:linkname Logspace py.logspace +func Logspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, base *py.Object, dtype *py.Object, axis *py.Object) *py.Object // -// Log error message: +// Return a scalar type which is common to the input arrays. // -// >>> class Log: -// ... def write(self, msg): -// ... print("LOG: %s" % msg) -// ... +// The return type will always be an inexact (i.e. floating point) scalar +// type, even if all the arrays are integer arrays. If one of the inputs is +// an integer array, the minimum precision type that is returned is a +// 64-bit floating point dtype. // -// >>> log = Log() -// >>> saved_handler = np.seterrcall(log) -// >>> save_err = np.seterr(all='log') +// All input arrays except int64 and uint64 can be safely cast to the +// returned dtype without loss of information. // -// >>> np.array([1, 2, 3]) / 0.0 -// LOG: Warning: divide by zero encountered in divide -// array([inf, inf, inf]) +// Parameters +// ---------- +// array1, array2, ... : ndarrays +// Input arrays. // -// >>> np.seterrcall(orig_handler) -// -// >>> np.seterr(**orig_err) -// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} +// Returns +// ------- +// out : data type code +// Data type code. // +// See Also +// -------- +// dtype, mintypecode // +// Examples +// -------- +// >>> np.common_type(np.arange(2, dtype=np.float32)) +// +// >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2)) +// +// >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0])) +// // -//go:linkname Seterrcall py.seterrcall -func Seterrcall(func_ *py.Object) *py.Object -// asarray(a, dtype=None, order=None, *, device=None, copy=None, like=None) // -// Convert the input to an array. // -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes lists, lists of tuples, tuples, tuples of tuples, tuples -// of lists and ndarrays. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'K'. -// device : str, optional -// The device on which to place the created array. Default: ``None``. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. +//go:linkname CommonType py.common_type +func CommonType(__llgo_va_list ...interface{}) *py.Object // -// .. versionadded:: 2.0.0 -// copy : bool, optional -// If ``True``, then the object is copied. If ``None`` then the object is -// copied only if needed, i.e. if ``__array__`` returns a copy, if obj -// is a nested sequence, or if a copy is needed to satisfy any of -// the other requirements (``dtype``, ``order``, etc.). -// For ``False`` it raises a ``ValueError`` if a copy cannot be avoided. -// Default: ``None``. -// -// .. versionadded:: 2.0.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// Upper triangle of an array. // -// .. versionadded:: 1.20.0 +// 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. // -// Returns -// ------- -// out : ndarray -// Array interpretation of ``a``. No copy is performed if the input -// is already an ndarray with matching dtype and order. If ``a`` is a -// subclass of ndarray, a base class ndarray is returned. +// Please refer to the documentation for `tril` for further details. // // See Also // -------- -// asanyarray : Similar function which passes through subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// asarray_chkfinite : Similar function which checks input for NaNs and Infs. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. +// tril : lower triangle of an array // // Examples // -------- -// Convert a list into an array: +// >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1) +// array([[ 1, 2, 3], +// [ 4, 5, 6], +// [ 0, 8, 9], +// [ 0, 0, 12]]) // -// >>> a = [1, 2] -// >>> import numpy as np -// >>> np.asarray(a) -// array([1, 2]) +// >>> np.triu(np.arange(3*4*5).reshape(3, 4, 5)) +// array([[[ 0, 1, 2, 3, 4], +// [ 0, 6, 7, 8, 9], +// [ 0, 0, 12, 13, 14], +// [ 0, 0, 0, 18, 19]], +// [[20, 21, 22, 23, 24], +// [ 0, 26, 27, 28, 29], +// [ 0, 0, 32, 33, 34], +// [ 0, 0, 0, 38, 39]], +// [[40, 41, 42, 43, 44], +// [ 0, 46, 47, 48, 49], +// [ 0, 0, 52, 53, 54], +// [ 0, 0, 0, 58, 59]]]) // -// Existing arrays are not copied: // -// >>> a = np.array([1, 2]) -// >>> np.asarray(a) is a -// True // -// If `dtype` is set, array is copied only if dtype does not match: +//go:linkname Triu py.triu +func Triu(m *py.Object, k *py.Object) *py.Object +// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// >>> a = np.array([1, 2], dtype=np.float32) -// >>> np.shares_memory(np.asarray(a, dtype=np.float32), a) -// True -// >>> np.shares_memory(np.asarray(a, dtype=np.float64), a) -// False +// Calculate ``exp(x) - 1`` for all elements in the array. // -// Contrary to `asanyarray`, ndarray subclasses are not passed through: +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> issubclass(np.recarray, np.ndarray) -// True -// >>> a = np.array([(1., 2), (3., 4)], dtype='f4,i4').view(np.recarray) -// >>> np.asarray(a) is a -// False -// >>> np.asanyarray(a) is a -// True +// Returns +// ------- +// out : ndarray or scalar +// Element-wise exponential minus one: ``out = exp(x) - 1``. +// This is a scalar if `x` is a scalar. // -//go:linkname Asarray py.asarray -func Asarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object +// See Also +// -------- +// log1p : ``log(1 + x)``, the inverse of expm1. // -// Return the maximum of an array or maximum along an axis. // -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to operate. By default, flattened input is -// used. 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. +// Notes +// ----- +// This function provides greater precision than ``exp(x) - 1`` +// for small values of ``x``. // -// out : ndarray, optional -// Alternative output array in which to place the result. Must -// be of the same shape and buffer length as the expected output. -// See :ref:`ufuncs-output-type` for more details. +// Examples +// -------- +// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to +// about 32 significant digits. This example shows the superiority of +// expm1 in this case. // -// 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 input array. +// >>> np.expm1(1e-10) +// 1.00000000005e-10 +// >>> np.exp(1e-10) - 1 +// 1.000000082740371e-10 // -// If the default value is passed, then `keepdims` will not be -// passed through to the ``max`` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. +//go:linkname Expm1 py.expm1 +func Expm1(x *py.Object, out *py.Object) *py.Object +// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// initial : scalar, optional -// The minimum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. +// Return the natural logarithm of one plus the input array, element-wise. // -// where : array_like of bool, optional -// Elements to compare for the maximum. See `~numpy.ufunc.reduce` -// for details. +// Calculates ``log(1 + x)``. // -// Returns -// ------- -// max : ndarray or scalar -// Maximum of `a`. If `axis` is None, the result is a scalar value. -// 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)``. +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// See Also -// -------- -// amin : -// The minimum value of an array along a given axis, propagating any NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignoring any NaNs. -// maximum : -// Element-wise maximum of two arrays, propagating any NaNs. -// fmax : -// Element-wise maximum of two arrays, ignoring any NaNs. -// argmax : -// Return the indices of the maximum values. +// Returns +// ------- +// y : ndarray +// Natural logarithm of `1 + x`, element-wise. +// This is a scalar if `x` is a scalar. // -// nanmin, minimum, fmin +// See Also +// -------- +// expm1 : ``exp(x) - 1``, the inverse of `log1p`. // -// Notes -// ----- -// NaN values are propagated, that is if at least one item is NaN, the -// corresponding max value will be NaN as well. To ignore NaN values -// (MATLAB behavior), please use nanmax. +// Notes +// ----- +// For real-valued input, `log1p` is accurate also for `x` so small +// that `1 + x == 1` in floating-point accuracy. // -// Don't use `~numpy.max` for element-wise comparison of 2 arrays; when -// ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than -// ``max(a, axis=0)``. +// Logarithm is a multivalued function: for each `x` there is an infinite +// number of `z` such that `exp(z) = 1 + x`. The convention is to return +// the `z` whose imaginary part lies in `[-pi, pi]`. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.arange(4).reshape((2,2)) -// >>> a -// array([[0, 1], -// [2, 3]]) -// >>> np.max(a) # Maximum of the flattened array -// 3 -// >>> np.max(a, axis=0) # Maxima along the first axis -// array([2, 3]) -// >>> np.max(a, axis=1) # Maxima along the second axis -// array([1, 3]) -// >>> np.max(a, where=[False, True], initial=-1, axis=0) -// array([-1, 3]) -// >>> b = np.arange(5, dtype=float) -// >>> b[2] = np.nan -// >>> np.max(b) -// np.float64(nan) -// >>> np.max(b, where=~np.isnan(b), initial=-1) -// 4.0 -// >>> np.nanmax(b) -// 4.0 +// For real-valued input data types, `log1p` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. // -// You can use an initial value to compute the maximum of an empty slice, or -// to initialize it to a different value: +// For complex-valued input, `log1p` is a complex analytical function that +// has a branch cut `[-inf, -1]` and is continuous from above on it. +// `log1p` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. // -// >>> np.max([[-50], [10]], axis=-1, initial=0) -// array([ 0, 10]) +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm // -// Notice that the initial value is used as one of the elements for which the -// maximum is determined, unlike for the default argument Python's max -// function, which is only used for empty iterables. +// Examples +// -------- +// >>> np.log1p(1e-99) +// 1e-99 +// >>> np.log(1 + 1e-99) +// 0.0 // -// >>> np.max([5], initial=6) -// 6 -// >>> max([5], default=6) -// 5 +//go:linkname Log1p py.log1p +func Log1p(x *py.Object, out *py.Object) *py.Object +// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // +// First array elements raised to powers from second array, element-wise. // -//go:linkname Max py.max -func Max(__llgo_va_list ...interface{}) *py.Object +// Raise each base in `x1` to the positionally-corresponding power in +// `x2`. `x1` and `x2` must be broadcastable to the same shape. // -// packbits(a, /, axis=None, bitorder='big') +// An integer type raised to a negative integer power will raise a +// ``ValueError``. // -// Packs the elements of a binary-valued array into bits in a uint8 array. +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). // -// The result is padded to full bytes by inserting zero bits at the end. +// Parameters +// ---------- +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// Parameters -// ---------- -// a : array_like -// An array of integers or booleans whose elements should be packed to -// bits. -// axis : int, optional -// The dimension over which bit-packing is done. -// ``None`` implies packing the flattened array. -// bitorder : {'big', 'little'}, optional -// The order of the input bits. 'big' will mimic bin(val), -// ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will -// reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``. -// Defaults to 'big'. +// Returns +// ------- +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. +// This is a scalar if both `x1` and `x2` are scalars. // -// Returns -// ------- -// packed : ndarray -// Array of type uint8 whose elements represent bits corresponding to the -// logical (0 or nonzero) value of the input elements. The shape of -// `packed` has the same number of dimensions as the input (unless `axis` -// is None, in which case the output is 1-D). +// See Also +// -------- +// float_power : power function that promotes integers to float // -// See Also -// -------- -// unpackbits: Unpacks elements of a uint8 array into a binary-valued output -// array. +// Examples +// -------- +// Cube each element in an array. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[[1,0,1], -// ... [0,1,0]], -// ... [[1,1,0], -// ... [0,0,1]]]) -// >>> b = np.packbits(a, axis=-1) -// >>> b -// array([[[160], -// [ 64]], -// [[192], -// [ 32]]], dtype=uint8) +// >>> x1 = np.arange(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.power(x1, 3) +// array([ 0, 1, 8, 27, 64, 125]) // -// Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, -// and 32 = 0010 0000. +// Raise the bases to different exponents. // +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) // +// The effect of broadcasting. // -//go:linkname Packbits py.packbits -func Packbits(a *py.Object, axis *py.Object, bitorder *py.Object) *py.Object +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.power(x1, x2) +// array([[ 0, 1, 8, 27, 16, 5], +// [ 0, 1, 8, 27, 16, 5]]) // -// unpackbits(a, /, axis=None, count=None, bitorder='big') +// The ``**`` operator can be used as a shorthand for ``np.power`` on +// ndarrays. // -// Unpacks elements of a uint8 array into a binary-valued output array. +// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) +// >>> x1 = np.arange(6) +// >>> x1 ** x2 +// array([ 0, 1, 8, 27, 16, 5]) // -// Each element of `a` represents a bit-field that should be unpacked -// into a binary-valued output array. The shape of the output array is -// either 1-D (if `axis` is ``None``) or the same shape as the input -// array with unpacking done along the axis specified. +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1.0, -4.0]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname Power py.power +func Power(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// +// Return a 2-D array with ones on the diagonal and zeros elsewhere. // // Parameters // ---------- -// a : ndarray, uint8 type -// Input array. -// axis : int, optional -// The dimension over which bit-unpacking is done. -// ``None`` implies unpacking the flattened array. -// count : int or None, optional -// The number of elements to unpack along `axis`, provided as a way -// of undoing the effect of packing a size that is not a multiple -// of eight. A non-negative number means to only unpack `count` -// bits. A negative number means to trim off that many bits from -// the end. ``None`` means to unpack the entire array (the -// default). Counts larger than the available number of bits will -// add zero padding to the output. Negative counts must not -// exceed the available number of bits. -// bitorder : {'big', 'little'}, optional -// The order of the returned bits. 'big' will mimic bin(val), -// ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse -// the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``. -// Defaults to 'big'. +// N : int +// Number of rows in the output. +// M : int, optional +// Number of columns in the output. If None, defaults to `N`. +// k : int, optional +// Index of the diagonal: 0 (the default) refers to the main diagonal, +// a positive value refers to an upper diagonal, and a negative value +// to a lower diagonal. +// dtype : data-type, optional +// Data-type of the returned array. +// order : {'C', 'F'}, optional +// Whether the output should be stored in row-major (C-style) or +// column-major (Fortran-style) order in memory. +// +// .. versionadded:: 1.14.0 +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // // Returns // ------- -// unpacked : ndarray, uint8 type -// The elements are binary-valued (0 or 1). +// I : ndarray of shape (N,M) +// An array where all elements are equal to zero, except for the `k`-th +// diagonal, whose values are equal to one. // // See Also // -------- -// packbits : Packs the elements of a binary-valued array into bits in -// a uint8 array. +// identity : (almost) equivalent function +// diag : diagonal 2-D array from a 1-D array specified by the user. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[2], [7], [23]], dtype=np.uint8) -// >>> a -// array([[ 2], -// [ 7], -// [23]], dtype=uint8) -// >>> b = np.unpackbits(a, axis=1) -// >>> b -// array([[0, 0, 0, 0, 0, 0, 1, 0], -// [0, 0, 0, 0, 0, 1, 1, 1], -// [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8) -// >>> c = np.unpackbits(a, axis=1, count=-3) -// >>> c -// array([[0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0], -// [0, 0, 0, 1, 0]], dtype=uint8) -// -// >>> p = np.packbits(b, axis=0) -// >>> np.unpackbits(p, axis=0) -// array([[0, 0, 0, 0, 0, 0, 1, 0], -// [0, 0, 0, 0, 0, 1, 1, 1], -// [0, 0, 0, 1, 0, 1, 1, 1], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8) -// >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0])) -// True -// +// >>> np.eye(2, dtype=int) +// array([[1, 0], +// [0, 1]]) +// >>> np.eye(3, k=1) +// array([[0., 1., 0.], +// [0., 0., 1.], +// [0., 0., 0.]]) // // -//go:linkname Unpackbits py.unpackbits -func Unpackbits(a *py.Object, axis *py.Object, count *py.Object, bitorder *py.Object) *py.Object // -// Returns a bool array, where True if input element is real. +//go:linkname Eye py.eye +func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object // -// If element has complex type with zero imaginary part, the return value -// for that element is True. +// Save an array to a binary file in NumPy ``.npy`` format. // // Parameters // ---------- -// x : array_like -// Input array. -// -// Returns -// ------- -// out : ndarray, bool -// Boolean array of same shape as `x`. +// file : file, str, or pathlib.Path +// File or filename to which the data is saved. If file is a file-object, +// then the filename is unchanged. If file is a string or Path, a ``.npy`` +// extension will be appended to the filename if it does not already +// have one. +// arr : array_like +// Array data to be saved. +// allow_pickle : bool, optional +// Allow saving object arrays using Python pickles. Reasons for disallowing +// pickles include security (loading pickled data can execute arbitrary +// code) and portability (pickled objects may not be loadable on different +// Python installations, for example if the stored objects require libraries +// that are not available, and not all pickled data is compatible between +// Python 2 and Python 3). +// Default: True +// fix_imports : bool, optional +// Only useful in forcing objects in object arrays on Python 3 to be +// pickled in a Python 2 compatible way. If `fix_imports` is True, pickle +// will try to map the new Python 3 names to the old module names used in +// Python 2, so that the pickle data stream is readable with Python 2. +// +// See Also +// -------- +// savez : Save several arrays into a ``.npz`` archive +// savetxt, load // // Notes // ----- -// `isreal` may behave unexpectedly for string or object arrays (see examples) +// For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`. // -// See Also -// -------- -// iscomplex -// isrealobj : Return True if x is not a complex type. +// Any data saved to the file is appended to the end of the file. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex) -// >>> np.isreal(a) -// array([False, True, True, True, True, False]) +// >>> from tempfile import TemporaryFile +// >>> outfile = TemporaryFile() // -// The function does not work on string arrays. +// >>> x = np.arange(10) +// >>> np.save(outfile, x) // -// >>> a = np.array([2j, "a"], dtype="U") -// >>> np.isreal(a) # Warns about non-elementwise comparison -// False +// >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file +// >>> np.load(outfile) +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) // -// 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]) +// >>> with open('test.npy', 'wb') as f: +// ... np.save(f, np.array([1, 2])) +// ... np.save(f, np.array([1, 3])) +// >>> with open('test.npy', 'rb') as f: +// ... a = np.load(f) +// ... b = np.load(f) +// >>> print(a, b) +// # [1 2] [1 3] // -// isreal should not be used with object arrays // -// >>> a = np.array([1+2j, 2+1j], dtype=object) -// >>> np.isreal(a) -// array([ True, True]) +//go:linkname Save py.save +func Save(file *py.Object, arr *py.Object, allowPickle *py.Object, fixImports *py.Object) *py.Object // +// Interpret the input as a matrix. // +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. // -//go:linkname Isreal py.isreal -func Isreal(x *py.Object) *py.Object +// Parameters +// ---------- +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. // -// If input is complex with all imaginary parts close to zero, return -// real parts. +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. // -// "Close to zero" is defined as `tol` * (machine epsilon of the type for -// `a`). +// Examples +// -------- +// >>> x = np.array([[1, 2], [3, 4]]) +// +// >>> m = np.asmatrix(x) +// +// >>> x[0,0] = 5 +// +// >>> m +// matrix([[5, 2], +// [3, 4]]) +// +// +// +//go:linkname Mat py.mat +func Mat(data *py.Object, dtype *py.Object) *py.Object +// +// Return a new array of given shape and type, filled with `fill_value`. // // Parameters // ---------- -// a : array_like -// Input array. -// tol : float -// Tolerance in machine epsilons for the complex part of the elements -// in the array. If the tolerance is <=1, then the absolute tolerance -// is used. +// shape : int or sequence of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// fill_value : scalar or array_like +// Fill value. +// dtype : data-type, optional +// The desired data-type for the array The default, None, means +// ``np.array(fill_value).dtype``. +// order : {'C', 'F'}, optional +// Whether to store multidimensional data in C- or Fortran-contiguous +// (row- or column-wise) order in memory. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // // Returns // ------- // out : ndarray -// If `a` is real, the type of `a` is used for the output. If `a` -// has complex elements, the returned type is float. +// Array of `fill_value` with the given shape, dtype, and order. // // See Also // -------- -// real, imag, angle -// -// Notes -// ----- -// Machine epsilon varies from machine to machine and between data types -// but Python floats on most platforms have a machine epsilon equal to -// 2.2204460492503131e-16. You can use 'np.finfo(float).eps' to print -// out the machine epsilon for floats. +// full_like : Return a new array with shape of input filled with value. +// empty : Return a new uninitialized array. +// ones : Return a new array setting values to one. +// zeros : Return a new array setting values to zero. // // Examples // -------- -// >>> import numpy as np -// >>> np.finfo(float).eps -// 2.2204460492503131e-16 # may vary +// >>> np.full((2, 2), np.inf) +// array([[inf, inf], +// [inf, inf]]) +// >>> np.full((2, 2), 10) +// array([[10, 10], +// [10, 10]]) // -// >>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000) -// array([2.1, 5.2]) -// >>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000) -// array([2.1+4.e-13j, 5.2 + 3e-15j]) +// >>> np.full((2, 2), [1, 2]) +// array([[1, 2], +// [1, 2]]) // // // -//go:linkname RealIfClose py.real_if_close -func RealIfClose(a *py.Object, tol *py.Object) *py.Object -// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Full py.full +func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Convert angles from degrees to radians. +// Return the complex conjugate, element-wise. +// +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. // // Parameters // ---------- // x : array_like -// Input array in degrees. +// Input value. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -8041,1287 +6816,1456 @@ func RealIfClose(a *py.Object, tol *py.Object) *py.Object // Returns // ------- // y : ndarray -// The corresponding radian values. +// The complex conjugate of `x`, with same dtype as `y`. // This is a scalar if `x` is a scalar. // -// See Also +// Notes +// ----- +// `conj` is an alias for `conjugate`: +// +// >>> np.conj is np.conjugate +// True +// +// Examples // -------- -// deg2rad : equivalent function +// >>> np.conjugate(1+2j) +// (1-2j) +// +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) +// +//go:linkname Conjugate py.conjugate +func Conjugate(x *py.Object, out *py.Object) *py.Object +// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Subtract arguments, element-wise. +// +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays to be subtracted from each other. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// The difference of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Notes +// ----- +// Equivalent to ``x1 - x2`` in terms of array broadcasting. // // Examples // -------- -// >>> import numpy as np +// >>> np.subtract(1.0, 4.0) +// -3.0 // -// Convert a degree array to radians +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> np.subtract(x1, x2) +// array([[ 0., 0., 0.], +// [ 3., 3., 3.], +// [ 6., 6., 6.]]) // -// >>> deg = np.arange(12.) * 30. -// >>> np.radians(deg) -// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , -// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, -// 5.23598776, 5.75958653]) +// The ``-`` operator can be used as a shorthand for ``np.subtract`` on +// ndarrays. // -// >>> out = np.zeros((deg.shape)) -// >>> ret = np.radians(deg, out) -// >>> ret is out -// True +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = np.arange(3.0) +// >>> x1 - x2 +// array([[0., 0., 0.], +// [3., 3., 3.], +// [6., 6., 6.]]) // -//go:linkname Radians py.radians -func Radians(x *py.Object, out *py.Object) *py.Object +//go:linkname Subtract py.subtract +func Subtract(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Repeat each element of an array after themselves +// bincount(x, /, weights=None, minlength=0) +// +// Count number of occurrences of each value in array of non-negative ints. +// +// The number of bins (of size 1) is one larger than the largest value in +// `x`. If `minlength` is specified, there will be at least this number +// of bins in the output array (though it will be longer if necessary, +// depending on the contents of `x`). +// Each bin gives the number of occurrences of its index value in `x`. +// If `weights` is specified the input array is weighted by it, i.e. if a +// value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead +// of ``out[n] += 1``. // // Parameters // ---------- -// a : array_like +// x : array_like, 1 dimension, nonnegative ints // Input array. -// repeats : int or array of ints -// The number of repetitions for each element. `repeats` is broadcasted -// to fit the shape of the given axis. -// axis : int, optional -// The axis along which to repeat values. By default, use the -// flattened input array, and return a flat output array. +// weights : array_like, optional +// Weights, array of the same shape as `x`. +// minlength : int, optional +// A minimum number of bins for the output array. +// +// .. versionadded:: 1.6.0 // // Returns // ------- -// repeated_array : ndarray -// Output array which has the same shape as `a`, except along -// the given axis. -// -// See Also +// out : ndarray of ints +// The result of binning the input array. +// The length of `out` is equal to ``np.amax(x)+1``. +// +// Raises +// ------ +// ValueError +// If the input is not 1-dimensional, or contains elements with negative +// values, or if `minlength` is negative. +// TypeError +// If the type of the input is float or complex. +// +// See Also // -------- -// tile : Tile an array. -// unique : Find the unique elements of an array. +// histogram, digitize, unique // // Examples // -------- -// >>> import numpy as np -// >>> np.repeat(3, 4) -// array([3, 3, 3, 3]) -// >>> x = np.array([[1,2],[3,4]]) -// >>> np.repeat(x, 2) -// array([1, 1, 2, 2, 3, 3, 4, 4]) -// >>> np.repeat(x, 3, axis=1) -// array([[1, 1, 1, 2, 2, 2], -// [3, 3, 3, 4, 4, 4]]) -// >>> np.repeat(x, [1, 2], axis=0) -// array([[1, 2], -// [3, 4], -// [3, 4]]) -// -// -// -//go:linkname Repeat py.repeat -func Repeat(a *py.Object, repeats *py.Object, axis *py.Object) *py.Object -// -// Show libraries and system information on which NumPy was built -// and is being used -// -// Parameters -// ---------- -// mode : {`'stdout'`, `'dicts'`}, optional. -// Indicates how to display the config information. -// `'stdout'` prints to console, `'dicts'` returns a dictionary -// of the configuration. -// -// Returns -// ------- -// out : {`dict`, `None`} -// If mode is `'dicts'`, a dict is returned, else None +// >>> np.bincount(np.arange(5)) +// array([1, 1, 1, 1, 1]) +// >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) +// array([1, 3, 1, 1, 0, 0, 0, 1]) // -// See Also -// -------- -// get_include : Returns the directory containing NumPy C -// header files. +// >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) +// >>> np.bincount(x).size == np.amax(x)+1 +// True // -// Notes -// ----- -// 1. The `'stdout'` mode will give more readable -// output if ``pyyaml`` is installed +// The input array needs to be of integer dtype, otherwise a +// TypeError is raised: // +// >>> np.bincount(np.arange(5, dtype=float)) +// Traceback (most recent call last): +// ... +// TypeError: Cannot cast array data from dtype('float64') to dtype('int64') +// according to the rule 'safe' // +// A possible use of ``bincount`` is to perform sums over +// variable-size chunks of an array, using the ``weights`` keyword. // -//go:linkname ShowConfig py.show_config -func ShowConfig(mode *py.Object) *py.Object +// >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights +// >>> x = np.array([0, 1, 1, 2, 2, 2]) +// >>> np.bincount(x, weights=w) +// array([ 0.3, 0.7, 1.1]) // -// Cross-correlation of two 1-dimensional sequences. // -// This function computes the correlation as generally defined in signal -// processing texts [1]_: // -// .. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n +//go:linkname Bincount py.bincount +func Bincount(x *py.Object, weights *py.Object, minlength *py.Object) *py.Object // -// with a and v sequences being zero-padded where necessary and -// :math:`\overline v` denoting complex conjugation. +// The differences between consecutive elements of an array. // // Parameters // ---------- -// a, v : array_like -// Input sequences. -// mode : {'valid', 'same', 'full'}, optional -// Refer to the `convolve` docstring. Note that the default -// is 'valid', unlike `convolve`, which uses 'full'. +// ary : array_like +// If necessary, will be flattened before the differences are taken. +// to_end : array_like, optional +// Number(s) to append at the end of the returned differences. +// to_begin : array_like, optional +// Number(s) to prepend at the beginning of the returned differences. // // Returns // ------- -// out : ndarray -// Discrete cross-correlation of `a` and `v`. +// ediff1d : ndarray +// The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``. // // See Also // -------- -// convolve : Discrete, linear convolution of two one-dimensional sequences. -// scipy.signal.correlate : uses FFT which has superior performance -// on large arrays. +// diff, gradient // // Notes // ----- -// The definition of correlation above is not unique and sometimes -// correlation may be defined differently. Another common definition is [1]_: -// -// .. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+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 be preferable. -// -// References -// ---------- -// .. [1] Wikipedia, "Cross-correlation", -// https://en.wikipedia.org/wiki/Cross-correlation +// When applied to masked arrays, this function drops the mask information +// if the `to_begin` and/or `to_end` parameters are used. // // Examples // -------- -// >>> import numpy as np -// >>> np.correlate([1, 2, 3], [0, 1, 0.5]) -// array([3.5]) -// >>> np.correlate([1, 2, 3], [0, 1, 0.5], "same") -// array([2. , 3.5, 3. ]) -// >>> np.correlate([1, 2, 3], [0, 1, 0.5], "full") -// array([0.5, 2. , 3.5, 3. , 0. ]) +// >>> x = np.array([1, 2, 4, 7, 0]) +// >>> np.ediff1d(x) +// array([ 1, 2, 3, -7]) // -// Using complex sequences: +// >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) +// array([-99, 1, 2, ..., -7, 88, 99]) // -// >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full') -// array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ]) +// The returned array is always 1D. // -// Note that you get the time reversed, complex conjugated result -// (:math:`\overline{c_{-k}}`) when the two input sequences a and v change -// places: +// >>> y = [[1, 2, 4], [1, 6, 24]] +// >>> np.ediff1d(y) +// array([ 1, 2, -3, 5, 18]) // -// >>> 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]) // // +//go:linkname Ediff1d py.ediff1d +func Ediff1d(ary *py.Object, toEnd *py.Object, toBegin *py.Object) *py.Object // -//go:linkname Correlate py.correlate -func Correlate(a *py.Object, v *py.Object, mode *py.Object) *py.Object -//go:linkname Matmul py.matmul -func Matmul(__llgo_va_list ...interface{}) *py.Object +// Compute the standard deviation along the specified axis, while +// ignoring NaNs. // -// Return the minimum of an array or minimum along an axis. +// Returns the standard deviation, a measure of the spread of a +// distribution, of the non-NaN array elements. The standard deviation is +// computed for the flattened array by default, otherwise over the +// specified axis. +// +// For all-NaN slices or slices with zero degrees of freedom, NaN is +// returned and a `RuntimeWarning` is raised. +// +// .. versionadded:: 1.8.0 // // Parameters // ---------- // a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to operate. By default, flattened input is -// used. -// -// 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. +// Calculate the standard deviation of the non-NaN values. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the standard deviation is computed. The default is +// to compute the standard deviation of the flattened array. +// dtype : dtype, optional +// Type to use in computing the standard deviation. For arrays of +// integer type the default is float64, for arrays of float types it +// is the same as the array type. // out : ndarray, optional -// Alternative output array in which to place the result. Must -// be of the same shape and buffer length as the expected output. -// See :ref:`ufuncs-output-type` for more details. +// Alternative output array in which to place the result. It must have +// the same shape as the expected output but the type (of the +// calculated values) will be cast if necessary. +// ddof : int, optional +// Means Delta Degrees of Freedom. The divisor used in calculations +// is ``N - ddof``, where ``N`` represents the number of non-NaN +// elements. By default `ddof` is zero. // // 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the ``min`` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// initial : scalar, optional -// The maximum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. +// the result will broadcast correctly against the original `a`. // +// If this value is anything but the default it is passed through +// as-is to the relevant functions of the sub-classes. If these +// functions do not have a `keepdims` kwarg, a RuntimeError will +// be raised. // where : array_like of bool, optional -// Elements to compare for the minimum. See `~numpy.ufunc.reduce` -// for details. +// Elements to include in the standard deviation. +// See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.22.0 // // Returns // ------- -// min : ndarray or scalar -// Minimum of `a`. If `axis` is None, the result is a scalar value. -// 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)``. +// standard_deviation : ndarray, see dtype parameter above. +// If `out` is None, return a new array containing the standard +// deviation, otherwise return a reference to the output array. If +// ddof is >= the number of non-NaN elements in a slice or the slice +// contains only NaNs, then the result for that slice is NaN. // // See Also // -------- -// amax : -// The maximum value of an array along a given axis, propagating any NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignoring any NaNs. -// minimum : -// Element-wise minimum of two arrays, propagating any NaNs. -// fmin : -// Element-wise minimum of two arrays, ignoring any NaNs. -// argmin : -// Return the indices of the minimum values. -// -// nanmax, maximum, fmax +// var, mean, std +// nanvar, nanmean +// :ref:`ufuncs-output-type` // // Notes // ----- -// NaN values are propagated, that is if at least one item is NaN, the -// corresponding min value will be NaN as well. To ignore NaN values -// (MATLAB behavior), please use nanmin. +// The standard deviation is the square root of the average of the squared +// deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``. // -// Don't use `~numpy.min` for element-wise comparison of 2 arrays; when -// ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than -// ``min(a, axis=0)``. +// The average squared deviation is normally calculated as +// ``x.sum() / N``, where ``N = len(x)``. If, however, `ddof` is +// specified, the divisor ``N - ddof`` is used instead. In standard +// statistical practice, ``ddof=1`` provides an unbiased estimator of the +// variance of the infinite population. ``ddof=0`` provides a maximum +// likelihood estimate of the variance for normally distributed variables. +// The standard deviation computed in this function is the square root of +// the estimated variance, so even with ``ddof=1``, it will not be an +// unbiased estimate of the standard deviation per se. +// +// Note that, for complex numbers, `std` takes the absolute value before +// squaring, so that the result is always real and nonnegative. +// +// For floating-point input, the *std* is computed using the same +// precision the input has. Depending on the input data, this can cause +// the results to be inaccurate, especially for float32 (see example +// below). Specifying a higher-accuracy accumulator using the `dtype` +// keyword can alleviate this issue. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.arange(4).reshape((2,2)) -// >>> a -// array([[0, 1], -// [2, 3]]) -// >>> np.min(a) # Minimum of the flattened array -// 0 -// >>> np.min(a, axis=0) # Minima along the first axis -// array([0, 1]) -// >>> np.min(a, axis=1) # Minima along the second axis -// array([0, 2]) -// >>> np.min(a, where=[False, True], initial=10, axis=0) -// array([10, 1]) -// -// >>> b = np.arange(5, dtype=float) -// >>> b[2] = np.nan -// >>> np.min(b) -// np.float64(nan) -// >>> np.min(b, where=~np.isnan(b), initial=10) -// 0.0 -// >>> np.nanmin(b) -// 0.0 -// -// >>> np.min([[-50], [10]], axis=-1, initial=0) -// array([-50, 0]) +// >>> a = np.array([[1, np.nan], [3, 4]]) +// >>> np.nanstd(a) +// 1.247219128924647 +// >>> np.nanstd(a, axis=0) +// array([1., 0.]) +// >>> np.nanstd(a, axis=1) +// array([0., 0.5]) # may vary // -// Notice that the initial value is used as one of the elements for which the -// minimum is determined, unlike for the default argument Python's max -// function, which is only used for empty iterables. // -// Notice that this isn't the same as Python's ``default`` argument. // -// >>> np.min([6], initial=5) -// 5 -// >>> min([6], default=5) -// 6 +//go:linkname Nanstd py.nanstd +func Nanstd(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object // +// Compute the multidimensional histogram of some data. // -//go:linkname Min py.min -func Min(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// Parameters +// ---------- +// sample : (N, D) array, or (N, D) array_like +// The data to be histogrammed. // -// Returns the discrete, linear convolution of two one-dimensional sequences. +// Note the unusual interpretation of sample when an array_like: // -// The convolution operator is often seen in signal processing, where it -// models the effect of a linear time-invariant system on a signal [1]_. In -// probability theory, the sum of two independent random variables is -// distributed according to the convolution of their individual -// distributions. +// * When an array, each row is a coordinate in a D-dimensional space - +// such as ``histogramdd(np.array([p1, p2, p3]))``. +// * When an array_like, each element is the list of values for single +// coordinate - such as ``histogramdd((X, Y, Z))``. // -// If `v` is longer than `a`, the arrays are swapped before computation. +// The first form should be preferred. // -// Parameters -// ---------- -// a : (N,) array_like -// First one-dimensional input array. -// v : (M,) array_like -// Second one-dimensional input array. -// mode : {'full', 'valid', 'same'}, optional -// 'full': -// By default, mode is 'full'. This returns the convolution -// at each point of overlap, with an output shape of (N+M-1,). At -// the end-points of the convolution, the signals do not overlap -// completely, and boundary effects may be seen. +// bins : sequence or int, optional +// The bin specification: // -// 'same': -// Mode 'same' returns output of length ``max(M, N)``. Boundary -// effects are still visible. +// * A sequence of arrays describing the monotonically increasing bin +// edges along each dimension. +// * The number of bins for each dimension (nx, ny, ... =bins) +// * The number of bins for all dimensions (nx=ny=...=bins). // -// 'valid': -// Mode 'valid' returns output of length -// ``max(M, N) - min(M, N) + 1``. The convolution product is only given -// for points where the signals overlap completely. Values outside -// the signal boundary have no effect. +// range : sequence, optional +// A sequence of length D, each an optional (lower, upper) tuple giving +// the outer bin edges to be used if the edges are not given explicitly in +// `bins`. +// An entry of None in the sequence results in the minimum and maximum +// values being used for the corresponding dimension. +// The default, None, is equivalent to passing a tuple of D None values. +// density : bool, optional +// 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``. +// 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 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 // ------- -// out : ndarray -// Discrete, linear convolution of `a` and `v`. +// H : ndarray +// 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. // // See Also // -------- -// scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier -// Transform. -// scipy.linalg.toeplitz : Used to construct the convolution operator. -// polymul : Polynomial multiplication. Same output as convolve, but also -// accepts poly1d objects as input. +// histogram: 1-D histogram +// histogram2d: 2-D histogram // -// Notes -// ----- -// The discrete convolution operation is defined as +// Examples +// -------- +// >>> r = np.random.randn(100,3) +// >>> H, edges = np.histogramdd(r, bins = (5, 8, 4)) +// >>> H.shape, edges[0].size, edges[1].size, edges[2].size +// ((5, 8, 4), 6, 9, 5) // -// .. 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 -// domain, after appropriate padding (padding is necessary to prevent -// circular convolution). Since multiplication is more efficient (faster) -// than convolution, the function `scipy.signal.fftconvolve` exploits the -// FFT to calculate the convolution of large data-sets. // -// References +//go:linkname Histogramdd py.histogramdd +func Histogramdd(sample *py.Object, bins *py.Object, Range *py.Object, density *py.Object, weights *py.Object) *py.Object +// +// Interpret the input as a matrix. +// +// Unlike `matrix`, `asmatrix` does not make a copy if the input is already +// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. +// +// Parameters // ---------- -// .. [1] Wikipedia, "Convolution", -// https://en.wikipedia.org/wiki/Convolution +// data : array_like +// Input data. +// dtype : data-type +// Data-type of the output matrix. +// +// Returns +// ------- +// mat : matrix +// `data` interpreted as a matrix. // // Examples // -------- -// Note how the convolution operator flips the second array -// before "sliding" the two across one another: -// -// >>> import numpy as np -// >>> np.convolve([1, 2, 3], [0, 1, 0.5]) -// array([0. , 1. , 2.5, 4. , 1.5]) -// -// Only return the middle values of the convolution. -// Contains boundary effects, where zeros are taken -// into account: +// >>> x = np.array([[1, 2], [3, 4]]) // -// >>> np.convolve([1,2,3],[0,1,0.5], 'same') -// array([1. , 2.5, 4. ]) +// >>> m = np.asmatrix(x) // -// The two arrays are of the same length, so there -// is only one position where they completely overlap: +// >>> x[0,0] = 5 // -// >>> np.convolve([1,2,3],[0,1,0.5], 'valid') -// array([2.5]) +// >>> m +// matrix([[5, 2], +// [3, 4]]) // // // -//go:linkname Convolve py.convolve -func Convolve(a *py.Object, v *py.Object, mode *py.Object) *py.Object -// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Asmatrix py.asmatrix +func Asmatrix(data *py.Object, dtype *py.Object) *py.Object +// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) // -// Return the largest integer smaller or equal to the division of the inputs. -// It is equivalent to the Python ``//`` operator and pairs with the -// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` -// up to roundoff. +// Matrix product of two arrays. // // Parameters // ---------- -// x1 : array_like -// Numerator. -// x2 : array_like -// Denominator. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional +// x1, x2 : array_like +// Input arrays, scalars not allowed. +// out : ndarray, optional // A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. +// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not +// provided or None, a freshly-allocated array is returned. // **kwargs // For other keyword-only arguments, see the // :ref:`ufunc docs `. // +// .. versionadded:: 1.16 +// Now handles ufunc kwargs +// // Returns // ------- // y : ndarray -// y = floor(`x1`/`x2`) -// This is a scalar if both `x1` and `x2` are scalars. +// The matrix product of the inputs. +// This is a scalar only when both x1, x2 are 1-d vectors. +// +// Raises +// ------ +// ValueError +// If the last dimension of `x1` is not the same size as +// the second-to-last dimension of `x2`. +// +// If a scalar value is passed in. // // See Also // -------- -// remainder : Remainder complementary to floor_divide. -// divmod : Simultaneous floor division and remainder. -// divide : Standard division. -// floor : Round a number to the nearest integer toward minus infinity. -// ceil : Round a number to the nearest integer toward infinity. +// vdot : Complex-conjugating dot product. +// tensordot : Sum products over arbitrary axes. +// einsum : Einstein summation convention. +// dot : alternative matrix product with different broadcasting rules. +// +// Notes +// ----- +// +// The behavior depends on the arguments in the following way. +// +// - If both arguments are 2-D they are multiplied like conventional +// matrices. +// - If either argument is N-D, N > 2, it is treated as a stack of +// matrices residing in the last two indexes and broadcast accordingly. +// - If the first argument is 1-D, it is promoted to a matrix by +// prepending a 1 to its dimensions. After matrix multiplication +// the prepended 1 is removed. +// - If the second argument is 1-D, it is promoted to a matrix by +// appending a 1 to its dimensions. After matrix multiplication +// the appended 1 is removed. +// +// ``matmul`` differs from ``dot`` in two important ways: +// +// - Multiplication by scalars is not allowed, use ``*`` instead. +// - Stacks of matrices are broadcast together as if the matrices +// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: +// +// >>> a = np.ones([9, 5, 7, 4]) +// >>> c = np.ones([9, 5, 4, 3]) +// >>> np.dot(a, c).shape +// (9, 5, 7, 9, 5, 3) +// >>> np.matmul(a, c).shape +// (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`. +// +// It uses an optimized BLAS library when possible (see `numpy.linalg`). // // Examples // -------- -// >>> import numpy as np -// >>> np.floor_divide(7,3) -// 2 -// >>> np.floor_divide([1., 2., 3., 4.], 2.5) -// array([ 0., 0., 1., 1.]) +// For 2-D arrays it is the matrix product: // -// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` -// on ndarrays. +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([[4, 1], +// ... [2, 2]]) +// >>> np.matmul(a, b) +// array([[4, 1], +// [2, 2]]) // -// >>> x1 = np.array([1., 2., 3., 4.]) -// >>> x1 // 2.5 -// array([0., 0., 1., 1.]) +// For 2-D mixed with 1-D, the result is the usual. // -//go:linkname FloorDivide py.floor_divide -func FloorDivide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> a = np.array([[1, 0], +// ... [0, 1]]) +// >>> b = np.array([1, 2]) +// >>> np.matmul(a, b) +// array([1, 2]) +// >>> np.matmul(b, a) +// array([1, 2]) // -// Element-wise minimum of array elements. // -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. +// Broadcasting is conventional for stacks of arrays // -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) +// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) +// >>> np.matmul(a,b).shape +// (2, 2, 2) +// >>> np.matmul(a, b)[0, 1, 1] +// 98 +// >>> sum(a[0, 1, :] * b[0 , :, 1]) +// 98 // -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. +// Vector, vector returns the scalar inner product, but neither argument +// is complex-conjugated: // -// See Also -// -------- -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. +// >>> np.matmul([2j, 3j], [2j, 3j]) +// (-13+0j) // -// maximum, amax, nanmax +// Scalar multiplication raises an error. // -// Notes -// ----- -// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// >>> np.matmul([1,2], 3) +// Traceback (most recent call last): +// ... +// ValueError: matmul: Input operand 1 does not have enough dimensions ... // -// Examples -// -------- -// >>> import numpy as np -// >>> np.fmin([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) +// The ``@`` operator can be used as a shorthand for ``np.matmul`` on +// ndarrays. // -// >>> np.fmin(np.eye(2), [0.5, 2]) -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) +// >>> x1 = np.array([2j, 3j]) +// >>> x2 = np.array([2j, 3j]) +// >>> x1 @ x2 +// (-13+0j) // -// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) +// .. versionadded:: 1.10.0 // -//go:linkname Fmin py.fmin -func Fmin(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +//go:linkname Matmul py.matmul +func Matmul(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Set how floating-point errors are handled. +// Check if all elements of input array are true. // -// Note that operations on integer scalar types (such as `int16`) are -// handled like floating point, and are affected by these settings. +// .. deprecated:: 1.25.0 +// ``alltrue`` is deprecated as of NumPy 1.25.0, and will be +// removed in NumPy 2.0. Please use `all` instead. // -// Parameters -// ---------- -// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Set treatment for all types of floating-point errors at once: +// See Also +// -------- +// numpy.all : Equivalent function; see for details. // -// - ignore: Take no action when the exception occurs. -// - warn: Print a :exc:`RuntimeWarning` (via the Python `warnings` -// module). -// - raise: Raise a :exc:`FloatingPointError`. -// - call: Call a function specified using the `seterrcall` function. -// - print: Print a warning directly to ``stdout``. -// - log: Record error in a Log object specified by `seterrcall`. // -// The default is not to change the current behavior. -// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for division by zero. -// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point overflow. -// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point underflow. -// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for invalid floating-point operation. +//go:linkname Alltrue py.alltrue +func Alltrue(__llgo_va_list ...interface{}) *py.Object +// +// is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None) +// +// Calculates which of the given dates are valid days, and which are not. +// +// .. versionadded:: 1.7.0 +// +// Parameters +// ---------- +// dates : array_like of datetime64[D] +// The array of dates to process. +// weekmask : str or array_like of bool, optional +// A seven-element array indicating which of Monday through Sunday are +// valid days. May be specified as a length-seven list or array, like +// [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string +// like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for +// weekdays, optionally separated by white space. Valid abbreviations +// are: Mon Tue Wed Thu Fri Sat Sun +// holidays : array_like of datetime64[D], optional +// An array of dates to consider as invalid dates. They may be +// specified in any order, and NaT (not-a-time) dates are ignored. +// This list is saved in a normalized form that is suited for +// fast calculations of valid days. +// busdaycal : busdaycalendar, optional +// A `busdaycalendar` object which specifies the valid days. If this +// parameter is provided, neither weekmask nor holidays may be +// provided. +// out : array of bool, optional +// If provided, this array is filled with the result. // // Returns // ------- -// old_settings : dict -// Dictionary containing the old settings. +// out : array of bool +// An array with the same shape as ``dates``, containing True for +// each valid day, and False for each invalid day. // -// See also +// See Also // -------- -// seterrcall : Set a callback function for the 'call' mode. -// geterr, geterrcall, errstate +// busdaycalendar : An object that specifies a custom set of valid days. +// busday_offset : Applies an offset counted in valid days. +// busday_count : Counts how many valid days are in a half-open date range. // -// Notes -// ----- -// The floating-point exceptions are defined in the IEEE 754 standard [1]_: +// Examples +// -------- +// >>> # The weekdays are Friday, Saturday, and Monday +// ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'], +// ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) +// array([False, False, True]) // -// - Division by zero: infinite result obtained from finite numbers. -// - Overflow: result too large to be expressed. -// - Underflow: result so close to zero that some precision -// was lost. -// - Invalid operation: result is not an expressible number, typically -// indicates that a NaN was produced. // -// .. [1] https://en.wikipedia.org/wiki/IEEE_754 +//go:linkname IsBusday py.is_busday +func IsBusday(dates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object +// +// Return a string representation of the data in an array. +// +// The data in the array is returned as a single string. This function is +// similar to `array_repr`, the difference being that `array_repr` also +// returns information on the kind of array and its data type. +// +// Parameters +// ---------- +// a : ndarray +// Input array. +// max_line_width : int, optional +// Inserts newlines if text is longer than `max_line_width`. +// Defaults to ``numpy.get_printoptions()['linewidth']``. +// precision : int, optional +// Floating point precision. +// Defaults to ``numpy.get_printoptions()['precision']``. +// suppress_small : bool, optional +// Represent numbers "very close" to zero as zero; default is False. +// Very close is defined by precision: if the precision is 8, e.g., +// numbers smaller (in absolute value) than 5e-9 are represented as +// zero. +// Defaults to ``numpy.get_printoptions()['suppress']``. +// +// See Also +// -------- +// array2string, array_repr, set_printoptions // // Examples // -------- -// >>> import numpy as np -// >>> orig_settings = np.seterr(all='ignore') # seterr to known value -// >>> np.int16(32000) * np.int16(3) -// np.int16(30464) -// >>> np.seterr(over='raise') -// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} -// >>> old_settings = np.seterr(all='warn', over='raise') -// >>> np.int16(32000) * np.int16(3) -// Traceback (most recent call last): -// File "", line 1, in -// FloatingPointError: overflow encountered in scalar multiply +// >>> np.array_str(np.arange(3)) +// '[0 1 2]' // -// >>> old_settings = np.seterr(all='print') -// >>> np.geterr() -// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} -// >>> np.int16(32000) * np.int16(3) -// np.int16(30464) -// >>> np.seterr(**orig_settings) # restore original -// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} // // +//go:linkname ArrayStr py.array_str +func ArrayStr(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object // -//go:linkname Seterr py.seterr -func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object +// Expand the shape of an array. // -// Return the angle of the complex argument. +// Insert a new axis that will appear at the `axis` position in the expanded +// array shape. // // Parameters // ---------- -// z : array_like -// A complex number or sequence of complex numbers. -// deg : bool, optional -// Return angle in degrees if True, radians if False (default). +// a : array_like +// Input array. +// axis : int or tuple of ints +// Position in the expanded axes where the new axis (or axes) is placed. +// +// .. deprecated:: 1.13.0 +// Passing an axis where ``axis > a.ndim`` will be treated as +// ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will +// be treated as ``axis == 0``. This behavior is deprecated. +// +// .. versionchanged:: 1.18.0 +// A tuple of axes is now supported. Out of range axes as +// described above are now forbidden and raise an `AxisError`. // // Returns // ------- -// angle : ndarray or scalar -// The counterclockwise angle from the positive real axis on the complex -// plane in the range ``(-pi, pi]``, with dtype as numpy.float64. +// result : ndarray +// View of `a` with the number of dimensions increased. // // See Also // -------- -// arctan2 -// absolute -// -// Notes -// ----- -// This function passes the imaginary and real parts of the argument to -// `arctan2` to compute the result; consequently, it follows the convention -// of `arctan2` when the magnitude of the argument is zero. See example. +// squeeze : The inverse operation, removing singleton dimensions +// reshape : Insert, remove, and combine dimensions, and resize existing ones +// doc.indexing, atleast_1d, atleast_2d, atleast_3d // // Examples // -------- -// >>> import numpy as np -// >>> np.angle([1.0, 1.0j, 1+1j]) # in radians -// array([ 0. , 1.57079633, 0.78539816]) # may vary -// >>> np.angle(1+1j, deg=True) # in degrees -// 45.0 -// >>> np.angle([0., -0., complex(0., -0.), complex(-0., -0.)]) # convention -// array([ 0. , 3.14159265, -0. , -3.14159265]) +// >>> x = np.array([1, 2]) +// >>> x.shape +// (2,) +// +// The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``: // +// >>> y = np.expand_dims(x, axis=0) +// >>> y +// array([[1, 2]]) +// >>> y.shape +// (1, 2) // +// The following is equivalent to ``x[:, np.newaxis]``: // -//go:linkname Angle py.angle -func Angle(z *py.Object, deg *py.Object) *py.Object +// >>> y = np.expand_dims(x, axis=1) +// >>> y +// array([[1], +// [2]]) +// >>> y.shape +// (2, 1) // -// Compute the q-th percentile of the data along the specified axis. +// ``axis`` may also be a tuple: // -// Returns the q-th percentile(s) of the array elements. +// >>> y = np.expand_dims(x, axis=(0, 1)) +// >>> y +// array([[[1, 2]]]) +// +// >>> y = np.expand_dims(x, axis=(2, 0)) +// >>> y +// array([[[1], +// [2]]]) +// +// Note that some examples may use ``None`` instead of ``np.newaxis``. These +// are the same objects: +// +// >>> np.newaxis is None +// True +// +// +// +//go:linkname ExpandDims py.expand_dims +func ExpandDims(a *py.Object, axis *py.Object) *py.Object +// +// Return an array of ones with the same shape and type as a given array. // // Parameters // ---------- -// a : array_like of real numbers -// Input array or object that can be converted to an array. -// q : array_like of float -// Percentage or sequence of percentages for the percentiles to compute. -// Values must be between 0 and 100 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the percentiles are computed. The -// default is to compute the percentile(s) along a flattened -// version of the array. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by intermediate -// calculations, to save memory. In this case, the contents of the input -// `a` after this function completes is undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// percentile. There are many different methods, some unique to NumPy. -// See the notes for explanation. The options sorted by their R type -// as summarized in the H&F paper [1]_ are: +// a : array_like +// The shape and data-type of `a` define these same attributes of +// the returned array. +// dtype : data-type, optional +// Overrides the data type of the result. // -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' +// .. versionadded:: 1.6.0 +// order : {'C', 'F', 'A', or 'K'}, optional +// Overrides the memory layout of the result. 'C' means C-order, +// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, +// 'C' otherwise. 'K' means match the layout of `a` as closely +// as possible. // -// The first three methods are discontinuous. NumPy further defines the -// following discontinuous variations of the default 'linear' (7.) option: +// .. versionadded:: 1.6.0 +// subok : bool, optional. +// If True, then the newly created array will use the sub-class +// type of `a`, otherwise it will be a base-class array. Defaults +// to True. +// shape : int or sequence of ints, optional. +// Overrides the shape of the result. If order='K' and the number of +// dimensions is unchanged, will try to keep order, otherwise, +// order='C' is implied. // -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' +// .. versionadded:: 1.17.0 // -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. +// Returns +// ------- +// out : ndarray +// Array of ones with the same shape and type as `a`. // -// 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 array `a`. +// See Also +// -------- +// empty_like : Return an empty array with shape and type of input. +// zeros_like : Return an array of zeros with shape and type of input. +// full_like : Return a new array with shape of input filled with value. +// ones : Return a new array setting values to one. // -// weights : array_like, optional -// An array of weights associated with the values in `a`. Each value in -// `a` contributes to the percentile according to its associated weight. -// The weights array can either be 1-D (in which case its length must be -// the size of `a` along the given axis) or of the same shape as `a`. -// If `weights=None`, then all data in `a` are assumed to have a -// weight equal to one. -// Only `method="inverted_cdf"` supports weights. -// See the notes for more details. +// Examples +// -------- +// >>> x = np.arange(6) +// >>> x = x.reshape((2, 3)) +// >>> x +// array([[0, 1, 2], +// [3, 4, 5]]) +// >>> np.ones_like(x) +// array([[1, 1, 1], +// [1, 1, 1]]) // -// .. versionadded:: 2.0.0 +// >>> y = np.arange(3, dtype=float) +// >>> y +// array([0., 1., 2.]) +// >>> np.ones_like(y) +// array([1., 1., 1.]) // -// interpolation : str, optional -// Deprecated name for the method keyword argument. // -// .. deprecated:: 1.22.0 +// +//go:linkname OnesLike py.ones_like +func OnesLike(__llgo_va_list ...interface{}) *py.Object +// +// Return True if x is a not complex type or an array of complex numbers. +// +// The type of the input is checked, not the value. So even if the input +// has an imaginary part equal to zero, `isrealobj` evaluates to False +// if the data type is complex. +// +// Parameters +// ---------- +// x : any +// The input can be of any type and shape. // // Returns // ------- -// percentile : scalar or ndarray -// If `q` is a single percentile and `axis=None`, then the result -// is a scalar. If multiple percentiles are given, first axis of -// the result corresponds to the percentiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the -// same as that of the input. If `out` is specified, that array is -// returned instead. +// y : bool +// The return value, False if `x` is of a complex type. // // See Also // -------- -// mean -// median : equivalent to ``percentile(..., 50)`` -// nanpercentile -// quantile : equivalent to percentile, except q in the range [0, 1]. +// iscomplexobj, isreal // // Notes // ----- -// The behavior of `numpy.percentile` with percentage `q` is -// that of `numpy.quantile` with argument ``q/100``. -// For more information, please see `numpy.quantile`. +// The function is only meant for arrays with numerical values but it +// accepts all other objects. Since it assumes array input, the return +// value of other objects may be True. +// +// >>> np.isrealobj('A string') +// True +// >>> np.isrealobj(False) +// True +// >>> np.isrealobj(None) +// True // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) -// >>> a -// array([[10, 7, 4], -// [ 3, 2, 1]]) -// >>> np.percentile(a, 50) -// 3.5 -// >>> np.percentile(a, 50, axis=0) -// array([6.5, 4.5, 2.5]) -// >>> np.percentile(a, 50, axis=1) -// array([7., 2.]) -// >>> np.percentile(a, 50, axis=1, keepdims=True) -// array([[7.], -// [2.]]) +// >>> np.isrealobj(1) +// True +// >>> np.isrealobj(1+0j) +// False +// >>> np.isrealobj([3, 1+0j, True]) +// False // -// >>> m = np.percentile(a, 50, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.percentile(a, 50, axis=0, out=out) -// array([6.5, 4.5, 2.5]) -// >>> m -// array([6.5, 4.5, 2.5]) // -// >>> b = a.copy() -// >>> np.percentile(b, 50, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a == b) // -// The different methods can be visualized graphically: +//go:linkname Isrealobj py.isrealobj +func Isrealobj(x *py.Object) *py.Object // -// .. plot:: +// Sort a complex array using the real part first, then the imaginary part. // -// import matplotlib.pyplot as plt +// Parameters +// ---------- +// a : array_like +// Input array // -// a = np.arange(4) -// p = np.linspace(0, 100, 6001) -// ax = plt.gca() -// lines = [ -// ('linear', '-', 'C0'), -// ('inverted_cdf', ':', 'C1'), -// # Almost the same as `inverted_cdf`: -// ('averaged_inverted_cdf', '-.', 'C1'), -// ('closest_observation', ':', 'C2'), -// ('interpolated_inverted_cdf', '--', 'C1'), -// ('hazen', '--', 'C3'), -// ('weibull', '-.', 'C4'), -// ('median_unbiased', '--', 'C5'), -// ('normal_unbiased', '-.', 'C6'), -// ] -// for method, style, color in lines: -// ax.plot( -// p, np.percentile(a, p, method=method), -// label=method, linestyle=style, color=color) -// ax.set( -// title='Percentiles for different methods and data: ' + str(a), -// xlabel='Percentile', -// ylabel='Estimated percentile value', -// yticks=a) -// ax.legend(bbox_to_anchor=(1.03, 1)) -// plt.tight_layout() -// plt.show() +// Returns +// ------- +// out : complex ndarray +// Always returns a sorted complex array. // -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 +// Examples +// -------- +// >>> np.sort_complex([5, 3, 6, 2, 1]) +// array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j]) // +// >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]) +// array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j]) // // -//go:linkname Percentile py.percentile -func Percentile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object // -// Function to calculate only the edges of the bins used by the `histogram` -// function. +//go:linkname SortComplex py.sort_complex +func SortComplex(a *py.Object) *py.Object +// +// Return the Blackman window. +// +// The Blackman window is a taper formed by using the first three +// terms of a summation of cosines. It was designed to have close to the +// minimal leakage possible. It is close to optimal, only slightly worse +// than a Kaiser window. // // Parameters // ---------- -// a : array_like -// Input data. The histogram is computed over the flattened array. -// bins : int or sequence of scalars or str, optional -// If `bins` is an int, it defines the number of equal-width -// bins in the given range (10, by default). If `bins` is a -// sequence, it defines the bin edges, including the rightmost -// edge, allowing for non-uniform bin widths. -// -// If `bins` is a string from the list below, `histogram_bin_edges` will -// use the method chosen to calculate the optimal bin width and -// consequently the number of bins (see the Notes section for more detail -// on the estimators) from the data that falls within the requested range. -// While the bin width will be optimal for the actual data -// in the range, the number of bins will be computed to fill the -// entire range, including the empty portions. For visualisation, -// using the 'auto' option is suggested. Weighted data is not -// supported for automated bin size selection. +// M : int +// Number of points in the output window. If zero or less, an empty +// array is returned. // -// 'auto' -// Minimum bin width between the 'sturges' and 'fd' estimators. -// Provides good all-around performance. +// Returns +// ------- +// out : ndarray +// The window, with the maximum value normalized to one (the value one +// appears only if the number of samples is odd). // -// 'fd' (Freedman Diaconis Estimator) -// Robust (resilient to outliers) estimator that takes into -// account data variability and data size. +// See Also +// -------- +// bartlett, hamming, hanning, kaiser // -// 'doane' -// An improved version of Sturges' estimator that works better -// with non-normal datasets. +// Notes +// ----- +// The Blackman window is defined as // -// 'scott' -// Less robust estimator that takes into account data variability -// and data size. +// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) // -// 'stone' -// Estimator based on leave-one-out cross-validation estimate of -// the integrated squared error. Can be regarded as a generalization -// of Scott's rule. +// Most references to the Blackman window come from the signal processing +// literature, where it is used as one of many windowing functions for +// smoothing values. 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. It is known as a +// "near optimal" tapering function, almost as good (by some measures) +// as the kaiser window. // -// 'rice' -// Estimator does not take variability into account, only data -// size. Commonly overestimates number of bins required. +// References +// ---------- +// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, +// Dover Publications, New York. // -// 'sturges' -// R's default method, only accounts for data size. Only -// optimal for gaussian data and underestimates number of bins -// for large non-gaussian datasets. +// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. +// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. // -// 'sqrt' -// Square root (of data size) estimator, used by Excel and -// other programs for its speed and simplicity. +// Examples +// -------- +// >>> import matplotlib.pyplot as plt +// >>> np.blackman(12) +// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary +// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, +// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, +// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) // -// range : (float, float), optional -// The lower and upper range of the bins. If not provided, range -// is simply ``(a.min(), a.max())``. Values outside the range are -// ignored. The first element of the range must be less than or -// equal to the second. `range` affects the automatic bin -// 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. +// Plot the window and the frequency response: // -// 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 -// (instead of 1). This is currently not used by any of the bin estimators, -// but may be in the future. +// >>> from numpy.fft import fft, fftshift +// >>> window = np.blackman(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Blackman window") +// Text(0.5, 1.0, 'Blackman window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() // -// Returns -// ------- -// bin_edges : array of dtype float -// The edges to pass into `histogram` +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Blackman window") +// Text(0.5, 1.0, 'Frequency response of Blackman window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() // -// See Also -// -------- -// histogram // -// Notes -// ----- -// The methods to estimate the optimal number of bins are well founded -// in literature, and are inspired by the choices R provides for -// histogram visualisation. Note that having the number of bins -// proportional to :math:`n^{1/3}` is asymptotically optimal, which is -// why it appears in most estimators. These are simply plug-in methods -// that give good starting points for number of bins. In the equations -// 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 -// than what is returned by the estimators below. // -// 'auto' (minimum bin width of the 'sturges' and 'fd' estimators) -// A compromise to get a good value. For small datasets the Sturges -// value will usually be chosen, while larger datasets will usually -// default to FD. Avoids the overly conservative behaviour of FD -// and Sturges for small and large datasets respectively. -// Switchover point is usually :math:`a.size \approx 1000`. +//go:linkname Blackman py.blackman +func Blackman(M *py.Object) *py.Object // -// 'fd' (Freedman Diaconis Estimator) -// .. math:: h = 2 \frac{IQR}{n^{1/3}} +// Broadcast the input shapes into a single shape. // -// The binwidth is proportional to the interquartile range (IQR) -// and inversely proportional to cube root of a.size. Can be too -// conservative for small datasets, but is quite good for large -// datasets. The IQR is very robust to outliers. +// :ref:`Learn more about broadcasting here `. // -// 'scott' -// .. math:: h = \sigma \sqrt[3]{\frac{24 \sqrt{\pi}}{n}} +// .. versionadded:: 1.20.0 // -// The binwidth is proportional to the standard deviation of the -// data and inversely proportional to cube root of ``x.size``. Can -// be too conservative for small datasets, but is quite good for -// large datasets. The standard deviation is not very robust to -// outliers. Values are very similar to the Freedman-Diaconis -// estimator in the absence of outliers. +// Parameters +// ---------- +// `*args` : tuples of ints, or ints +// The shapes to be broadcast against each other. // -// 'rice' -// .. math:: n_h = 2n^{1/3} +// Returns +// ------- +// tuple +// Broadcasted shape. // -// The number of bins is only proportional to cube root of -// ``a.size``. It tends to overestimate the number of bins and it -// does not take into account data variability. +// Raises +// ------ +// ValueError +// If the shapes are not compatible and cannot be broadcast according +// to NumPy's broadcasting rules. // -// 'sturges' -// .. math:: n_h = \log _{2}(n) + 1 +// See Also +// -------- +// broadcast +// broadcast_arrays +// broadcast_to // -// The number of bins is the base 2 log of ``a.size``. This -// estimator assumes normality of data and is too conservative for -// larger, non-normal datasets. This is the default method in R's -// ``hist`` method. +// Examples +// -------- +// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) +// (3, 2) // -// 'doane' -// .. math:: n_h = 1 + \log_{2}(n) + -// \log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right) +// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) +// (5, 6, 7) // -// g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right] // -// \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}} +//go:linkname BroadcastShapes py.broadcast_shapes +func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object // -// An improved version of Sturges' formula that produces better -// estimates for non-normal datasets. This estimator attempts to -// account for the skew of the data. +// Find the union of two arrays. // -// 'sqrt' -// .. math:: n_h = \sqrt n +// Return the unique, sorted array of values that are in either of the two +// input arrays. // -// The simplest and fastest estimator. Only takes into account the -// data size. +// Parameters +// ---------- +// ar1, ar2 : array_like +// Input arrays. They are flattened if they are not already 1D. +// +// Returns +// ------- +// union1d : ndarray +// Unique, sorted union of the input arrays. // -// Additionally, if the data is of integer dtype, then the binwidth will never -// be less than 1. +// See Also +// -------- +// numpy.lib.arraysetops : Module with a number of other functions for +// performing set operations on arrays. // // Examples // -------- -// >>> import numpy as np -// >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]) -// >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1)) -// array([0. , 0.25, 0.5 , 0.75, 1. ]) -// >>> np.histogram_bin_edges(arr, bins=2) -// array([0. , 2.5, 5. ]) +// >>> np.union1d([-1, 0, 1], [-2, 0, 2]) +// array([-2, -1, 0, 1, 2]) // -// For consistency with histogram, an array of pre-computed bins is -// passed through unmodified: +// To find the union of more than two arrays, use functools.reduce: // -// >>> np.histogram_bin_edges(arr, [1, 2]) -// array([1, 2]) +// >>> from functools import reduce +// >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) +// array([1, 2, 3, 4, 6]) // -// This function allows one set of bins to be computed, and reused across -// multiple histograms: // -// >>> shared_bins = np.histogram_bin_edges(arr, bins='auto') -// >>> shared_bins -// array([0., 1., 2., 3., 4., 5.]) +//go:linkname Union1d py.union1d +func Union1d(ar1 *py.Object, ar2 *py.Object) *py.Object // -// >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1]) -// >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins) -// >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins) +// Find the indices of array elements that are non-zero, grouped by element. // -// >>> hist_0; hist_1 -// array([1, 1, 0, 1, 0]) -// array([2, 0, 1, 1, 2]) +// Parameters +// ---------- +// a : array_like +// Input data. // -// Which gives more easily comparable results than using separate bins for -// each histogram: +// Returns +// ------- +// index_array : (N, a.ndim) ndarray +// Indices of elements that are non-zero. Indices are grouped by element. +// This array will have shape ``(N, a.ndim)`` where ``N`` is the number of +// non-zero items. // -// >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto') -// >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto') -// >>> hist_0; hist_1 -// array([1, 1, 1]) -// array([2, 1, 1, 2]) -// >>> bins_0; bins_1 -// array([0., 1., 2., 3.]) -// array([0. , 1.25, 2.5 , 3.75, 5. ]) +// See Also +// -------- +// where, nonzero // +// Notes +// ----- +// ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``, +// but produces a result of the correct shape for a 0D array. // +// The output of ``argwhere`` is not suitable for indexing arrays. +// For this purpose use ``nonzero(a)`` instead. // -//go:linkname HistogramBinEdges py.histogram_bin_edges -func HistogramBinEdges(a *py.Object, bins *py.Object, range_ *py.Object, weights *py.Object) *py.Object +// Examples +// -------- +// >>> x = np.arange(6).reshape(2,3) +// >>> x +// array([[0, 1, 2], +// [3, 4, 5]]) +// >>> np.argwhere(x>1) +// array([[0, 2], +// [1, 0], +// [1, 1], +// [1, 2]]) // -// Split an array into multiple sub-arrays horizontally (column-wise). // -// Please refer to the `split` documentation. `hsplit` is equivalent -// to `split` with ``axis=1``, the array is always split along the second -// axis except for 1-D arrays, where it is split at ``axis=0``. // -// See Also -// -------- -// split : Split an array into multiple sub-arrays of equal size. +//go:linkname Argwhere py.argwhere +func Argwhere(a *py.Object) *py.Object // -// Examples +// True if two arrays have the same shape and elements, False otherwise. +// +// Parameters +// ---------- +// a1, a2 : array_like +// Input arrays. +// equal_nan : bool +// Whether to compare NaN's as equal. If the dtype of a1 and a2 is +// complex, values will be considered equal if either the real or the +// imaginary component of a given value is ``nan``. +// +// .. versionadded:: 1.19.0 +// +// Returns +// ------- +// b : bool +// Returns True if the arrays are equal. +// +// See Also // -------- -// >>> import numpy as np -// >>> x = np.arange(16.0).reshape(4, 4) -// >>> x -// array([[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.], -// [ 8., 9., 10., 11.], -// [12., 13., 14., 15.]]) -// >>> np.hsplit(x, 2) -// [array([[ 0., 1.], -// [ 4., 5.], -// [ 8., 9.], -// [12., 13.]]), -// array([[ 2., 3.], -// [ 6., 7.], -// [10., 11.], -// [14., 15.]])] -// >>> np.hsplit(x, np.array([3, 6])) -// [array([[ 0., 1., 2.], -// [ 4., 5., 6.], -// [ 8., 9., 10.], -// [12., 13., 14.]]), -// array([[ 3.], -// [ 7.], -// [11.], -// [15.]]), -// array([], shape=(4, 0), dtype=float64)] -// -// With a higher dimensional array the split is still along the second axis. +// allclose: Returns True if two arrays are element-wise equal within a +// tolerance. +// array_equiv: Returns True if input arrays are shape consistent and all +// elements equal. // -// >>> x = np.arange(8.0).reshape(2, 2, 2) -// >>> x -// array([[[0., 1.], -// [2., 3.]], -// [[4., 5.], -// [6., 7.]]]) -// >>> np.hsplit(x, 2) -// [array([[[0., 1.]], -// [[4., 5.]]]), -// array([[[2., 3.]], -// [[6., 7.]]])] +// Examples +// -------- +// >>> np.array_equal([1, 2], [1, 2]) +// True +// >>> np.array_equal(np.array([1, 2]), np.array([1, 2])) +// True +// >>> np.array_equal([1, 2], [1, 2, 3]) +// False +// >>> np.array_equal([1, 2], [1, 4]) +// False +// >>> a = np.array([1, np.nan]) +// >>> np.array_equal(a, a) +// False +// >>> np.array_equal(a, a, equal_nan=True) +// True // -// With a 1-D array, the split is along axis 0. +// When ``equal_nan`` is True, complex values with nan components are +// considered equal if either the real *or* the imaginary components are nan. // -// >>> x = np.array([0, 1, 2, 3, 4, 5]) -// >>> np.hsplit(x, 2) -// [array([0, 1, 2]), array([3, 4, 5])] +// >>> a = np.array([1 + 1j]) +// >>> b = a.copy() +// >>> a.real = np.nan +// >>> b.imag = np.nan +// >>> np.array_equal(a, b, equal_nan=True) +// True // // +//go:linkname ArrayEqual py.array_equal +func ArrayEqual(a1 *py.Object, a2 *py.Object, equalNan *py.Object) *py.Object // -//go:linkname Hsplit py.hsplit -func Hsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object +// Join a sequence of arrays along a new axis. // -// Set the size of the buffer used in ufuncs. +// The ``axis`` parameter specifies the index of the new axis in the +// dimensions of the result. For example, if ``axis=0`` it will be the first +// dimension and if ``axis=-1`` it will be the last dimension. // -// .. versionchanged:: 2.0 -// The scope of setting the buffer is tied to the `numpy.errstate` -// context. Exiting a ``with errstate():`` will also restore the bufsize. +// .. versionadded:: 1.10.0 // // Parameters // ---------- -// size : int -// Size of buffer. -// -// Returns -// ------- -// bufsize : int -// Previous size of ufunc buffer in bytes. +// arrays : sequence of array_like +// Each array must have the same shape. // -// Examples -// -------- -// When exiting a `numpy.errstate` context manager the bufsize is restored: +// axis : int, optional +// The axis in the result array along which the input arrays are stacked. // -// >>> import numpy as np -// >>> with np.errstate(): -// ... np.setbufsize(4096) -// ... print(np.getbufsize()) -// ... -// 8192 -// 4096 -// >>> np.getbufsize() -// 8192 +// out : ndarray, optional +// If provided, the destination to place the result. The shape must be +// 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 // -//go:linkname Setbufsize py.setbufsize -func Setbufsize(size *py.Object) *py.Object +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional +// Controls what kind of data casting may occur. Defaults to 'same_kind'. // -// Return the number of elements along a given axis. +// .. versionadded:: 1.24 // -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : int, optional -// Axis along which the elements are counted. By default, give -// the total number of elements. // // Returns // ------- -// element_count : int -// Number of elements along the specified axis. +// stacked : ndarray +// The stacked array has one more dimension than the input arrays. // // See Also // -------- -// shape : dimensions of array -// ndarray.shape : dimensions of array -// ndarray.size : number of elements in array +// concatenate : Join a sequence of arrays along an existing axis. +// block : Assemble an nd-array from nested lists of blocks. +// split : Split array into a list of multiple sub-arrays of equal size. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1,2,3],[4,5,6]]) -// >>> np.size(a) -// 6 -// >>> np.size(a,1) -// 3 -// >>> np.size(a,0) -// 2 -// -// -// -//go:linkname Size py.size -func Size(a *py.Object, axis *py.Object) *py.Object -// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Compute the bit-wise XOR of two arrays element-wise. -// -// Computes the bit-wise XOR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``^``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_xor -// bitwise_and -// bitwise_or -// binary_repr : -// Return the binary representation of the input number as a string. +// >>> arrays = [np.random.randn(3, 4) for _ in range(10)] +// >>> np.stack(arrays, axis=0).shape +// (10, 3, 4) // -// Examples -// -------- -// >>> import numpy as np +// >>> np.stack(arrays, axis=1).shape +// (3, 10, 4) // -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise XOR of 13 and 17 is -// therefore ``00011100``, or 28: +// >>> np.stack(arrays, axis=2).shape +// (3, 4, 10) // -// >>> np.bitwise_xor(13, 17) -// 28 -// >>> np.binary_repr(28) -// '11100' +// >>> a = np.array([1, 2, 3]) +// >>> b = np.array([4, 5, 6]) +// >>> np.stack((a, b)) +// array([[1, 2, 3], +// [4, 5, 6]]) // -// >>> np.bitwise_xor(31, 5) -// 26 -// >>> np.bitwise_xor([31,3], 5) -// array([26, 6]) +// >>> np.stack((a, b), axis=-1) +// array([[1, 4], +// [2, 5], +// [3, 6]]) // -// >>> np.bitwise_xor([31,3], [5,6]) -// array([26, 5]) -// >>> np.bitwise_xor([True, True], [False, True]) -// array([ True, False]) // -// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on -// ndarrays. // -// >>> x1 = np.array([True, True]) -// >>> x2 = np.array([False, True]) -// >>> x1 ^ x2 -// array([ True, False]) +//go:linkname Stack py.stack +func Stack(arrays *py.Object, axis *py.Object, out *py.Object) *py.Object // -//go:linkname BitwiseXor py.bitwise_xor -func BitwiseXor(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// Returns a bool array, where True if input element is complex. // -// True if two arrays have the same shape and elements, False otherwise. +// What is tested is whether the input has a non-zero imaginary part, not if +// the input type is complex. // // Parameters // ---------- -// a1, a2 : array_like -// Input arrays. -// equal_nan : bool -// Whether to compare NaN's as equal. If the dtype of a1 and a2 is -// complex, values will be considered equal if either the real or the -// imaginary component of a given value is ``nan``. +// x : array_like +// Input array. // // Returns // ------- -// b : bool -// Returns True if the arrays are equal. +// out : ndarray of bools +// Output array. // // See Also // -------- -// allclose: Returns True if two arrays are element-wise equal within a -// tolerance. -// array_equiv: Returns True if input arrays are shape consistent and all -// elements equal. +// isreal +// iscomplexobj : Return True if x is a complex type or an array of complex +// numbers. // // Examples // -------- -// >>> import numpy as np +// >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]) +// array([ True, False, False, False, False, True]) // -// >>> np.array_equal([1, 2], [1, 2]) -// True // -// >>> np.array_equal(np.array([1, 2]), np.array([1, 2])) -// True // -// >>> np.array_equal([1, 2], [1, 2, 3]) -// False +//go:linkname Iscomplex py.iscomplex +func Iscomplex(x *py.Object) *py.Object // -// >>> np.array_equal([1, 2], [1, 4]) -// False +// Return an array converted to a float type. // -// >>> a = np.array([1, np.nan]) -// >>> np.array_equal(a, a) -// False +// Parameters +// ---------- +// a : array_like +// The input array. +// dtype : str or dtype object, optional +// Float type code to coerce input array `a`. If `dtype` is one of the +// 'int' dtypes, it is replaced with float64. // -// >>> np.array_equal(a, a, equal_nan=True) -// True +// Returns +// ------- +// out : ndarray +// The input `a` as a float ndarray. // -// When ``equal_nan`` is True, complex values with nan components are -// considered equal if either the real *or* the imaginary components are nan. +// Examples +// -------- +// >>> np.asfarray([2, 3]) +// array([2., 3.]) +// >>> np.asfarray([2, 3], dtype='float') +// array([2., 3.]) +// >>> np.asfarray([2, 3], dtype='int8') +// array([2., 3.]) // -// >>> a = np.array([1 + 1j]) -// >>> b = a.copy() -// >>> a.real = np.nan -// >>> b.imag = np.nan -// >>> np.array_equal(a, b, equal_nan=True) -// True // // -//go:linkname ArrayEqual py.array_equal -func ArrayEqual(a1 *py.Object, a2 *py.Object, equalNan *py.Object) *py.Object +//go:linkname Asfarray py.asfarray +func Asfarray(a *py.Object, dtype *py.Object) *py.Object +// +// Rotate an array by 90 degrees in the plane specified by axes. +// +// Rotation direction is from the first towards the second axis. +// This means for a 2D array with the default `k` and `axes`, the +// rotation will be counterclockwise. +// +// Parameters +// ---------- +// m : array_like +// Array of two or more dimensions. +// k : integer +// Number of times the array is rotated by 90 degrees. +// axes : (2,) array_like +// The array is rotated in the plane defined by the axes. +// Axes must be different. +// +// .. versionadded:: 1.12.0 +// +// Returns +// ------- +// y : ndarray +// A rotated view of `m`. +// +// See Also +// -------- +// flip : Reverse the order of elements in an array along the given axis. +// fliplr : Flip an array horizontally. +// flipud : Flip an array vertically. +// +// Notes +// ----- +// ``rot90(m, k=1, axes=(1,0))`` is the reverse of +// ``rot90(m, k=1, axes=(0,1))`` +// +// ``rot90(m, k=1, axes=(1,0))`` is equivalent to +// ``rot90(m, k=-1, axes=(0,1))`` +// +// Examples +// -------- +// >>> m = np.array([[1,2],[3,4]], int) +// >>> m +// array([[1, 2], +// [3, 4]]) +// >>> np.rot90(m) +// array([[2, 4], +// [1, 3]]) +// >>> np.rot90(m, 2) +// array([[4, 3], +// [2, 1]]) +// >>> m = np.arange(8).reshape((2,2,2)) +// >>> np.rot90(m, 1, (1,2)) +// array([[[1, 3], +// [0, 2]], +// [[5, 7], +// [4, 6]]]) +// +// +// +//go:linkname Rot90 py.rot90 +func Rot90(m *py.Object, k *py.Object, axes *py.Object) *py.Object +// +// Return a new array with sub-arrays along an axis deleted. For a one +// dimensional array, this returns those entries not returned by +// `arr[obj]`. +// +// Parameters +// ---------- +// arr : array_like +// Input array. +// obj : slice, int or array of ints +// Indicate indices of sub-arrays to remove along the specified axis. +// +// .. versionchanged:: 1.19.0 +// Boolean indices are now treated as a mask of elements to remove, +// rather than being cast to the integers 0 and 1. +// +// axis : int, optional +// The axis along which to delete the subarray defined by `obj`. +// If `axis` is None, `obj` is applied to the flattened array. +// +// Returns +// ------- +// out : ndarray +// A copy of `arr` with the elements specified by `obj` removed. Note +// that `delete` does not occur in-place. If `axis` is None, `out` is +// a flattened array. +// +// See Also +// -------- +// insert : Insert elements into an array. +// append : Append elements at the end of an array. +// +// Notes +// ----- +// Often it is preferable to use a boolean mask. For example: +// +// >>> arr = np.arange(12) + 1 +// >>> mask = np.ones(len(arr), dtype=bool) +// >>> mask[[0,2,4]] = False +// >>> result = arr[mask,...] +// +// Is equivalent to ``np.delete(arr, [0,2,4], axis=0)``, but allows further +// use of `mask`. +// +// Examples +// -------- +// >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) +// >>> arr +// array([[ 1, 2, 3, 4], +// [ 5, 6, 7, 8], +// [ 9, 10, 11, 12]]) +// >>> np.delete(arr, 1, 0) +// array([[ 1, 2, 3, 4], +// [ 9, 10, 11, 12]]) +// +// >>> np.delete(arr, np.s_[::2], 1) +// array([[ 2, 4], +// [ 6, 8], +// [10, 12]]) +// >>> np.delete(arr, [1,3,5], None) +// array([ 1, 3, 5, 7, 8, 9, 10, 11, 12]) +// +// +// +//go:linkname Delete py.delete +func Delete(arr *py.Object, obj *py.Object, axis *py.Object) *py.Object +// +// Return the product of array elements over a given axis treating Not a +// Numbers (NaNs) as ones. +// +// One is returned for slices that are all-NaN or empty. +// +// .. versionadded:: 1.10.0 +// +// Parameters +// ---------- +// a : array_like +// Array containing numbers whose product is desired. If `a` is not an +// array, a conversion is attempted. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the product is computed. The default is to compute +// the product of the flattened array. +// dtype : data-type, optional +// The type of the returned array and of the accumulator in which the +// elements are summed. By default, the dtype of `a` is used. An +// exception is when `a` has an integer type with less precision than +// the platform (u)intp. In that case, the default will be either +// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 +// bits. For inexact inputs, dtype must be inexact. +// out : ndarray, optional +// Alternate output array in which to place the result. The default +// is ``None``. If provided, it must have the same shape as the +// expected output, but the type will be cast if necessary. See +// :ref:`ufuncs-output-type` for more details. The casting of NaN to integer +// can yield unexpected results. +// keepdims : bool, optional +// If 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 `arr`. +// initial : scalar, optional +// The starting value for this product. See `~numpy.ufunc.reduce` +// for details. +// +// .. versionadded:: 1.22.0 +// where : array_like of bool, optional +// Elements to include in the product. See `~numpy.ufunc.reduce` +// for details. +// +// .. versionadded:: 1.22.0 +// +// Returns +// ------- +// nanprod : ndarray +// A new array holding the result is returned unless `out` is +// specified, in which case it is returned. +// +// See Also +// -------- +// numpy.prod : Product across array propagating NaNs. +// isnan : Show which elements are NaN. +// +// Examples +// -------- +// >>> np.nanprod(1) +// 1 +// >>> np.nanprod([1]) +// 1 +// >>> np.nanprod([1, np.nan]) +// 1.0 +// >>> a = np.array([[1, 2], [3, np.nan]]) +// >>> np.nanprod(a) +// 6.0 +// >>> np.nanprod(a, axis=0) +// array([3., 2.]) +// +// +// +//go:linkname Nanprod py.nanprod +func Nanprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object // // Returns True if input arrays are shape consistent and all elements equal. // @@ -9340,7 +8284,6 @@ func ArrayEqual(a1 *py.Object, a2 *py.Object, equalNan *py.Object) *py.Object // // Examples // -------- -// >>> import numpy as np // >>> np.array_equiv([1, 2], [1, 2]) // True // >>> np.array_equiv([1, 2], [1, 3]) @@ -9360,260 +8303,217 @@ func ArrayEqual(a1 *py.Object, a2 *py.Object, equalNan *py.Object) *py.Object // //go:linkname ArrayEquiv py.array_equiv func ArrayEquiv(a1 *py.Object, a2 *py.Object) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Divide arguments element-wise. +// Return the binary representation of the input number as a string. // -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// For negative numbers, if width is not given, a minus sign is added to the +// front. If width is given, the two's complement of the number is +// returned, with respect to that width. // -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. +// In a two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit two's-complement +// system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. // -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. +// Parameters +// ---------- +// num : int +// Only an integer decimal number can be used. +// width : int, optional +// The length of the returned string if `num` is positive, or the length +// of the two's complement if `num` is negative, provided that `width` is +// at least a sufficient number of bits for `num` to be represented in the +// designated form. // -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. +// If the `width` value is insufficient, it will be ignored, and `num` will +// be returned in binary (`num` > 0) or two's complement (`num` < 0) form +// with its width equal to the minimum number of bits needed to represent +// the number in the designated form. This behavior is deprecated and will +// later raise an error. // -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. +// .. deprecated:: 1.12.0 // -// Examples -// -------- -// >>> import numpy as np -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> 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. ]]) +// Returns +// ------- +// bin : str +// Binary representation of `num` or two's complement of `num`. // -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. +// See Also +// -------- +// base_repr: Return a string representation of a number in the given base +// system. +// bin: Python's built-in binary representation generator of an integer. // -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) +// Notes +// ----- +// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x +// faster. // -//go:linkname TrueDivide py.true_divide -func TrueDivide(__llgo_va_list ...interface{}) *py.Object +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement +// +// Examples +// -------- +// >>> np.binary_repr(3) +// '11' +// >>> np.binary_repr(-3) +// '-11' +// >>> np.binary_repr(3, width=4) +// '0011' +// +// The two's complement is returned when the input number is negative and +// width is specified: +// +// >>> np.binary_repr(-3, width=3) +// '101' +// >>> np.binary_repr(-3, width=5) +// '11101' // -// Compute the median along the specified axis, while ignoring NaNs. // -// Returns the median of the array elements. +// +//go:linkname BinaryRepr py.binary_repr +func BinaryRepr(num *py.Object, width *py.Object) *py.Object +// +// Test whether all array elements along a given axis evaluate to True. // // Parameters // ---------- // a : array_like // Input array or object that can be converted to an array. -// axis : {int, sequence of int, None}, optional -// Axis or axes along which the medians are computed. The default -// is to compute the median along a flattened version of the array. -// A sequence of axes is supported since version 1.9.0. +// axis : None or int or tuple of ints, optional +// Axis or axes along which a logical AND reduction is performed. +// The default (``axis=None``) is to perform a logical AND over all +// the dimensions of the input array. `axis` may be negative, in +// which case it counts from the last to the first axis. +// +// .. versionadded:: 1.7.0 +// +// If this is a tuple of ints, a reduction is performed on multiple +// axes, instead of a single axis or all the axes as before. // out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow use of memory of input array `a` for -// calculations. The input array will be modified by the call to -// `median`. This will save memory when you do not need to preserve -// the contents of the input array. Treat the input as undefined, -// but it will probably be fully or partially sorted. Default is -// False. If `overwrite_input` is ``True`` and `a` is not already an -// `ndarray`, an error will be raised. +// Alternate output array in which to place the result. +// It must have the same shape as the expected output and its +// type is preserved (e.g., if ``dtype(out)`` is float, the result +// will consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` for more +// details. +// // 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`. +// the result will broadcast correctly against the input array. // -// If this is anything but the default value it will be passed -// through (in the special case of an empty array) to the -// `mean` function of the underlying array. If the array is -// a sub-class and `mean` does not have the kwarg `keepdims` this -// will raise a RuntimeError. +// If the default value is passed, then `keepdims` will not be +// passed through to the `all` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. +// +// where : array_like of bool, optional +// Elements to include in checking for all `True` values. +// See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.20.0 // // Returns // ------- -// median : ndarray -// A new array holding the result. If the input contains integers -// or floats smaller than ``float64``, then the output data-type is -// ``np.float64``. Otherwise, the data-type of the output is the -// same as that of the input. If `out` is specified, that array is -// returned instead. +// all : ndarray, bool +// A new boolean or array is returned unless `out` is specified, +// in which case a reference to `out` is returned. // // See Also // -------- -// mean, median, percentile +// ndarray.all : equivalent method +// +// any : Test whether any element along a given axis evaluates to True. // // Notes // ----- -// Given a vector ``V`` of length ``N``, the median of ``V`` is the -// middle value of a sorted copy of ``V``, ``V_sorted`` - i.e., -// ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two -// middle values of ``V_sorted`` when ``N`` is even. +// Not a Number (NaN), positive infinity and negative infinity +// evaluate to `True` because these are not equal to zero. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[10.0, 7, 4], [3, 2, 1]]) -// >>> a[0, 1] = np.nan -// >>> a -// array([[10., nan, 4.], -// [ 3., 2., 1.]]) -// >>> np.median(a) -// np.float64(nan) -// >>> np.nanmedian(a) -// 3.0 -// >>> np.nanmedian(a, axis=0) -// array([6.5, 2. , 2.5]) -// >>> np.median(a, axis=1) -// array([nan, 2.]) -// >>> b = a.copy() -// >>> np.nanmedian(b, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a==b) -// >>> b = a.copy() -// >>> np.nanmedian(b, axis=None, overwrite_input=True) -// 3.0 -// >>> assert not np.all(a==b) -// +// >>> np.all([[True,False],[True,True]]) +// False // +// >>> np.all([[True,False],[True,True]], axis=0) +// array([ True, False]) // -//go:linkname Nanmedian py.nanmedian -func Nanmedian(a *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, keepdims *py.Object) *py.Object -// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> np.all([-1, 4, 5]) +// True // -// Inverse hyperbolic sine element-wise. +// >>> np.all([1.0, np.nan]) +// True // -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> np.all([[True, True], [False, True]], where=[[True], [False]]) +// True // -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. +// >>> o=np.array(False) +// >>> z=np.all([-1, 4, 5], out=o) +// >>> id(z), id(o), z +// (28293632, 28293632, array(True)) # may vary // -// Notes -// ----- -// `arcsinh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `sinh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `[-pi/2, pi/2]`. // -// For real-valued input data types, `arcsinh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// returns ``nan`` and sets the `invalid` floating point error flag. // -// For complex-valued input, `arcsinh` is a complex analytical function that -// has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from -// the right on the former and from the left on the latter. +//go:linkname All py.all +func All(__llgo_va_list ...interface{}) *py.Object // -// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. +// Return the number of elements along a given axis. // -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arcsinh +// Parameters +// ---------- +// a : array_like +// Input data. +// axis : int, optional +// Axis along which the elements are counted. By default, give +// the total number of elements. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.arcsinh(np.array([np.e, 10.0])) -// array([ 1.72538256, 2.99822295]) +// Returns +// ------- +// element_count : int +// Number of elements along the specified axis. // -//go:linkname Arcsinh py.arcsinh -func Arcsinh(x *py.Object, out *py.Object) *py.Object +// See Also +// -------- +// shape : dimensions of array +// ndarray.shape : dimensions of array +// ndarray.size : number of elements in array // -// busday_offset( -// dates, -// offsets, -// roll='raise', -// weekmask='1111100', -// holidays=None, -// busdaycal=None, -// out=None -// ) +// Examples +// -------- +// >>> a = np.array([[1,2,3],[4,5,6]]) +// >>> np.size(a) +// 6 +// >>> np.size(a,1) +// 3 +// >>> np.size(a,0) +// 2 // -// First adjusts the date to fall on a valid day according to -// the ``roll`` rule, then applies offsets to the given dates -// counted in valid days. +// +// +//go:linkname Size py.size +func Size(a *py.Object, axis *py.Object) *py.Object +// +// busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None) +// +// Counts the number of valid days between `begindates` and +// `enddates`, not including the day of `enddates`. +// +// If ``enddates`` specifies a date value that is earlier than the +// corresponding ``begindates`` date value, the count will be negative. +// +// .. versionadded:: 1.7.0 // // Parameters // ---------- -// dates : array_like of datetime64[D] -// The array of dates to process. -// offsets : array_like of int -// The array of offsets, which is broadcast with ``dates``. -// roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional -// How to treat dates that do not fall on a valid day. The default -// is 'raise'. -// -// * 'raise' means to raise an exception for an invalid day. -// * 'nat' means to return a NaT (not-a-time) for an invalid day. -// * 'forward' and 'following' mean to take the first valid day -// later in time. -// * 'backward' and 'preceding' mean to take the first valid day -// earlier in time. -// * 'modifiedfollowing' means to take the first valid day -// later in time unless it is across a Month boundary, in which -// case to take the first valid day earlier in time. -// * 'modifiedpreceding' means to take the first valid day -// earlier in time unless it is across a Month boundary, in which -// case to take the first valid day later in time. +// begindates : array_like of datetime64[D] +// The array of the first dates for counting. +// enddates : array_like of datetime64[D] +// The array of the end dates for counting, which are excluded +// from the count themselves. // weekmask : str or array_like of bool, optional // A seven-element array indicating which of Monday through Sunday are // valid days. May be specified as a length-seven list or array, like @@ -9630,382 +8530,235 @@ func Arcsinh(x *py.Object, out *py.Object) *py.Object // A `busdaycalendar` object which specifies the valid days. If this // parameter is provided, neither weekmask nor holidays may be // provided. -// out : array of datetime64[D], optional +// out : array of int, optional // If provided, this array is filled with the result. // // Returns // ------- -// out : array of datetime64[D] -// An array with a shape from broadcasting ``dates`` and ``offsets`` -// together, containing the dates with offsets applied. +// out : array of int +// An array with a shape from broadcasting ``begindates`` and ``enddates`` +// together, containing the number of valid days between +// the begin and end dates. // // See Also // -------- // busdaycalendar : An object that specifies a custom set of valid days. // is_busday : Returns a boolean array indicating valid days. -// busday_count : Counts how many valid days are in a half-open date range. +// busday_offset : Applies an offset counted in valid days. // // Examples // -------- -// >>> import numpy as np -// >>> # First business day in October 2011 (not accounting for holidays) -// ... np.busday_offset('2011-10', 0, roll='forward') -// np.datetime64('2011-10-03') -// >>> # Last business day in February 2012 (not accounting for holidays) -// ... np.busday_offset('2012-03', -1, roll='forward') -// np.datetime64('2012-02-29') -// >>> # Third Wednesday in January 2011 -// ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed') -// np.datetime64('2011-01-19') -// >>> # 2012 Mother's Day in Canada and the U.S. -// ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun') -// np.datetime64('2012-05-13') -// -// >>> # First business day on or after a date -// ... np.busday_offset('2011-03-20', 0, roll='forward') -// np.datetime64('2011-03-21') -// >>> np.busday_offset('2011-03-22', 0, roll='forward') -// np.datetime64('2011-03-22') -// >>> # First business day after a date -// ... np.busday_offset('2011-03-20', 1, roll='backward') -// np.datetime64('2011-03-21') -// >>> np.busday_offset('2011-03-22', 1, roll='backward') -// np.datetime64('2011-03-23') +// >>> # Number of weekdays in January 2011 +// ... np.busday_count('2011-01', '2011-02') +// 21 +// >>> # Number of weekdays in 2011 +// >>> np.busday_count('2011', '2012') +// 260 +// >>> # Number of Saturdays in 2011 +// ... np.busday_count('2011', '2012', weekmask='Sat') +// 53 // // -//go:linkname BusdayOffset py.busday_offset -func BusdayOffset(dates *py.Object, offsets *py.Object, roll *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object +//go:linkname BusdayCount py.busday_count +func BusdayCount(begindates *py.Object, enddates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object // -// Return numbers spaced evenly on a log scale (a geometric progression). +// Compute the qth quantile of the data along the specified axis, +// while ignoring nan values. +// Returns the qth quantile(s) of the array elements. // -// This is similar to `logspace`, but with endpoints specified directly. -// Each output sample is a constant multiple of the previous. +// .. versionadded:: 1.15.0 // // Parameters // ---------- -// start : array_like -// The starting value of the sequence. -// stop : array_like -// The final value of the sequence, unless `endpoint` is False. -// In that case, ``num + 1`` values are spaced over the -// interval in log-space, of which all but the last (a sequence of -// length `num`) are returned. -// num : integer, optional -// Number of samples to generate. Default is 50. -// endpoint : boolean, optional -// If true, `stop` is the last sample. Otherwise, it is not included. -// Default is True. -// dtype : dtype -// The type of the output array. If `dtype` is not given, the data type -// is inferred from `start` and `stop`. The inferred dtype will never be -// an integer; `float` is chosen even if the arguments would produce an -// array of integers. -// axis : int, optional -// The axis in the result to store the samples. Relevant only if start -// or stop are array-like. By default (0), the samples will be along a -// new axis inserted at the beginning. Use -1 to get an axis at the end. +// a : array_like +// Input array or object that can be converted to an array, containing +// nan values to be ignored +// q : array_like of float +// Probability or sequence of probabilities for the quantiles to compute. +// Values must be between 0 and 1 inclusive. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the quantiles are computed. The +// default is to compute the quantile(s) along a flattened +// version of the array. +// out : ndarray, optional +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output, +// but the type (of the output) will be cast if necessary. +// overwrite_input : bool, optional +// If True, then allow the input array `a` to be modified by intermediate +// calculations, to save memory. In this case, the contents of the input +// `a` after this function completes is undefined. +// method : str, optional +// This parameter specifies the method to use for estimating the +// quantile. There are many different methods, some unique to NumPy. +// See the notes for explanation. The options sorted by their R type +// as summarized in the H&F paper [1]_ are: +// +// 1. 'inverted_cdf' +// 2. 'averaged_inverted_cdf' +// 3. 'closest_observation' +// 4. 'interpolated_inverted_cdf' +// 5. 'hazen' +// 6. 'weibull' +// 7. 'linear' (default) +// 8. 'median_unbiased' +// 9. 'normal_unbiased' +// +// The first three methods are discontinuous. NumPy further defines the +// following discontinuous variations of the default 'linear' (7.) option: +// +// * 'lower' +// * 'higher', +// * 'midpoint' +// * 'nearest' +// +// .. versionchanged:: 1.22.0 +// This argument was previously called "interpolation" and only +// offered the "linear" default and last four options. +// +// 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 array `a`. +// +// If this is anything but the default value it will be passed +// through (in the special case of an empty array) to the +// `mean` function of the underlying array. If the array is +// a sub-class and `mean` does not have the kwarg `keepdims` this +// will raise a RuntimeError. +// +// interpolation : str, optional +// Deprecated name for the method keyword argument. +// +// .. deprecated:: 1.22.0 // // Returns // ------- -// samples : ndarray -// `num` samples, equally spaced on a log scale. +// quantile : scalar or ndarray +// If `q` is a single probability and `axis=None`, then the result +// is a scalar. If multiple probability levels are given, first axis of +// the result corresponds to the quantiles. The other axes are +// the axes that remain after the reduction of `a`. If the input +// contains integers or floats smaller than ``float64``, the output +// data-type is ``float64``. Otherwise, the output data-type is the +// same as that of the input. If `out` is specified, that array is +// returned instead. // // See Also // -------- -// logspace : Similar to geomspace, but with endpoints specified using log -// and base. -// linspace : Similar to geomspace, but with arithmetic instead of geometric -// progression. -// arange : Similar to linspace, with the step size specified instead of the -// number of samples. -// :ref:`how-to-partition` +// quantile +// nanmean, nanmedian +// nanmedian : equivalent to ``nanquantile(..., 0.5)`` +// nanpercentile : same as nanquantile, but with q in the range [0, 100]. // // Notes // ----- -// If the inputs or dtype are complex, the output will follow a logarithmic -// spiral in the complex plane. (There are an infinite number of spirals -// passing through two points; the output will follow the shortest such path.) +// For more information please see `numpy.quantile` // // Examples // -------- -// >>> import numpy as np -// >>> np.geomspace(1, 1000, num=4) -// array([ 1., 10., 100., 1000.]) -// >>> np.geomspace(1, 1000, num=3, endpoint=False) -// array([ 1., 10., 100.]) -// >>> np.geomspace(1, 1000, num=4, endpoint=False) -// array([ 1. , 5.62341325, 31.6227766 , 177.827941 ]) -// >>> np.geomspace(1, 256, num=9) -// array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.]) +// >>> a = np.array([[10., 7., 4.], [3., 2., 1.]]) +// >>> a[0][1] = np.nan +// >>> a +// array([[10., nan, 4.], +// [ 3., 2., 1.]]) +// >>> np.quantile(a, 0.5) +// nan +// >>> np.nanquantile(a, 0.5) +// 3.0 +// >>> np.nanquantile(a, 0.5, axis=0) +// array([6.5, 2. , 2.5]) +// >>> np.nanquantile(a, 0.5, axis=1, keepdims=True) +// array([[7.], +// [2.]]) +// >>> m = np.nanquantile(a, 0.5, axis=0) +// >>> out = np.zeros_like(m) +// >>> np.nanquantile(a, 0.5, axis=0, out=out) +// array([6.5, 2. , 2.5]) +// >>> m +// array([6.5, 2. , 2.5]) +// >>> b = a.copy() +// >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True) +// array([7., 2.]) +// >>> assert not np.all(a==b) // -// Note that the above may not produce exact integers: +// References +// ---------- +// .. [1] R. J. Hyndman and Y. Fan, +// "Sample quantiles in statistical packages," +// The American Statistician, 50(4), pp. 361-365, 1996 // -// >>> np.geomspace(1, 256, num=9, dtype=int) -// array([ 1, 2, 4, 7, 16, 32, 63, 127, 256]) -// >>> np.around(np.geomspace(1, 256, num=9)).astype(int) -// array([ 1, 2, 4, 8, 16, 32, 64, 128, 256]) // -// Negative, decreasing, and complex inputs are allowed: // -// >>> np.geomspace(1000, 1, num=4) -// array([1000., 100., 10., 1.]) -// >>> np.geomspace(-1000, -1, num=4) -// array([-1000., -100., -10., -1.]) -// >>> np.geomspace(1j, 1000j, num=4) # Straight line -// array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j]) -// >>> np.geomspace(-1+0j, 1+0j, num=5) # Circle -// array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j, -// 6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j, -// 1.00000000e+00+0.00000000e+00j]) +//go:linkname Nanquantile py.nanquantile +func Nanquantile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object +// empty(shape, dtype=float, order='C', *, like=None) // -// Graphical illustration of `endpoint` parameter: -// -// >>> import matplotlib.pyplot as plt -// >>> N = 10 -// >>> y = np.zeros(N) -// >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o') -// [] -// >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o') -// [] -// >>> plt.axis([0.5, 2000, 0, 3]) -// [0.5, 2000, 0, 3] -// >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both') -// >>> plt.show() -// -// -// -//go:linkname Geomspace py.geomspace -func Geomspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, dtype *py.Object, axis *py.Object) *py.Object -// -// inner(a, b, /) -// -// Inner product of two arrays. -// -// Ordinary inner product of vectors for 1-D arrays (without complex -// conjugation), in higher dimensions a sum product over the last axes. +// Return a new array of given shape and type, without initializing entries. // // Parameters // ---------- -// a, b : array_like -// If `a` and `b` are nonscalar, their last dimensions must match. -// -// Returns -// ------- -// out : ndarray -// If `a` and `b` are both -// scalars or both 1-D arrays then a scalar is returned; otherwise -// an array is returned. -// ``out.shape = (*a.shape[:-1], *b.shape[:-1])`` -// -// Raises -// ------ -// ValueError -// If both `a` and `b` are nonscalar and their last dimensions have -// different sizes. -// -// See Also -// -------- -// tensordot : Sum products over arbitrary axes. -// dot : Generalised matrix product, using second last dimension of `b`. -// vecdot : Vector dot product of two arrays. -// einsum : Einstein summation convention. -// -// Notes -// ----- -// For vectors (1-D arrays) it computes the ordinary inner-product:: -// -// np.inner(a, b) = sum(a[:]*b[:]) -// -// More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``:: -// -// np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1)) -// -// or explicitly:: -// -// np.inner(a, b)[i0,...,ir-2,j0,...,js-2] -// = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:]) -// -// In addition `a` or `b` may be scalars, in which case:: -// -// np.inner(a,b) = a*b -// -// Examples -// -------- -// Ordinary inner product for vectors: -// -// >>> import numpy as np -// >>> a = np.array([1,2,3]) -// >>> b = np.array([0,1,0]) -// >>> np.inner(a, b) -// 2 -// -// Some multidimensional examples: -// -// >>> a = np.arange(24).reshape((2,3,4)) -// >>> b = np.arange(4) -// >>> c = np.inner(a, b) -// >>> c.shape -// (2, 3) -// >>> c -// array([[ 14, 38, 62], -// [ 86, 110, 134]]) -// -// >>> a = np.arange(2).reshape((1,1,2)) -// >>> b = np.arange(6).reshape((3,2)) -// >>> c = np.inner(a, b) -// >>> c.shape -// (1, 1, 3) -// >>> c -// array([[[1, 3, 5]]]) -// -// An example where `b` is a scalar: -// -// >>> np.inner(np.eye(2), 7) -// array([[7., 0.], -// [0., 7.]]) -// -// -// -//go:linkname Inner py.inner -func Inner(a *py.Object, b *py.Object) *py.Object -// -// min_scalar_type(a, /) -// -// For scalar ``a``, returns the data type with the smallest size -// and smallest scalar kind which can hold its value. For non-scalar -// array ``a``, returns the vector's dtype unmodified. -// -// Floating point values are not demoted to integers, -// and complex values are not demoted to floats. +// shape : int or tuple of int +// Shape of the empty array, e.g., ``(2, 3)`` or ``2``. +// dtype : data-type, optional +// Desired output data-type for the array, e.g, `numpy.int8`. Default is +// `numpy.float64`. +// order : {'C', 'F'}, optional, default: 'C' +// Whether to store multi-dimensional data in row-major +// (C-style) or column-major (Fortran-style) order in +// memory. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. // -// Parameters -// ---------- -// a : scalar or array_like -// The value whose minimal data type is to be found. +// .. versionadded:: 1.20.0 // // Returns // ------- -// out : dtype -// The minimal data type. +// out : ndarray +// Array of uninitialized (arbitrary) data of the given shape, dtype, and +// order. Object arrays will be initialized to None. // // See Also // -------- -// result_type, promote_types, dtype, can_cast -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.min_scalar_type(10) -// dtype('uint8') -// -// >>> np.min_scalar_type(-260) -// dtype('int16') -// -// >>> np.min_scalar_type(3.1) -// dtype('float16') -// -// >>> np.min_scalar_type(1e50) -// dtype('float64') -// -// >>> np.min_scalar_type(np.arange(4,dtype='f8')) -// dtype('float64') -// -// -// -//go:linkname MinScalarType py.min_scalar_type -func MinScalarType(a *py.Object) *py.Object -// -// Calculate the n-th discrete difference along the given axis. -// -// The first difference is given by ``out[i] = a[i+1] - a[i]`` along -// the given axis, higher differences are calculated by using `diff` -// recursively. -// -// Parameters -// ---------- -// a : array_like -// Input array -// n : int, optional -// The number of times values are differenced. If zero, the input -// is returned as-is. -// axis : int, optional -// The axis along which the difference is taken, default is the -// last axis. -// prepend, append : array_like, optional -// Values to prepend or append to `a` along axis prior to -// performing the difference. Scalar values are expanded to -// arrays with length 1 in the direction of axis and the shape -// of the input array in along all other axes. Otherwise the -// dimension and shape must match `a` except along axis. -// -// Returns -// ------- -// diff : ndarray -// The n-th differences. The shape of the output is the same as `a` -// except along `axis` where the dimension is smaller by `n`. The -// type of the output is the same as the type of the difference -// between any two elements of `a`. This is the same as the type of -// `a` in most cases. A notable exception is `datetime64`, which -// results in a `timedelta64` output array. +// empty_like : Return an empty array with shape and type of input. +// ones : Return a new array setting values to one. +// zeros : Return a new array setting values to zero. +// full : Return a new array of given shape filled with value. // -// See Also -// -------- -// gradient, ediff1d, cumsum // // Notes // ----- -// Type is preserved for boolean arrays, so the result will contain -// `False` when consecutive elements are the same and `True` when they -// differ. -// -// For unsigned integer arrays, the results will also be unsigned. This -// should not be surprising, as the result is consistent with -// calculating the difference directly: -// -// >>> u8_arr = np.array([1, 0], dtype=np.uint8) -// >>> np.diff(u8_arr) -// array([255], dtype=uint8) -// >>> u8_arr[1,...] - u8_arr[0,...] -// np.uint8(255) -// -// If this is not desirable, then the array should be cast to a larger -// integer type first: -// -// >>> i16_arr = u8_arr.astype(np.int16) -// >>> np.diff(i16_arr) -// array([-1], dtype=int16) +// `empty`, unlike `zeros`, does not set the array values to zero, +// and may therefore be marginally faster. On the other hand, it requires +// the user to manually set all the values in the array, and should be +// used with caution. // // Examples // -------- -// >>> import numpy as np -// >>> x = np.array([1, 2, 4, 7, 0]) -// >>> np.diff(x) -// array([ 1, 2, 3, -7]) -// >>> np.diff(x, n=2) -// array([ 1, 1, -10]) -// -// >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]]) -// >>> np.diff(x) -// array([[2, 3, 4], -// [5, 1, 2]]) -// >>> np.diff(x, axis=0) -// array([[-1, 2, 0, -2]]) -// -// >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64) -// >>> np.diff(x) -// array([1, 1], dtype='timedelta64[D]') -// +// >>> np.empty([2, 2]) +// array([[ -9.74499359e+001, 6.69583040e-309], +// [ 2.13182611e-314, 3.06959433e-309]]) #uninitialized // +// >>> np.empty([2, 2], dtype=int) +// array([[-1073741821, -1067949133], +// [ 496041986, 19249760]]) #uninitialized // -//go:linkname Diff py.diff -func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, append *py.Object) *py.Object +//go:linkname Empty py.empty +func Empty(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object // -// Return a tuple of coordinate matrices from coordinate vectors. +// Return a list of coordinate matrices from coordinate vectors. // // Make N-D coordinate arrays for vectorized evaluations of // N-D scalar/vector fields over N-D grids, given // one-dimensional coordinate arrays x1, x2,..., xn. // +// .. versionchanged:: 1.9 +// 1-D and 0-D cases are allowed. +// // Parameters // ---------- // x1, x2,..., xn : array_like @@ -10013,16 +8766,19 @@ func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, appen // indexing : {'xy', 'ij'}, optional // Cartesian ('xy', default) or matrix ('ij') indexing of output. // See Notes for more details. +// +// .. versionadded:: 1.7.0 // sparse : bool, optional // If True the shape of the returned coordinate array for dimension *i* // is reduced from ``(N1, ..., Ni, ... Nn)`` to // ``(1, ..., 1, Ni, 1, ..., 1)``. These sparse coordinate grids are -// intended to be used with :ref:`basics.broadcasting`. When all +// intended to be use with :ref:`basics.broadcasting`. When all // coordinates are used in an expression, broadcasting still leads to a // fully-dimensonal result array. // // Default is False. // +// .. versionadded:: 1.7.0 // copy : bool, optional // If False, a view into the original arrays are returned in order to // conserve memory. Default is True. Please note that @@ -10031,9 +8787,11 @@ func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, appen // may refer to a single memory location. If you need to write to the // arrays, make copies first. // +// .. versionadded:: 1.7.0 +// // Returns // ------- -// X1, X2,..., XN : tuple of ndarrays +// X1, X2,..., XN : list of ndarrays // 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' @@ -10068,11 +8826,10 @@ func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, appen // mgrid : Construct a multi-dimensional "meshgrid" using indexing notation. // ogrid : Construct an open multi-dimensional "meshgrid" using indexing // notation. -// :ref:`how-to-index` +// how-to-index // // Examples // -------- -// >>> import numpy as np // >>> nx, ny = (3, 2) // >>> x = np.linspace(0, 1, nx) // >>> y = np.linspace(0, 1, ny) @@ -10126,510 +8883,567 @@ func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, appen // //go:linkname Meshgrid py.meshgrid func Meshgrid(__llgo_va_list ...interface{}) *py.Object -// Fill the main diagonal of the given array of any dimensionality. -// -// For an array `a` with ``a.ndim >= 2``, the diagonal is the list of -// values ``a[i, ..., i]`` with indices ``i`` all identical. This function -// modifies the input array in-place without returning a value. +// Broadcast an array to a new shape. // // Parameters // ---------- -// a : array, at least 2-D. -// Array whose diagonal is to be filled in-place. -// val : scalar or array_like -// Value(s) to write on the diagonal. If `val` is scalar, the value is -// written along the diagonal. If array-like, the flattened `val` is -// written along the diagonal, repeating if necessary to fill all -// diagonal entries. -// -// wrap : bool -// For tall matrices in NumPy version up to 1.6.2, the -// diagonal "wrapped" after N columns. You can have this behavior -// with this option. This affects only tall matrices. -// -// See also -// -------- -// diag_indices, diag_indices_from -// -// Notes -// ----- -// This functionality can be obtained via `diag_indices`, but internally -// this version uses a much faster implementation that never constructs the -// indices and uses simple slicing. -// -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.zeros((3, 3), int) -// >>> np.fill_diagonal(a, 5) -// >>> a -// array([[5, 0, 0], -// [0, 5, 0], -// [0, 0, 5]]) -// -// The same function can operate on a 4-D array: -// -// >>> a = np.zeros((3, 3, 3, 3), int) -// >>> np.fill_diagonal(a, 4) -// -// We only show a few blocks for clarity: -// -// >>> a[0, 0] -// array([[4, 0, 0], -// [0, 0, 0], -// [0, 0, 0]]) -// >>> a[1, 1] -// array([[0, 0, 0], -// [0, 4, 0], -// [0, 0, 0]]) -// >>> a[2, 2] -// array([[0, 0, 0], -// [0, 0, 0], -// [0, 0, 4]]) -// -// The wrap option affects only tall matrices: -// -// >>> # tall matrices no wrap -// >>> a = np.zeros((5, 3), int) -// >>> np.fill_diagonal(a, 4) -// >>> a -// array([[4, 0, 0], -// [0, 4, 0], -// [0, 0, 4], -// [0, 0, 0], -// [0, 0, 0]]) -// -// >>> # tall matrices wrap -// >>> a = np.zeros((5, 3), int) -// >>> np.fill_diagonal(a, 4, wrap=True) -// >>> a -// array([[4, 0, 0], -// [0, 4, 0], -// [0, 0, 4], -// [0, 0, 0], -// [4, 0, 0]]) -// -// >>> # wide matrices -// >>> a = np.zeros((3, 5), int) -// >>> np.fill_diagonal(a, 4, wrap=True) -// >>> a -// array([[4, 0, 0, 0, 0], -// [0, 4, 0, 0, 0], -// [0, 0, 4, 0, 0]]) -// -// The anti-diagonal can be filled by reversing the order of elements -// using either `numpy.flipud` or `numpy.fliplr`. -// -// >>> a = np.zeros((3, 3), int); -// >>> np.fill_diagonal(np.fliplr(a), [1,2,3]) # Horizontal flip -// >>> a -// array([[0, 0, 1], -// [0, 2, 0], -// [3, 0, 0]]) -// >>> np.fill_diagonal(np.flipud(a), [1,2,3]) # Vertical flip -// >>> a -// array([[0, 0, 3], -// [0, 2, 0], -// [1, 0, 0]]) -// -// Note that the order in which the diagonal is filled varies depending -// on the flip function. -// -// -//go:linkname FillDiagonal py.fill_diagonal -func FillDiagonal(a *py.Object, val *py.Object, wrap *py.Object) *py.Object -// -// Remove axes of length one from `a`. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// Selects a subset of the entries of length one in the -// shape. If an axis is selected with shape entry greater than -// one, an error is raised. +// array : array_like +// The array to broadcast. +// shape : tuple or int +// The shape of the desired array. A single integer ``i`` is interpreted +// as ``(i,)``. +// subok : bool, optional +// If True, then sub-classes will be passed-through, otherwise +// the returned array will be forced to be a base-class array (default). // // Returns // ------- -// squeezed : ndarray -// The input array, but with all or a subset of the -// dimensions of length 1 removed. This is always `a` itself -// or a view into `a`. Note that if all axes are squeezed, -// the result is a 0d array and not a scalar. +// broadcast : array +// A readonly view on the original array with the given shape. It is +// typically not contiguous. Furthermore, more than one element of a +// broadcasted array may refer to a single memory location. // // Raises // ------ // ValueError -// If `axis` is not None, and an axis being squeezed is not of length 1 +// If the array is not compatible with the new shape according to NumPy's +// broadcasting rules. // // See Also // -------- -// expand_dims : The inverse operation, adding entries of length one -// reshape : Insert, remove, and combine dimensions, and resize existing ones +// broadcast +// broadcast_arrays +// broadcast_shapes +// +// Notes +// ----- +// .. versionadded:: 1.10.0 // // Examples // -------- -// >>> import numpy as np -// >>> x = np.array([[[0], [1], [2]]]) -// >>> x.shape -// (1, 3, 1) -// >>> np.squeeze(x).shape -// (3,) -// >>> np.squeeze(x, axis=0).shape -// (3, 1) -// >>> np.squeeze(x, axis=1).shape -// Traceback (most recent call last): -// ... -// ValueError: cannot select an axis to squeeze out which has size -// not equal to one -// >>> np.squeeze(x, axis=2).shape -// (1, 3) -// >>> x = np.array([[1234]]) -// >>> x.shape -// (1, 1) -// >>> np.squeeze(x) -// array(1234) # 0d array -// >>> np.squeeze(x).shape -// () -// >>> np.squeeze(x)[()] -// 1234 -// +// >>> x = np.array([1, 2, 3]) +// >>> np.broadcast_to(x, (3, 3)) +// array([[1, 2, 3], +// [1, 2, 3], +// [1, 2, 3]]) // // -//go:linkname Squeeze py.squeeze -func Squeeze(a *py.Object, axis *py.Object) *py.Object -// fromiter(iter, dtype, count=-1, *, like=None) +//go:linkname BroadcastTo py.broadcast_to +func BroadcastTo(array *py.Object, shape *py.Object, subok *py.Object) *py.Object // -// Create a new 1-dimensional array from an iterable object. +// Compute the bi-dimensional histogram of two data samples. // // Parameters // ---------- -// iter : iterable object -// 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). +// x : array_like, shape (N,) +// An array containing the x coordinates of the points to be +// histogrammed. +// y : array_like, shape (N,) +// An array containing the y coordinates of the points to be +// histogrammed. +// bins : int or array_like or [int, int] or [array, array], optional +// The bin specification: // -// count : int, optional -// The number of items to read from *iterable*. The default is -1, -// which means all data is read. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// * If int, the number of bins for the two dimensions (nx=ny=bins). +// * If array_like, the bin edges for the two dimensions +// (x_edges=y_edges=bins). +// * If [int, int], the number of bins in each dimension +// (nx, ny = bins). +// * If [array, array], the bin edges in each dimension +// (x_edges, y_edges = bins). +// * A combination [int, array] or [array, int], where int +// is the number of bins and array is the bin edges. // -// .. versionadded:: 1.20.0 +// range : array_like, shape(2,2), optional +// The leftmost and rightmost edges of the bins along each dimension +// (if not specified explicitly in the `bins` parameters): +// ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range +// will be considered outliers and not tallied in the histogram. +// density : bool, optional +// 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``. +// 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 `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 // ------- -// out : ndarray -// The output array. +// H : ndarray, shape(nx, ny) +// The bi-dimensional histogram of samples `x` and `y`. Values in `x` +// are histogrammed along the first dimension and values in `y` are +// histogrammed along the second dimension. +// xedges : ndarray, shape(nx+1,) +// The bin edges along the first dimension. +// yedges : ndarray, shape(ny+1,) +// The bin edges along the second dimension. +// +// See Also +// -------- +// histogram : 1D histogram +// histogramdd : Multidimensional histogram // // Notes // ----- -// Specify `count` to improve performance. It allows ``fromiter`` to -// pre-allocate the output array, instead of resizing it on demand. +// 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. +// +// Please note that the histogram does not follow the Cartesian convention +// where `x` values are on the abscissa and `y` values on the ordinate +// axis. Rather, `x` is histogrammed along the first dimension of the +// array (vertical), and `y` along the second dimension of the array +// (horizontal). This ensures compatibility with `histogramdd`. // // Examples // -------- -// >>> import numpy as np -// >>> iterable = (x*x for x in range(5)) -// >>> np.fromiter(iterable, float) -// array([ 0., 1., 4., 9., 16.]) +// >>> from matplotlib.image import NonUniformImage +// >>> import matplotlib.pyplot as plt // -// A carefully constructed subarray dtype will lead to higher dimensional -// results: +// Construct a 2-D histogram with variable bin width. First define the bin +// edges: // -// >>> 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]]) +// >>> xedges = [0, 1, 3, 5] +// >>> yedges = [0, 2, 3, 4, 6] // -//go:linkname Fromiter py.fromiter -func Fromiter(iter *py.Object, dtype *py.Object, count *py.Object) *py.Object -// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Angle in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in degrees. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : Convert angles from degrees to radians. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// rad2deg(x) is ``180 * x / pi``. -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.rad2deg(np.pi/2) -// 90.0 -// -//go:linkname Rad2deg py.rad2deg -func Rad2deg(x *py.Object, out *py.Object) *py.Object -// -// Expand the shape of an array. +// Next we create a histogram H with random bin content: // -// Insert a new axis that will appear at the `axis` position in the expanded -// array shape. +// >>> x = np.random.normal(2, 1, 100) +// >>> y = np.random.normal(1, 1, 100) +// >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) +// >>> # Histogram does not follow Cartesian convention (see Notes), +// >>> # therefore transpose H for visualization purposes. +// >>> H = H.T // -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int or tuple of ints -// Position in the expanded axes where the new axis (or axes) is placed. +// :func:`imshow ` can only display square bins: // -// .. deprecated:: 1.13.0 -// Passing an axis where ``axis > a.ndim`` will be treated as -// ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will -// be treated as ``axis == 0``. This behavior is deprecated. +// >>> fig = plt.figure(figsize=(7, 3)) +// >>> ax = fig.add_subplot(131, title='imshow: square bins') +// >>> plt.imshow(H, interpolation='nearest', origin='lower', +// ... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) +// // -// Returns -// ------- -// result : ndarray -// View of `a` with the number of dimensions increased. +// :func:`pcolormesh ` can display actual edges: // -// See Also -// -------- -// squeeze : The inverse operation, removing singleton dimensions -// reshape : Insert, remove, and combine dimensions, and resize existing ones -// atleast_1d, atleast_2d, atleast_3d +// >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges', +// ... aspect='equal') +// >>> X, Y = np.meshgrid(xedges, yedges) +// >>> ax.pcolormesh(X, Y, H) +// // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([1, 2]) -// >>> x.shape -// (2,) +// :class:`NonUniformImage ` can be used to +// display actual bin edges with interpolation: // -// The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``: +// >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated', +// ... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]]) +// >>> im = NonUniformImage(ax, interpolation='bilinear') +// >>> xcenters = (xedges[:-1] + xedges[1:]) / 2 +// >>> ycenters = (yedges[:-1] + yedges[1:]) / 2 +// >>> im.set_data(xcenters, ycenters, H) +// >>> ax.add_image(im) +// >>> plt.show() // -// >>> y = np.expand_dims(x, axis=0) -// >>> y -// array([[1, 2]]) -// >>> y.shape -// (1, 2) +// It is also possible to construct a 2-D histogram without specifying bin +// edges: // -// The following is equivalent to ``x[:, np.newaxis]``: +// >>> # Generate non-symmetric test data +// >>> n = 10000 +// >>> x = np.linspace(1, 100, n) +// >>> y = 2*np.log(x) + np.random.rand(n) - 0.5 +// >>> # Compute 2d histogram. Note the order of x/y and xedges/yedges +// >>> H, yedges, xedges = np.histogram2d(y, x, bins=20) // -// >>> y = np.expand_dims(x, axis=1) -// >>> y -// array([[1], -// [2]]) -// >>> y.shape -// (2, 1) +// Now we can plot the histogram using +// :func:`pcolormesh `, and a +// :func:`hexbin ` for comparison. // -// ``axis`` may also be a tuple: +// >>> # Plot histogram using pcolormesh +// >>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True) +// >>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow') +// >>> ax1.plot(x, 2*np.log(x), 'k-') +// >>> ax1.set_xlim(x.min(), x.max()) +// >>> ax1.set_ylim(y.min(), y.max()) +// >>> ax1.set_xlabel('x') +// >>> ax1.set_ylabel('y') +// >>> ax1.set_title('histogram2d') +// >>> ax1.grid() // -// >>> y = np.expand_dims(x, axis=(0, 1)) -// >>> y -// array([[[1, 2]]]) +// >>> # Create hexbin plot for comparison +// >>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow') +// >>> ax2.plot(x, 2*np.log(x), 'k-') +// >>> ax2.set_title('hexbin') +// >>> ax2.set_xlim(x.min(), x.max()) +// >>> ax2.set_xlabel('x') +// >>> ax2.grid() // -// >>> y = np.expand_dims(x, axis=(2, 0)) -// >>> y -// array([[[1], -// [2]]]) +// >>> plt.show() // -// Note that some examples may use ``None`` instead of ``np.newaxis``. These -// are the same objects: // -// >>> np.newaxis is None -// True +//go:linkname Histogram2d py.histogram2d +func Histogram2d(x *py.Object, y *py.Object, bins *py.Object, Range *py.Object, density *py.Object, weights *py.Object) *py.Object // +// Return an antiderivative (indefinite integral) of a polynomial. // +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. // -//go:linkname ExpandDims py.expand_dims -func ExpandDims(a *py.Object, axis *py.Object) *py.Object +// The returned order `m` antiderivative `P` of polynomial `p` satisfies +// :math:`\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1` +// integration constants `k`. The constants determine the low-order +// polynomial part // -// Reverse the order of elements along axis 1 (left/right). +// .. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1} // -// For a 2-D array, this flips the entries in each row in the left/right -// direction. Columns are preserved, but appear in a different order than -// before. +// of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`. // // Parameters // ---------- -// m : array_like -// Input array, must be at least 2-D. +// p : array_like or poly1d +// Polynomial to integrate. +// A sequence is interpreted as polynomial coefficients, see `poly1d`. +// m : int, optional +// Order of the antiderivative. (Default: 1) +// k : list of `m` scalars or scalar, optional +// Integration constants. They are given in the order of integration: +// those corresponding to highest-order terms come first. // -// Returns -// ------- -// f : ndarray -// A view of `m` with the columns reversed. Since a view -// is returned, this operation is :math:`\mathcal O(1)`. +// If ``None`` (default), all constants are assumed to be zero. +// If `m = 1`, a single scalar can be given instead of a list. // // See Also // -------- -// flipud : Flip array in the up/down direction. -// flip : Flip array in one or more dimensions. -// rot90 : Rotate array counterclockwise. -// -// Notes -// ----- -// Equivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``. -// Requires the array to be at least 2-D. +// polyder : derivative of a polynomial +// poly1d.integ : equivalent method // // Examples // -------- -// >>> import numpy as np -// >>> A = np.diag([1.,2.,3.]) -// >>> A -// array([[1., 0., 0.], -// [0., 2., 0.], -// [0., 0., 3.]]) -// >>> np.fliplr(A) -// array([[0., 0., 1.], -// [0., 2., 0.], -// [3., 0., 0.]]) +// The defining property of the antiderivative: // -// >>> rng = np.random.default_rng() -// >>> A = rng.normal(size=(2,3,5)) -// >>> np.all(np.fliplr(A) == A[:,::-1,...]) +// >>> p = np.poly1d([1,1,1]) +// >>> P = np.polyint(p) +// >>> P +// poly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary +// >>> np.polyder(P) == p // True // +// The integration constants default to zero, but can be specified: +// +// >>> P = np.polyint(p, 3) +// >>> P(0) +// 0.0 +// >>> np.polyder(P)(0) +// 0.0 +// >>> np.polyder(P, 2)(0) +// 0.0 +// >>> P = np.polyint(p, 3, k=[6,5,3]) +// >>> P +// poly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may vary +// +// Note that 3 = 6 / 2!, and that the constants are given in the order of +// integrations. Constant of the highest-order polynomial term comes first: +// +// >>> np.polyder(P, 2)(0) +// 6.0 +// >>> np.polyder(P, 1)(0) +// 5.0 +// >>> P(0) +// 3.0 +// // // -//go:linkname Fliplr py.fliplr -func Fliplr(m *py.Object) *py.Object +//go:linkname Polyint py.polyint +func Polyint(p *py.Object, m *py.Object, k *py.Object) *py.Object // -// Returns a bool array, where True if input element is complex. +// Deprecates a function and includes the deprecation in its docstring. // -// What is tested is whether the input has a non-zero imaginary part, not if -// the input type is complex. +// This function is used as a decorator. It returns an object that can be +// used to issue a DeprecationWarning, by passing the to-be decorated +// function as argument, this adds warning to the to-be decorated function's +// docstring and returns the new function object. +// +// See Also +// -------- +// deprecate : Decorate a function such that it issues a `DeprecationWarning` // // Parameters // ---------- -// x : array_like -// Input array. +// msg : str +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. // // Returns // ------- -// out : ndarray of bools -// Output array. +// obj : object +// +// +// +//go:linkname DeprecateWithDoc py.deprecate_with_doc +func DeprecateWithDoc(msg *py.Object) *py.Object +// +// Return the sum of array elements over a given axis treating Not a +// Numbers (NaNs) as zero. +// +// In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or +// empty. In later versions zero is returned. +// +// Parameters +// ---------- +// a : array_like +// Array containing numbers whose sum is desired. If `a` is not an +// array, a conversion is attempted. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the sum is computed. The default is to compute the +// sum of the flattened array. +// dtype : data-type, optional +// The type of the returned array and of the accumulator in which the +// elements are summed. By default, the dtype of `a` is used. An +// exception is when `a` has an integer type with less precision than +// the platform (u)intp. In that case, the default will be either +// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 +// bits. For inexact inputs, dtype must be inexact. +// +// .. versionadded:: 1.8.0 +// out : ndarray, optional +// Alternate output array in which to place the result. The default +// is ``None``. If provided, it must have the same shape as the +// expected output, but the type will be cast if necessary. See +// :ref:`ufuncs-output-type` for more details. The casting of NaN to integer +// can yield unexpected results. +// +// .. versionadded:: 1.8.0 +// 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`. +// +// +// If the value is anything but the default, then +// `keepdims` will be passed through to the `mean` or `sum` methods +// of sub-classes of `ndarray`. If the sub-classes methods +// does not implement `keepdims` any exceptions will be raised. +// +// .. versionadded:: 1.8.0 +// initial : scalar, optional +// Starting value for the sum. See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.22.0 +// where : array_like of bool, optional +// Elements to include in the sum. See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.22.0 +// +// Returns +// ------- +// nansum : ndarray. +// A new array holding the result is returned unless `out` is +// specified, in which it is returned. The result has the same +// size as `a`, and the same shape as `a` if `axis` is not None +// or `a` is a 1-d array. // // See Also // -------- -// isreal -// iscomplexobj : Return True if x is a complex type or an array of complex -// numbers. +// numpy.sum : Sum across array propagating NaNs. +// isnan : Show which elements are NaN. +// isfinite : Show which elements are not NaN or +/-inf. +// +// Notes +// ----- +// If both positive and negative infinity are present, the sum will be Not +// A Number (NaN). // // Examples // -------- -// >>> import numpy as np -// >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]) -// array([ True, False, False, False, False, True]) +// >>> np.nansum(1) +// 1 +// >>> np.nansum([1]) +// 1 +// >>> np.nansum([1, np.nan]) +// 1.0 +// >>> a = np.array([[1, 1], [1, np.nan]]) +// >>> np.nansum(a) +// 3.0 +// >>> np.nansum(a, axis=0) +// array([2., 1.]) +// >>> np.nansum([1, np.nan, np.inf]) +// inf +// >>> np.nansum([1, np.nan, np.NINF]) +// -inf +// >>> from numpy.testing import suppress_warnings +// >>> with suppress_warnings() as sup: +// ... sup.filter(RuntimeWarning) +// ... np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present +// nan // // // -//go:linkname Iscomplex py.iscomplex -func Iscomplex(x *py.Object) *py.Object +//go:linkname Nansum py.nansum +func Nansum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// zeros(shape, dtype=float, order='C', *, like=None) // -// Print information about various resources in the system -// including available intrinsic support and BLAS/LAPACK library -// in use +// Return a new array of given shape and type, filled with zeros. // -// .. versionadded:: 1.24.0 +// Parameters +// ---------- +// shape : int or tuple of ints +// Shape of the new array, e.g., ``(2, 3)`` or ``2``. +// dtype : data-type, optional +// The desired data-type for the array, e.g., `numpy.int8`. Default is +// `numpy.float64`. +// order : {'C', 'F'}, optional, default: 'C' +// Whether to store multi-dimensional data in row-major +// (C-style) or column-major (Fortran-style) order in +// memory. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// Array of zeros with the given shape, dtype, and order. // // See Also // -------- -// show_config : Show libraries in the system on which NumPy was built. +// zeros_like : Return an array of zeros with shape and type of input. +// empty : Return a new uninitialized array. +// ones : Return a new array setting values to one. +// full : Return a new array of given shape filled with value. // -// Notes -// ----- -// 1. Information is derived with the help of `threadpoolctl `_ -// library if available. -// 2. SIMD related information is derived from ``__cpu_features__``, -// ``__cpu_baseline__`` and ``__cpu_dispatch__`` +// Examples +// -------- +// >>> np.zeros(5) +// array([ 0., 0., 0., 0., 0.]) +// +// >>> np.zeros((5,), dtype=int) +// array([0, 0, 0, 0, 0]) +// +// >>> np.zeros((2, 1)) +// array([[ 0.], +// [ 0.]]) // +// >>> s = (2,2) +// >>> np.zeros(s) +// array([[ 0., 0.], +// [ 0., 0.]]) // +// >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype +// array([(0, 0), (0, 0)], +// dtype=[('x', '= 2``. -// Copies are avoided where possible, and views with two or more -// dimensions are returned. +// reshaped_array : ndarray +// This will be a new view object if possible; otherwise, it will +// be a copy. Note there is no guarantee of the *memory layout* (C- or +// Fortran- contiguous) of the returned array. // // See Also // -------- -// atleast_1d, atleast_3d +// ndarray.reshape : Equivalent method. +// +// Notes +// ----- +// It is not always possible to change the shape of an array without copying +// the data. +// +// The `order` keyword gives the index ordering both for *fetching* the values +// from `a`, and then *placing* the values into the output array. +// For example, let's say you have an array: +// +// >>> a = np.arange(6).reshape((3, 2)) +// >>> a +// array([[0, 1], +// [2, 3], +// [4, 5]]) +// +// You can think of reshaping as first raveling the array (using the given +// index order), then inserting the elements from the raveled array into the +// new array using the same kind of index ordering as was used for the +// raveling. +// +// >>> np.reshape(a, (2, 3)) # C-like index ordering +// array([[0, 1, 2], +// [3, 4, 5]]) +// >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape +// array([[0, 1, 2], +// [3, 4, 5]]) +// >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering +// array([[0, 4, 3], +// [2, 1, 5]]) +// >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F') +// array([[0, 4, 3], +// [2, 1, 5]]) // // Examples // -------- -// >>> import numpy as np -// >>> np.atleast_2d(3.0) -// array([[3.]]) -// -// >>> x = np.arange(3.0) -// >>> np.atleast_2d(x) -// array([[0., 1., 2.]]) -// >>> np.atleast_2d(x).base is x -// True +// >>> a = np.array([[1,2,3], [4,5,6]]) +// >>> np.reshape(a, 6) +// array([1, 2, 3, 4, 5, 6]) +// >>> np.reshape(a, 6, order='F') +// array([1, 4, 2, 5, 3, 6]) // -// >>> np.atleast_2d(1, [1, 2], [[1, 2]]) -// (array([[1]]), array([[1, 2]]), array([[1, 2]])) +// >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 +// array([[1, 2], +// [3, 4], +// [5, 6]]) // // +//go:linkname Reshape py.reshape +func Reshape(a *py.Object, newshape *py.Object, order *py.Object) *py.Object +// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname Atleast2d py.atleast_2d -func Atleast2d(__llgo_va_list ...interface{}) *py.Object -// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Logarithm of the sum of exponentiations of the inputs in base-2. // -// Calculate ``exp(x) - 1`` for all elements in the array. +// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine +// learning when the calculated probabilities of events may be so small as +// to exceed the range of normal floating point numbers. In such cases +// the base-2 logarithm of the calculated probability can be used instead. +// This function allows adding probabilities stored in such a fashion. // // Parameters // ---------- -// x : array_like +// x1, x2 : array_like // Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -10648,454 +9462,391 @@ func Atleast2d(__llgo_va_list ...interface{}) *py.Object // // Returns // ------- -// out : ndarray or scalar -// Element-wise exponential minus one: ``out = exp(x) - 1``. -// This is a scalar if `x` is a scalar. +// result : ndarray +// Base-2 logarithm of ``2**x1 + 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// log1p : ``log(1 + x)``, the inverse of expm1. -// +// logaddexp: Logarithm of the sum of exponentiations of the inputs. // // Notes // ----- -// This function provides greater precision than ``exp(x) - 1`` -// for small values of ``x``. +// .. versionadded:: 1.3.0 // // Examples // -------- +// >>> prob1 = np.log2(1e-50) +// >>> prob2 = np.log2(2.5e-50) +// >>> prob12 = np.logaddexp2(prob1, prob2) +// >>> prob1, prob2, prob12 +// (-166.09640474436813, -164.77447664948076, -164.28904982231052) +// >>> 2**prob12 +// 3.4999999999999914e-50 // -// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to -// about 32 significant digits. This example shows the superiority of -// expm1 in this case. -// -// >>> import numpy as np -// >>> np.expm1(1e-10) -// 1.00000000005e-10 -// >>> np.exp(1e-10) - 1 -// 1.000000082740371e-10 -// -//go:linkname Expm1 py.expm1 -func Expm1(x *py.Object, out *py.Object) *py.Object +//go:linkname Logaddexp2 py.logaddexp2 +func Logaddexp2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Return the identity array. +// Return the gradient of an N-dimensional array. // -// The identity array is a square array with ones on -// the main diagonal. +// The gradient is computed using second order accurate central differences +// in the interior points and either first or second order accurate one-sides +// (forward or backwards) differences at the boundaries. +// The returned gradient hence has the same shape as the input array. // // Parameters // ---------- -// n : int -// Number of rows (and columns) in `n` x `n` output. -// dtype : data-type, optional -// Data-type of the output. Defaults to ``float``. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// f : array_like +// An N-dimensional array containing samples of a scalar function. +// varargs : list of scalar or array, optional +// Spacing between f values. Default unitary spacing for all dimensions. +// Spacing can be specified using: // -// .. versionadded:: 1.20.0 +// 1. single scalar to specify a sample distance for all dimensions. +// 2. N scalars to specify a constant sample distance for each dimension. +// i.e. `dx`, `dy`, `dz`, ... +// 3. N arrays to specify the coordinates of the values along each +// dimension of F. The length of the array must match the size of +// the corresponding dimension +// 4. Any combination of N scalars/arrays with the meaning of 2. and 3. +// +// If `axis` is given, the number of varargs must equal the number of axes. +// Default: 1. +// +// edge_order : {1, 2}, optional +// Gradient is calculated using N-th order accurate differences +// at the boundaries. Default: 1. +// +// .. versionadded:: 1.9.1 +// +// axis : None or int or tuple of ints, optional +// Gradient is calculated only along the given axis or axes +// The default (axis = None) is to calculate the gradient for all the axes +// of the input array. axis may be negative, in which case it counts from +// the last to the first axis. +// +// .. versionadded:: 1.11.0 // // Returns // ------- -// out : ndarray -// `n` x `n` array with its main diagonal set to one, -// and all other elements 0. +// gradient : ndarray or list of ndarray +// A list of ndarrays (or a single ndarray if there is only one dimension) +// corresponding to the derivatives of f with respect to each dimension. +// Each derivative has the same shape as f. // // Examples // -------- -// >>> import numpy as np -// >>> np.identity(3) -// array([[1., 0., 0.], -// [0., 1., 0.], -// [0., 0., 1.]]) +// >>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float) +// >>> np.gradient(f) +// array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) +// >>> np.gradient(f, 2) +// array([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ]) // +// Spacing can be also specified with an array that represents the coordinates +// of the values F along the dimensions. +// For instance a uniform spacing: // +// >>> x = np.arange(f.size) +// >>> np.gradient(f, x) +// array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) // -//go:linkname Identity py.identity -func Identity(n *py.Object, dtype *py.Object) *py.Object -// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Or a non uniform one: // -// Return the truth value of (x1 <= x2) element-wise. +// >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float) +// >>> np.gradient(f, x) +// array([1. , 3. , 3.5, 6.7, 6.9, 2.5]) // -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// For two dimensional arrays, the return will be two arrays ordered by +// axis. In this example the first array stands for the gradient in +// rows and the second one in columns direction: // -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. +// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float)) +// [array([[ 2., 2., -1.], +// [ 2., 2., -1.]]), array([[1. , 2.5, 4. ], +// [1. , 1. , 1. ]])] // -// See Also -// -------- -// greater, less, greater_equal, equal, not_equal +// In this example the spacing is also specified: +// uniform for axis=0 and non uniform for axis=1 // -// Examples -// -------- -// >>> import numpy as np -// >>> np.less_equal([4, 2, 1], [2, 2, 2]) -// array([False, True, True]) +// >>> dx = 2. +// >>> y = [1., 1.5, 3.5] +// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y) +// [array([[ 1. , 1. , -0.5], +// [ 1. , 1. , -0.5]]), array([[2. , 2. , 2. ], +// [2. , 1.7, 0.5]])] // -// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on -// ndarrays. +// It is possible to specify how boundaries are treated using `edge_order` // -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a <= b -// array([False, True, True]) +// >>> x = np.array([0, 1, 2, 3, 4]) +// >>> f = x**2 +// >>> np.gradient(f, edge_order=1) +// array([1., 2., 4., 6., 7.]) +// >>> np.gradient(f, edge_order=2) +// array([0., 2., 4., 6., 8.]) // -//go:linkname LessEqual py.less_equal -func LessEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// The `axis` keyword can be used to specify a subset of axes of which the +// gradient is calculated // -// `trapz` is deprecated in NumPy 2.0. +// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0) +// array([[ 2., 2., -1.], +// [ 2., 2., -1.]]) // -// Please use `trapezoid` instead, or one of the numerical integration -// functions in `scipy.integrate`. +// Notes +// ----- +// Assuming that :math:`f\in C^{3}` (i.e., :math:`f` has at least 3 continuous +// derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we +// minimize the "consistency error" :math:`\eta_{i}` between the true gradient +// and its estimate from a linear combination of the neighboring grid-points: // +// .. math:: // -//go:linkname Trapz py.trapz -func Trapz(y *py.Object, x *py.Object, dx *py.Object, axis *py.Object) *py.Object +// \eta_{i} = f_{i}^{\left(1\right)} - +// \left[ \alpha f\left(x_{i}\right) + +// \beta f\left(x_{i} + h_{d}\right) + +// \gamma f\left(x_{i}-h_{s}\right) +// \right] // -// Return the cumulative sum of array elements over a given axis treating Not a -// Numbers (NaNs) as zero. The cumulative sum does not change when NaNs are -// encountered and leading NaNs are replaced by zeros. +// By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})` +// with their Taylor series expansion, this translates into solving +// the following the linear system: // -// Zeros are returned for slices that are all-NaN or empty. +// .. math:: // -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative sum is computed. The default -// (None) is to compute the cumsum over the flattened array. -// dtype : dtype, optional -// Type of the returned array and of the accumulator in which the -// elements are summed. If `dtype` is not specified, it defaults -// to the dtype of `a`, unless `a` has an integer dtype with a -// precision less than that of the default platform integer. In -// that case, the default platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type will be cast if necessary. See :ref:`ufuncs-output-type` for -// more details. +// \left\{ +// \begin{array}{r} +// \alpha+\beta+\gamma=0 \\ +// \beta h_{d}-\gamma h_{s}=1 \\ +// \beta h_{d}^{2}+\gamma h_{s}^{2}=0 +// \end{array} +// \right. // -// Returns -// ------- -// nancumsum : ndarray. -// A new array holding the result is returned unless `out` is -// specified, in which it is returned. The result has the same -// size as `a`, and the same shape as `a` if `axis` is not None -// or `a` is a 1-d array. +// The resulting approximation of :math:`f_{i}^{(1)}` is the following: // -// See Also -// -------- -// numpy.cumsum : Cumulative sum across array propagating NaNs. -// isnan : Show which elements are NaN. +// .. math:: // -// Examples -// -------- -// >>> import numpy as np -// >>> np.nancumsum(1) -// array([1]) -// >>> np.nancumsum([1]) -// array([1]) -// >>> np.nancumsum([1, np.nan]) -// array([1., 1.]) -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nancumsum(a) -// array([1., 3., 6., 6.]) -// >>> np.nancumsum(a, axis=0) -// array([[1., 2.], -// [4., 2.]]) -// >>> np.nancumsum(a, axis=1) -// array([[1., 3.], -// [3., 3.]]) +// \hat f_{i}^{(1)} = +// \frac{ +// h_{s}^{2}f\left(x_{i} + h_{d}\right) +// + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right) +// - h_{d}^{2}f\left(x_{i}-h_{s}\right)} +// { h_{s}h_{d}\left(h_{d} + h_{s}\right)} +// + \mathcal{O}\left(\frac{h_{d}h_{s}^{2} +// + h_{s}h_{d}^{2}}{h_{d} +// + h_{s}}\right) // +// It is worth noting that if :math:`h_{s}=h_{d}` +// (i.e., data are evenly spaced) +// we find the standard second order approximation: // +// .. math:: // -//go:linkname Nancumsum py.nancumsum -func Nancumsum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object +// \hat f_{i}^{(1)}= +// \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h} +// + \mathcal{O}\left(h^{2}\right) // -// Return selected slices of an array along given axis. +// With a similar procedure the forward/backward approximations used for +// boundaries can be derived. // -// When working along a given axis, a slice along that axis is returned in -// `output` for each index where `condition` evaluates to True. When -// working on a 1-D array, `compress` is equivalent to `extract`. +// References +// ---------- +// .. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics +// (Texts in Applied Mathematics). New York: Springer. +// .. [2] Durran D. R. (1999) Numerical Methods for Wave Equations +// in Geophysical Fluid Dynamics. New York: Springer. +// .. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on +// Arbitrarily Spaced Grids, +// Mathematics of Computation 51, no. 184 : 699-706. +// `PDF `_. +// +// +//go:linkname Gradient py.gradient +func Gradient(f *py.Object, __llgo_va_list ...interface{}) *py.Object +// +// Kronecker product of two arrays. +// +// Computes the Kronecker product, a composite array made of blocks of the +// second array scaled by the first. // // Parameters // ---------- -// condition : 1-D array of bools -// Array that selects which entries to return. If len(condition) -// is less than the size of `a` along the given axis, then output is -// truncated to the length of the condition array. -// a : array_like -// Array from which to extract a part. -// axis : int, optional -// Axis along which to take slices. If None (default), work on the -// flattened array. -// out : ndarray, optional -// Output array. Its type is preserved and it must be of the right -// shape to hold the output. +// a, b : array_like // // Returns // ------- -// compressed_array : ndarray -// A copy of `a` without the slices along axis for which `condition` -// is false. +// out : ndarray // // See Also // -------- -// take, choose, diag, diagonal, select -// ndarray.compress : Equivalent method in ndarray -// extract : Equivalent method when working on 1-D arrays -// :ref:`ufuncs-output-type` +// outer : The outer product // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4], [5, 6]]) -// >>> a -// array([[1, 2], -// [3, 4], -// [5, 6]]) -// >>> np.compress([0, 1], a, axis=0) -// array([[3, 4]]) -// >>> np.compress([False, True, True], a, axis=0) -// array([[3, 4], -// [5, 6]]) -// >>> np.compress([False, True], a, axis=1) -// array([[2], -// [4], -// [6]]) +// Notes +// ----- +// The function assumes that the number of dimensions of `a` and `b` +// are the same, if necessary prepending the smallest with ones. +// If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``, +// the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``. +// The elements are products of elements from `a` and `b`, organized +// explicitly by:: // -// Working on the flattened array does not return slices along an axis but -// selects elements. +// kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN] // -// >>> np.compress([False, True], a) -// array([2]) +// where:: // +// kt = it * st + jt, t = 0,...,N // +// In the common 2-D case (N=1), the block structure can be visualized:: // -//go:linkname Compress py.compress -func Compress(condition *py.Object, a *py.Object, axis *py.Object, out *py.Object) *py.Object +// [[ a[0,0]*b, a[0,1]*b, ... , a[0,-1]*b ], +// [ ... ... ], +// [ a[-1,0]*b, a[-1,1]*b, ... , a[-1,-1]*b ]] // -// Return the number of dimensions of an array. // -// Parameters -// ---------- -// a : array_like -// Input array. If it is not already an ndarray, a conversion is -// attempted. +// Examples +// -------- +// >>> np.kron([1,10,100], [5,6,7]) +// array([ 5, 6, 7, ..., 500, 600, 700]) +// >>> np.kron([5,6,7], [1,10,100]) +// array([ 5, 50, 500, ..., 7, 70, 700]) // -// Returns -// ------- -// number_of_dimensions : int -// The number of dimensions in `a`. Scalars are zero-dimensional. +// >>> np.kron(np.eye(2), np.ones((2,2))) +// array([[1., 1., 0., 0.], +// [1., 1., 0., 0.], +// [0., 0., 1., 1.], +// [0., 0., 1., 1.]]) // -// See Also -// -------- -// ndarray.ndim : equivalent method -// shape : dimensions of array -// ndarray.shape : dimensions of array +// >>> a = np.arange(100).reshape((2,5,2,5)) +// >>> b = np.arange(24).reshape((2,3,4)) +// >>> c = np.kron(a,b) +// >>> c.shape +// (2, 10, 6, 20) +// >>> I = (1,3,0,2) +// >>> J = (0,2,1) +// >>> J1 = (0,) + J # extend to ndim=4 +// >>> S1 = (1,) + b.shape +// >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1)) +// >>> c[K] == a[I]*b[J] +// True // -// Examples -// -------- -// >>> import numpy as np -// >>> np.ndim([[1,2,3],[4,5,6]]) -// 2 -// >>> np.ndim(np.array([[1,2,3],[4,5,6]])) -// 2 -// >>> np.ndim(1) -// 0 // // +//go:linkname Kron py.kron +func Kron(a *py.Object, b *py.Object) *py.Object // -//go:linkname Ndim py.ndim -func Ndim(__llgo_va_list ...interface{}) *py.Object -// Save several arrays into a single file in uncompressed ``.npz`` format. +// inner(a, b, /) // -// Provide arrays as keyword arguments to store them under the -// corresponding name in the output file: ``savez(fn, x=x, y=y)``. +// Inner product of two arrays. // -// If arrays are specified as positional arguments, i.e., ``savez(fn, -// x, y)``, their names will be `arr_0`, `arr_1`, etc. +// Ordinary inner product of vectors for 1-D arrays (without complex +// conjugation), in higher dimensions a sum product over the last axes. // // Parameters // ---------- -// file : file, str, or pathlib.Path -// Either the filename (string) or an open file (file-like object) -// where the data will be saved. If file is a string or a Path, the -// ``.npz`` extension will be appended to the filename if it is not -// already there. -// args : Arguments, optional -// Arrays to save to the file. Please use keyword arguments (see -// `kwds` below) to assign names to arrays. Arrays specified as -// args will be named "arr_0", "arr_1", and so on. -// allow_pickle : bool, optional -// Allow saving object arrays using Python pickles. Reasons for -// disallowing pickles include security (loading pickled data can execute -// arbitrary code) and portability (pickled objects may not be loadable -// on different Python installations, for example if the stored objects -// require libraries that are not available, and not all pickled data is -// compatible between different versions of Python). -// Default: True -// kwds : Keyword arguments, optional -// Arrays to save to the file. Each array will be saved to the -// output file with its corresponding keyword name. +// a, b : array_like +// If `a` and `b` are nonscalar, their last dimensions must match. // // Returns // ------- -// None +// out : ndarray +// If `a` and `b` are both +// scalars or both 1-D arrays then a scalar is returned; otherwise +// an array is returned. +// ``out.shape = (*a.shape[:-1], *b.shape[:-1])`` +// +// Raises +// ------ +// ValueError +// If both `a` and `b` are nonscalar and their last dimensions have +// different sizes. // // See Also // -------- -// save : Save a single array to a binary file in NumPy format. -// savetxt : Save an array to a file as plain text. -// savez_compressed : Save several arrays into a compressed ``.npz`` archive +// tensordot : Sum products over arbitrary axes. +// dot : Generalised matrix product, using second last dimension of `b`. +// einsum : Einstein summation convention. // // Notes // ----- -// The ``.npz`` file format is a zipped archive of files named after the -// variables they contain. The archive is not compressed and each file -// in the archive contains one variable in ``.npy`` format. For a -// description of the ``.npy`` format, see :py:mod:`numpy.lib.format`. +// For vectors (1-D arrays) it computes the ordinary inner-product:: // -// When opening the saved ``.npz`` file with `load` a `~lib.npyio.NpzFile` -// object is returned. This is a dictionary-like object which can be queried -// for its list of arrays (with the ``.files`` attribute), and for the arrays -// themselves. +// np.inner(a, b) = sum(a[:]*b[:]) // -// Keys passed in `kwds` are used as filenames inside the ZIP archive. -// Therefore, keys should be valid filenames; e.g., avoid keys that begin with -// ``/`` or contain ``.``. +// More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``:: // -// When naming variables with keyword arguments, it is not possible to name a -// variable ``file``, as this would cause the ``file`` argument to be defined -// twice in the call to ``savez``. +// np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1)) +// +// or explicitly:: +// +// np.inner(a, b)[i0,...,ir-2,j0,...,js-2] +// = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:]) +// +// In addition `a` or `b` may be scalars, in which case:: +// +// np.inner(a,b) = a*b // // Examples // -------- -// >>> import numpy as np -// >>> from tempfile import TemporaryFile -// >>> outfile = TemporaryFile() -// >>> x = np.arange(10) -// >>> y = np.sin(x) +// Ordinary inner product for vectors: // -// Using `savez` with \*args, the arrays are saved with default names. +// >>> a = np.array([1,2,3]) +// >>> b = np.array([0,1,0]) +// >>> np.inner(a, b) +// 2 // -// >>> np.savez(outfile, x, y) -// >>> _ = outfile.seek(0) # Only needed to simulate closing & reopening file -// >>> npzfile = np.load(outfile) -// >>> npzfile.files -// ['arr_0', 'arr_1'] -// >>> npzfile['arr_0'] -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// Some multidimensional examples: // -// Using `savez` with \**kwds, the arrays are saved with the keyword names. +// >>> a = np.arange(24).reshape((2,3,4)) +// >>> b = np.arange(4) +// >>> c = np.inner(a, b) +// >>> c.shape +// (2, 3) +// >>> c +// array([[ 14, 38, 62], +// [ 86, 110, 134]]) // -// >>> outfile = TemporaryFile() -// >>> np.savez(outfile, x=x, y=y) -// >>> _ = outfile.seek(0) -// >>> npzfile = np.load(outfile) -// >>> sorted(npzfile.files) -// ['x', 'y'] -// >>> npzfile['x'] -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// >>> a = np.arange(2).reshape((1,1,2)) +// >>> b = np.arange(6).reshape((3,2)) +// >>> c = np.inner(a, b) +// >>> c.shape +// (1, 1, 3) +// >>> c +// array([[[1, 3, 5]]]) // +// An example where `b` is a scalar: // +// >>> np.inner(np.eye(2), 7) +// array([[7., 0.], +// [0., 7.]]) // -//go:linkname Savez py.savez -func Savez(__llgo_va_list ...interface{}) *py.Object // -// View inputs as arrays with at least three dimensions. -// -// Parameters -// ---------- -// arys1, arys2, ... : array_like -// One or more array-like sequences. Non-array inputs are converted to -// arrays. Arrays that already have three or more dimensions are -// preserved. -// -// Returns -// ------- -// res1, res2, ... : ndarray -// An array, or tuple of arrays, each with ``a.ndim >= 3``. Copies are -// avoided where possible, and views with three or more dimensions are -// returned. For example, a 1-D array of shape ``(N,)`` becomes a view -// of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a -// view of shape ``(M, N, 1)``. -// -// See Also -// -------- -// atleast_1d, atleast_2d -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.atleast_3d(3.0) -// array([[[3.]]]) -// -// >>> x = np.arange(3.0) -// >>> np.atleast_3d(x).shape -// (1, 3, 1) -// -// >>> x = np.arange(12.0).reshape(4,3) -// >>> np.atleast_3d(x).shape -// (4, 3, 1) -// >>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself -// True -// -// >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]): -// ... print(arr, arr.shape) # doctest: +SKIP -// ... -// [[[1] -// [2]]] (1, 2, 1) -// [[[1] -// [2]]] (1, 2, 1) -// [[[1 2]]] (1, 1, 2) // +//go:linkname Inner py.inner +func Inner(a *py.Object, b *py.Object) *py.Object +//go:linkname Arccos py.arccos +func Arccos(__llgo_va_list ...interface{}) *py.Object +// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // +// First array elements raised to powers from second array, element-wise. // -//go:linkname Atleast3d py.atleast_3d -func Atleast3d(__llgo_va_list ...interface{}) *py.Object -// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Raise each base in `x1` to the positionally-corresponding power in `x2`. +// `x1` and `x2` must be broadcastable to the same shape. This differs from +// the power function in that integers, float16, and float32 are promoted to +// floats with a minimum precision of float64 so that the result is always +// inexact. The intent is that the function will return a usable result for +// negative powers and seldom overflow for positive powers. // -// Given the "legs" of a right triangle, return its hypotenuse. +// Negative values raised to a non-integral value will return ``nan``. +// To get complex results, cast the input to complex, or specify the +// ``dtype`` to be ``complex`` (see the example below). // -// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. If `x1` or -// `x2` is scalar_like (i.e., unambiguously cast-able to a scalar type), -// it is broadcast for use with each element of the other argument. -// (See Examples) +// .. versionadded:: 1.12.0 // // Parameters // ---------- -// x1, x2 : array_like -// Leg of the triangle(s). +// x1 : array_like +// The bases. +// x2 : array_like +// The exponents. // If ``x1.shape != x2.shape``, they must be broadcastable to a common // shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional @@ -11116,37 +9867,67 @@ func Atleast3d(__llgo_va_list ...interface{}) *py.Object // // Returns // ------- -// z : ndarray -// The hypotenuse of the triangle(s). +// y : ndarray +// The bases in `x1` raised to the exponents in `x2`. // This is a scalar if both `x1` and `x2` are scalars. // +// See Also +// -------- +// power : power function that preserves type +// // Examples // -------- -// >>> import numpy as np -// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) +// Cube each element in a list. // -// Example showing broadcast of scalar_like argument: +// >>> x1 = range(6) +// >>> x1 +// [0, 1, 2, 3, 4, 5] +// >>> np.float_power(x1, 3) +// array([ 0., 1., 8., 27., 64., 125.]) // -// >>> np.hypot(3*np.ones((3, 3)), [4]) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) +// Raise the bases to different exponents. // -//go:linkname Hypot py.hypot -func Hypot(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] +// >>> np.float_power(x1, x2) +// array([ 0., 1., 8., 27., 16., 5.]) // -// Compute the truth value of x1 OR x2 element-wise. +// The effect of broadcasting. +// +// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) +// >>> x2 +// array([[1, 2, 3, 3, 2, 1], +// [1, 2, 3, 3, 2, 1]]) +// >>> np.float_power(x1, x2) +// array([[ 0., 1., 8., 27., 16., 5.], +// [ 0., 1., 8., 27., 16., 5.]]) +// +// Negative values raised to a non-integral value will result in ``nan`` +// (and a warning will be generated). +// +// >>> x3 = np.array([-1, -4]) +// >>> with np.errstate(invalid='ignore'): +// ... p = np.float_power(x3, 1.5) +// ... +// >>> p +// array([nan, nan]) +// +// To get complex results, give the argument ``dtype=complex``. +// +// >>> np.float_power(x3, 1.5, dtype=complex) +// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +// +//go:linkname FloatPower py.float_power +func FloatPower(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute hyperbolic tangent element-wise. +// +// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. // // Parameters // ---------- -// x1, x2 : array_like -// Logical OR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Input array. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -11165,507 +9946,362 @@ func Hypot(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // // Returns // ------- -// y : ndarray or bool -// Boolean result of the logical OR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray +// The corresponding hyperbolic tangent values. +// This is a scalar if `x` is a scalar. // -// See Also -// -------- -// logical_and, logical_not, logical_xor -// bitwise_or +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.logical_or(True, False) -// True -// >>> np.logical_or([True, False], [False, False]) -// array([ True, False]) +// References +// ---------- +// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. +// https://personal.math.ubc.ca/~cbm/aands/page_83.htm // -// >>> x = np.arange(5) -// >>> np.logical_or(x < 1, x > 3) -// array([ True, False, False, False, True]) +// .. [2] Wikipedia, "Hyperbolic function", +// https://en.wikipedia.org/wiki/Hyperbolic_function // -// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on -// boolean ndarrays. +// Examples +// -------- +// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) +// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) // -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a | b -// array([ True, False]) +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.tanh([0.1], out1) +// >>> out2 is out1 +// True // -//go:linkname LogicalOr py.logical_or -func LogicalOr(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) // -// Return a partitioned copy of an array. +//go:linkname Tanh py.tanh +func Tanh(x *py.Object, out *py.Object) *py.Object // -// Creates a copy of the array and partially sorts it 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. In the output array, all elements smaller than the k-th -// element are located to the left of this element and all equal or greater -// are located to its right. The ordering of the elements in the two -// partitions on the either side of the k-th element in the output array is -// undefined. +// Return an array drawn from elements in choicelist, depending on conditions. // // Parameters // ---------- -// a : array_like -// Array to be sorted. -// kth : int or sequence of ints -// Element index to partition by. The k-th value of the element -// will be in its final sorted position and all smaller elements -// will be moved before it and all equal or greater 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 elements -// indexed by k-th of them into their sorted position at once. -// -// .. deprecated:: 1.22.0 -// Passing booleans as index is deprecated. -// axis : int or None, optional -// Axis along which to sort. If None, the array is flattened before -// sorting. The default is -1, which sorts along the last axis. -// kind : {'introselect'}, optional -// Selection algorithm. Default is 'introselect'. -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument -// specifies which fields to compare first, second, etc. A single -// field can be specified as a string. Not all fields need be -// specified, but unspecified fields will still be used, in the -// order in which they come up in the dtype, to break ties. +// condlist : list of bool ndarrays +// The list of conditions which determine from which array in `choicelist` +// the output elements are taken. When multiple conditions are satisfied, +// the first one encountered in `condlist` is used. +// choicelist : list of ndarrays +// The list of arrays from which the output elements are taken. It has +// to be of the same length as `condlist`. +// default : scalar, optional +// The element inserted in `output` when all conditions evaluate to False. // // Returns // ------- -// partitioned_array : ndarray -// Array of the same type and shape as `a`. +// output : ndarray +// The output at position m is the m-th element of the array in +// `choicelist` where the m-th element of the corresponding array in +// `condlist` is True. // // See Also // -------- -// ndarray.partition : Method to sort an array in-place. -// argpartition : Indirect partition. -// sort : Full sorting +// where : Return elements from one of two arrays depending on condition. +// take, choose, compress, diag, diagonal // -// Notes -// ----- -// The various selection algorithms are characterized by their average -// speed, worst case performance, work space size, and whether they are -// stable. A stable sort keeps items with the same key in the same -// relative order. The available algorithms have the following -// properties: +// Examples +// -------- +// >>> x = np.arange(6) +// >>> condlist = [x<3, x>3] +// >>> choicelist = [x, x**2] +// >>> np.select(condlist, choicelist, 42) +// array([ 0, 1, 2, 42, 16, 25]) // -// ================= ======= ============= ============ ======= -// kind speed worst case work space stable -// ================= ======= ============= ============ ======= -// 'introselect' 1 O(n) 0 no -// ================= ======= ============= ============ ======= +// >>> condlist = [x<=4, x>3] +// >>> choicelist = [x, x**2] +// >>> np.select(condlist, choicelist, 55) +// array([ 0, 1, 2, 3, 4, 25]) // -// All the partition algorithms make temporary copies of the data when -// partitioning along any but the last axis. Consequently, -// partitioning along the last axis is faster and uses less space than -// partitioning along any other axis. // -// The sort order for complex numbers is lexicographic. If both the -// real and imaginary parts are non-nan then the order is determined by -// the real parts except when they are equal, in which case the order -// is determined by the imaginary parts. -// -// The sort order of ``np.nan`` is bigger than ``np.inf``. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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]) # may vary -// -// ``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] +//go:linkname Select py.select +func Select(condlist *py.Object, choicelist *py.Object, Default *py.Object) *py.Object // -// The next example shows the use of multiple values passed to `kth`. +// Least squares polynomial fit. // -// >>> p2 = np.partition(a, (4, 8)) -// >>> p2 -// array([0, 1, 2, 1, 2, 3, 3, 2, 5, 6, 7, 7, 7, 7]) +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. // -// ``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:: +// Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg` +// to points `(x, y)`. Returns a vector of coefficients `p` that minimises +// the squared error in the order `deg`, `deg-1`, ... `0`. // -// [0, 1, 2, 1], [2], [3, 3, 2], [5], [6, 7, 7, 7, 7] +// The `Polynomial.fit ` class +// method is recommended for new code as it is more stable numerically. See +// the documentation of the method for more information. // +// Parameters +// ---------- +// x : array_like, shape (M,) +// x-coordinates of the M sample points ``(x[i], y[i])``. +// y : array_like, shape (M,) or (M, K) +// y-coordinates of the sample points. Several data sets of sample +// points sharing the same x-coordinates can be fitted at once by +// passing in a 2D-array that contains one dataset per column. +// deg : int +// Degree of the fitting polynomial +// rcond : float, optional +// Relative condition number of the fit. Singular values smaller than +// this relative to the largest singular value will be ignored. The +// default value is len(x)*eps, where eps is the relative precision of +// the float type, about 2e-16 in most cases. +// full : bool, optional +// Switch determining nature of return value. When it is False (the +// default) just the coefficients are returned, when True diagnostic +// information from the singular value decomposition is also returned. +// w : array_like, shape (M,), optional +// Weights. If not None, the weight ``w[i]`` applies to the unsquared +// residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are +// chosen so that the errors of the products ``w[i]*y[i]`` all have the +// same variance. When using inverse-variance weighting, use +// ``w[i] = 1/sigma(y[i])``. The default value is None. +// cov : bool or str, optional +// If given and not `False`, return not just the estimate but also its +// covariance matrix. By default, the covariance are scaled by +// chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed +// to be unreliable except in a relative sense and everything is scaled +// such that the reduced chi2 is unity. This scaling is omitted if +// ``cov='unscaled'``, as is relevant for the case that the weights are +// w = 1/sigma, with sigma known to be a reliable estimate of the +// uncertainty. // -//go:linkname Partition py.partition -func Partition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object +// Returns +// ------- +// p : ndarray, shape (deg + 1,) or (deg + 1, K) +// Polynomial coefficients, highest power first. If `y` was 2-D, the +// coefficients for `k`-th data set are in ``p[:,k]``. // -// Find the unique elements and counts of an input array `x`. +// residuals, rank, singular_values, rcond +// These values are only returned if ``full == True`` // -// This function is an Array API compatible alternative to:: +// - residuals -- sum of squared residuals of the least squares fit +// - rank -- the effective rank of the scaled Vandermonde +// coefficient matrix +// - singular_values -- singular values of the scaled Vandermonde +// coefficient matrix +// - rcond -- value of `rcond`. // -// np.unique(x, return_counts=True, equal_nan=False, sorted=False) +// For more details, see `numpy.linalg.lstsq`. // -// but returns a namedtuple for easier access to each output. +// V : ndarray, shape (M,M) or (M,M,K) +// Present only if ``full == False`` and ``cov == True``. The covariance +// matrix of the polynomial coefficient estimates. The diagonal of +// this matrix are the variance estimates for each coefficient. If y +// is a 2-D array, then the covariance matrix for the `k`-th data set +// are in ``V[:,:,k]`` // -// .. note:: -// This function currently always returns a sorted result, however, -// this could change in any NumPy minor release. // -// Parameters -// ---------- -// x : array_like -// Input array. It will be flattened if it is not already 1-D. +// Warns +// ----- +// RankWarning +// The rank of the coefficient matrix in the least-squares fit is +// deficient. The warning is only raised if ``full == False``. // -// Returns -// ------- -// out : namedtuple -// The result containing: +// The warnings can be turned off by // -// * values - The unique elements of an input array. -// * counts - The corresponding counts for each unique element. +// >>> import warnings +// >>> warnings.simplefilter('ignore', np.RankWarning) // // See Also // -------- -// unique : Find the unique elements of an array. -// -// Examples -// -------- -// >>> import numpy as np -// >>> x = [1, 1, 2] -// >>> uniq = np.unique_counts(x) -// >>> uniq.values -// array([1, 2]) -// >>> uniq.counts -// array([2, 1]) +// polyval : Compute polynomial values. +// linalg.lstsq : Computes a least-squares fit. +// scipy.interpolate.UnivariateSpline : Computes spline fits. // +// Notes +// ----- +// The solution minimizes the squared error // -//go:linkname UniqueCounts py.unique_counts -func UniqueCounts(x *py.Object) *py.Object +// .. math:: +// E = \sum_{j=0}^k |p(x_j) - y_j|^2 // -// Return an antiderivative (indefinite integral) of a polynomial. +// in the equations:: // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. +// x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0] +// x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1] +// ... +// x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k] // -// The returned order `m` antiderivative `P` of polynomial `p` satisfies -// :math:`\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1` -// integration constants `k`. The constants determine the low-order -// polynomial part +// The coefficient matrix of the coefficients `p` is a Vandermonde matrix. // -// .. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1} +// `polyfit` issues a `RankWarning` when the least-squares fit is badly +// conditioned. This implies that the best fit is not well-defined due +// to numerical error. The results may be improved by lowering the polynomial +// degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter +// can also be set to a value smaller than its default, but the resulting +// fit may be spurious: including contributions from the small singular +// values can add numerical noise to the result. // -// of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`. +// Note that fitting polynomial coefficients is inherently badly conditioned +// when the degree of the polynomial is large or the interval of sample points +// is badly centered. The quality of the fit should always be checked in these +// cases. When polynomial fits are not satisfactory, splines may be a good +// alternative. // -// Parameters +// References // ---------- -// p : array_like or poly1d -// Polynomial to integrate. -// A sequence is interpreted as polynomial coefficients, see `poly1d`. -// m : int, optional -// Order of the antiderivative. (Default: 1) -// k : list of `m` scalars or scalar, optional -// Integration constants. They are given in the order of integration: -// those corresponding to highest-order terms come first. -// -// If ``None`` (default), all constants are assumed to be zero. -// If `m = 1`, a single scalar can be given instead of a list. -// -// See Also -// -------- -// polyder : derivative of a polynomial -// poly1d.integ : equivalent method +// .. [1] Wikipedia, "Curve fitting", +// https://en.wikipedia.org/wiki/Curve_fitting +// .. [2] Wikipedia, "Polynomial interpolation", +// https://en.wikipedia.org/wiki/Polynomial_interpolation // // Examples // -------- +// >>> import warnings +// >>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]) +// >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0]) +// >>> z = np.polyfit(x, y, 3) +// >>> z +// array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary // -// The defining property of the antiderivative: -// -// >>> import numpy as np -// -// >>> p = np.poly1d([1,1,1]) -// >>> P = np.polyint(p) -// >>> P -// poly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary -// >>> np.polyder(P) == p -// True -// -// The integration constants default to zero, but can be specified: -// -// >>> P = np.polyint(p, 3) -// >>> P(0) -// 0.0 -// >>> np.polyder(P)(0) -// 0.0 -// >>> np.polyder(P, 2)(0) -// 0.0 -// >>> P = np.polyint(p, 3, k=[6,5,3]) -// >>> P -// poly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may vary +// It is convenient to use `poly1d` objects for dealing with polynomials: // -// Note that 3 = 6 / 2!, and that the constants are given in the order of -// integrations. Constant of the highest-order polynomial term comes first: +// >>> p = np.poly1d(z) +// >>> p(0.5) +// 0.6143849206349179 # may vary +// >>> p(3.5) +// -0.34732142857143039 # may vary +// >>> p(10) +// 22.579365079365115 # may vary // -// >>> np.polyder(P, 2)(0) -// 6.0 -// >>> np.polyder(P, 1)(0) -// 5.0 -// >>> P(0) -// 3.0 +// High-order polynomials may oscillate wildly: // +// >>> with warnings.catch_warnings(): +// ... warnings.simplefilter('ignore', np.RankWarning) +// ... p30 = np.poly1d(np.polyfit(x, y, 30)) +// ... +// >>> p30(4) +// -0.80000000000000204 # may vary +// >>> p30(5) +// -0.99999999999999445 # may vary +// >>> p30(4.5) +// -0.10547061179440398 # may vary // +// Illustration: // -//go:linkname Polyint py.polyint -func Polyint(p *py.Object, m *py.Object, k *py.Object) *py.Object +// >>> import matplotlib.pyplot as plt +// >>> xp = np.linspace(-2, 6, 100) +// >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--') +// >>> plt.ylim(-2,2) +// (-2, 2) +// >>> plt.show() // -// Return the roots of a polynomial with coefficients given in p. // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. // -// The values in the rank-1 array `p` are coefficients of a polynomial. -// If the length of `p` is n+1 then the polynomial is described by:: +//go:linkname Polyfit py.polyfit +func Polyfit(x *py.Object, y *py.Object, deg *py.Object, rcond *py.Object, full *py.Object, w *py.Object, cov *py.Object) *py.Object // -// p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n] +// Return minimum of an array or minimum along an axis, ignoring any NaNs. +// When all-NaN slices are encountered a ``RuntimeWarning`` is raised and +// Nan is returned for that slice. // // Parameters // ---------- -// p : array_like -// Rank-1 array of polynomial coefficients. -// -// Returns -// ------- -// out : ndarray -// An array containing the roots of the polynomial. -// -// Raises -// ------ -// ValueError -// When `p` cannot be converted to a rank-1 array. -// -// See also -// -------- -// poly : Find the coefficients of a polynomial with a given sequence -// of roots. -// polyval : Compute polynomial values. -// polyfit : Least squares polynomial fit. -// poly1d : A one-dimensional polynomial class. -// -// Notes -// ----- -// The algorithm relies on computing the eigenvalues of the -// companion matrix [1]_. -// -// References -// ---------- -// .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*. Cambridge, UK: -// Cambridge University Press, 1999, pp. 146-7. -// -// Examples -// -------- -// >>> import numpy as np -// >>> coeff = [3.2, 2, 1] -// >>> np.roots(coeff) -// array([-0.3125+0.46351241j, -0.3125-0.46351241j]) -// +// a : array_like +// Array containing numbers whose minimum is desired. If `a` is not an +// array, a conversion is attempted. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the minimum is computed. The default is to compute +// the minimum of the flattened array. +// out : ndarray, optional +// Alternate output array in which to place the result. The default +// is ``None``; if provided, it must have the same shape as the +// expected output, but the type will be cast if necessary. See +// :ref:`ufuncs-output-type` for more details. // +// .. versionadded:: 1.8.0 +// 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`. // -//go:linkname Roots py.roots -func Roots(p *py.Object) *py.Object +// If the value is anything but the default, then +// `keepdims` will be passed through to the `min` method +// of sub-classes of `ndarray`. If the sub-classes methods +// does not implement `keepdims` any exceptions will be raised. // -// Convert inputs to arrays with at least one dimension. +// .. versionadded:: 1.8.0 +// initial : scalar, optional +// The maximum value of an output element. Must be present to allow +// computation on empty slice. See `~numpy.ufunc.reduce` for details. // -// Scalar inputs are converted to 1-dimensional arrays, whilst -// higher-dimensional inputs are preserved. +// .. versionadded:: 1.22.0 +// where : array_like of bool, optional +// Elements to compare for the minimum. See `~numpy.ufunc.reduce` +// for details. // -// Parameters -// ---------- -// arys1, arys2, ... : array_like -// One or more input arrays. +// .. versionadded:: 1.22.0 // // Returns // ------- -// ret : ndarray -// An array, or tuple of arrays, each with ``a.ndim >= 1``. -// Copies are made only if necessary. +// nanmin : ndarray +// An array with the same shape as `a`, with the specified axis +// removed. If `a` is a 0-d array, or if axis is None, an ndarray +// scalar is returned. The same dtype as `a` is returned. // // See Also // -------- -// atleast_2d, atleast_3d -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.atleast_1d(1.0) -// array([1.]) -// -// >>> x = np.arange(9.0).reshape(3,3) -// >>> np.atleast_1d(x) -// array([[0., 1., 2.], -// [3., 4., 5.], -// [6., 7., 8.]]) -// >>> np.atleast_1d(x) is x -// True -// -// >>> np.atleast_1d(1, [3, 4]) -// (array([1]), array([3, 4])) -// -// -// -//go:linkname Atleast1d py.atleast_1d -func Atleast1d(__llgo_va_list ...interface{}) *py.Object -// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Logarithm of the sum of exponentiations of the inputs in base-2. -// -// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine -// learning when the calculated probabilities of events may be so small as -// to exceed the range of normal floating point numbers. In such cases -// the base-2 logarithm of the calculated probability can be used instead. -// This function allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Base-2 logarithm of ``2**x1 + 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp: Logarithm of the sum of exponentiations of the inputs. -// -// Examples -// -------- -// >>> import numpy as np -// >>> prob1 = np.log2(1e-50) -// >>> prob2 = np.log2(2.5e-50) -// >>> prob12 = np.logaddexp2(prob1, prob2) -// >>> prob1, prob2, prob12 -// (-166.09640474436813, -164.77447664948076, -164.28904982231052) -// >>> 2**prob12 -// 3.4999999999999914e-50 -// -//go:linkname Logaddexp2 py.logaddexp2 -func Logaddexp2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Perform an indirect partition along the given axis using the -// algorithm specified by the `kind` keyword. It returns an array of -// indices of the same shape as `a` that index data along the given -// axis in partitioned order. -// -// Parameters -// ---------- -// a : array_like -// Array to sort. -// 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 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. -// -// .. deprecated:: 1.22.0 -// Passing booleans as index is deprecated. -// axis : int or None, optional -// Axis along which to sort. The default is -1 (the last axis). If -// None, the flattened array is used. -// kind : {'introselect'}, optional -// Selection algorithm. Default is 'introselect' -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument -// specifies which fields to compare first, second, etc. A single -// field can be specified as a string, and not all fields need be -// specified, but unspecified fields will still be used, in the -// order in which they come up in the dtype, to break ties. -// -// Returns -// ------- -// 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=axis)`` -// always yields the partitioned `a`, irrespective of dimensionality. +// nanmax : +// The maximum value of an array along a given axis, ignoring any NaNs. +// amin : +// The minimum value of an array along a given axis, propagating any NaNs. +// fmin : +// Element-wise minimum of two arrays, ignoring any NaNs. +// minimum : +// Element-wise minimum of two arrays, propagating any NaNs. +// isnan : +// Shows which elements are Not a Number (NaN). +// isfinite: +// Shows which elements are neither NaN nor infinity. // -// See Also -// -------- -// partition : Describes partition algorithms used. -// ndarray.partition : Inplace partition. -// argsort : Full indirect sort. -// take_along_axis : Apply ``index_array`` from argpartition -// to an array as if by calling partition. +// amax, fmax, maximum // // Notes // ----- -// The returned indices are not guaranteed to be sorted according to -// the values. Furthermore, the default selection algorithm ``introselect`` -// is unstable, and hence the returned indices are not guaranteed -// to be the earliest/latest occurrence of the element. +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). This means that Not a Number is not equivalent to infinity. +// Positive infinity is treated as a very large number and negative +// infinity is treated as a very small (i.e. negative) number. // -// `argpartition` works for real/complex inputs with nan values, -// see `partition` for notes on the enhanced sort order and -// different selection algorithms. +// If the input has a integer type the function is equivalent to np.min. // // Examples // -------- -// One dimensional array: -// -// >>> import numpy as np -// >>> x = np.array([3, 4, 2, 1]) -// >>> x[np.argpartition(x, 3)] -// array([2, 1, 3, 4]) # may vary -// >>> x[np.argpartition(x, (1, 3))] -// array([1, 2, 3, 4]) # may vary -// -// >>> x = [3, 4, 2, 1] -// >>> np.array(x)[np.argpartition(x, 3)] -// array([2, 1, 3, 4]) # may vary +// >>> a = np.array([[1, 2], [3, np.nan]]) +// >>> np.nanmin(a) +// 1.0 +// >>> np.nanmin(a, axis=0) +// array([1., 2.]) +// >>> np.nanmin(a, axis=1) +// array([1., 3.]) // -// Multi-dimensional array: +// When positive infinity and negative infinity are present: // -// >>> x = np.array([[3, 4, 2], [1, 3, 1]]) -// >>> index_array = np.argpartition(x, kth=1, axis=-1) -// >>> # below is the same as np.partition(x, kth=1) -// >>> np.take_along_axis(x, index_array, axis=-1) -// array([[2, 3, 4], -// [1, 1, 3]]) +// >>> np.nanmin([1, 2, np.nan, np.inf]) +// 1.0 +// >>> np.nanmin([1, 2, np.nan, np.NINF]) +// -inf // // // -//go:linkname Argpartition py.argpartition -func Argpartition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object -// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Nanmin py.nanmin +func Nanmin(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // // Cosine element-wise. // @@ -11707,7 +10343,6 @@ func Argpartition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object // // Examples // -------- -// >>> import numpy as np // >>> np.cos(np.array([0, np.pi/2, np.pi])) // array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) // >>> @@ -11725,267 +10360,231 @@ func Argpartition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object // //go:linkname Cos py.cos func Cos(x *py.Object, out *py.Object) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Divide arguments element-wise. +// Returns the greatest common divisor of ``|x1|`` and ``|x2|`` // // Parameters // ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. +// x1, x2 : array_like, int +// Arrays of values. // If ``x1.shape != x2.shape``, they must be broadcastable to a common // shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. // // Returns // ------- // y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. +// The greatest common divisor of the absolute value of the inputs // This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. +// lcm : The lowest common multiple // // Examples // -------- -// >>> import numpy as np -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> 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. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) +// >>> np.gcd(12, 20) +// 4 +// >>> np.gcd.reduce([15, 25, 35]) +// 5 +// >>> np.gcd(np.arange(6), 20) +// array([20, 1, 2, 1, 4, 5]) // -//go:linkname Divide py.divide -func Divide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Gcd py.gcd +func Gcd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Returns element-wise True where signbit is set (less than zero). +// Set the floating-point error callback function or log object. // -// Parameters -// ---------- -// x : array_like -// The input value(s). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// There are two ways to capture floating-point error messages. The first +// is to set the error-handler to 'call', using `seterr`. Then, set +// the function to call using this function. // -// Returns -// ------- -// result : ndarray of bool -// Output array, or reference to `out` if that was supplied. -// This is a scalar if `x` is a scalar. +// The second is to set the error-handler to 'log', using `seterr`. +// Floating-point errors then trigger a call to the 'write' method of +// the provided object. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.signbit(-1.2) -// True -// >>> np.signbit(np.array([1, -2.3, 2.1])) -// array([False, True, False]) +// Parameters +// ---------- +// func : callable f(err, flag) or object with write method +// Function to call upon floating-point errors ('call'-mode) or +// object whose 'write' method is used to log such message ('log'-mode). // -//go:linkname Signbit py.signbit -func Signbit(x *py.Object, out *py.Object) *py.Object +// The call function takes two arguments. The first is a string describing +// the type of error (such as "divide by zero", "overflow", "underflow", +// or "invalid value"), and the second is the status flag. The flag is a +// byte, whose four least-significant bits indicate the type of error, one +// of "divide", "over", "under", "invalid":: // -// Find the set difference of two arrays. +// [0 0 0 0 divide over under invalid] // -// Return the unique values in `ar1` that are not in `ar2`. +// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. // -// Parameters -// ---------- -// ar1 : array_like -// Input array. -// ar2 : array_like -// Input comparison array. -// assume_unique : bool -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. Default is False. +// If an object is provided, its write method should take one argument, +// a string. // // Returns // ------- -// setdiff1d : ndarray -// 1D array of values in `ar1` that are not in `ar2`. The result -// is sorted when `assume_unique=False`, but otherwise only sorted -// if the input is sorted. +// h : callable, log instance or None +// The old error handler. +// +// See Also +// -------- +// seterr, geterr, geterrcall // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([1, 2, 3, 2, 4, 1]) -// >>> b = np.array([3, 4, 5, 6]) -// >>> np.setdiff1d(a, b) -// array([1, 2]) +// Callback upon error: // +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// ... // +// >>> saved_handler = np.seterrcall(err_handler) +// >>> save_err = np.seterr(all='call') // -//go:linkname Setdiff1d py.setdiff1d -func Setdiff1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object) *py.Object +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) // -// Integrate along the given axis using the composite trapezoidal rule. +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} // -// If `x` is provided, the integration happens in sequence along its -// elements - they are not sorted. +// Log error message: // -// Integrate `y` (`x`) along each 1d slice on the given axis, compute -// :math:`\int y(x) dx`. -// When `x` is specified, this integrates along the parametric curve, -// computing :math:`\int_t y(t) dt = -// \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`. +// >>> class Log: +// ... def write(self, msg): +// ... print("LOG: %s" % msg) +// ... // -// .. versionadded:: 2.0.0 +// >>> log = Log() +// >>> saved_handler = np.seterrcall(log) +// >>> save_err = np.seterr(all='log') // -// Parameters -// ---------- -// y : array_like -// Input array to integrate. -// x : array_like, optional -// The sample points corresponding to the `y` values. If `x` is None, -// the sample points are assumed to be evenly spaced `dx` apart. The -// default is None. -// dx : scalar, optional -// The spacing between sample points when `x` is None. The default is 1. -// axis : int, optional -// The axis along which to integrate. +// >>> np.array([1, 2, 3]) / 0.0 +// LOG: Warning: divide by zero encountered in divide +// array([inf, inf, inf]) // -// Returns -// ------- -// trapezoid : 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. +// >>> np.seterrcall(saved_handler) +// +// >>> np.seterr(**save_err) +// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} // -// See Also -// -------- -// sum, cumsum // -// Notes -// ----- -// Image [2]_ illustrates trapezoidal rule -- y-axis locations of points -// will be taken from `y` array, by default x-axis distances between -// points will be 1.0, alternatively they can be provided with `x` array -// or with `dx` scalar. Return value will be equal to combined area under -// the red lines. // +//go:linkname Seterrcall py.seterrcall +func Seterrcall(Func *py.Object) *py.Object // -// References +// Check whether or not an object can be iterated over. +// +// Parameters // ---------- -// .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule +// y : object +// Input object. +// +// Returns +// ------- +// b : bool +// Return ``True`` if the object has an iterator method or is a +// sequence and ``False`` otherwise. // -// .. [2] Illustration image: -// https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png // // Examples // -------- -// >>> import numpy as np +// >>> np.iterable([1, 2, 3]) +// True +// >>> np.iterable(2) +// False // -// Use the trapezoidal rule on evenly spaced points: +// Notes +// ----- +// In most cases, the results of ``np.iterable(obj)`` are consistent with +// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is +// the treatment of 0-dimensional arrays:: // -// >>> np.trapezoid([1, 2, 3]) -// 4.0 +// >>> from collections.abc import Iterable +// >>> a = np.array(1.0) # 0-dimensional numpy array +// >>> isinstance(a, Iterable) +// True +// >>> np.iterable(a) +// False // -// The spacing between sample points can be selected by either the -// ``x`` or ``dx`` arguments: // -// >>> np.trapezoid([1, 2, 3], x=[4, 6, 8]) -// 8.0 -// >>> np.trapezoid([1, 2, 3], dx=2) -// 8.0 // -// Using a decreasing ``x`` corresponds to integrating in reverse: +//go:linkname Iterable py.iterable +func Iterable(y *py.Object) *py.Object // -// >>> np.trapezoid([1, 2, 3], x=[8, 6, 4]) -// -8.0 +// Reverse the order of elements along axis 0 (up/down). // -// More generally ``x`` is used to integrate along a parametric curve. We can -// estimate the integral :math:`\int_0^1 x^2 = 1/3` using: +// For a 2-D array, this flips the entries in each column in the up/down +// direction. Rows are preserved, but appear in a different order than before. // -// >>> x = np.linspace(0, 1, num=50) -// >>> y = x**2 -// >>> np.trapezoid(y, x) -// 0.33340274885464394 +// Parameters +// ---------- +// m : array_like +// Input array. // -// Or estimate the area of a circle, noting we repeat the sample which closes -// the curve: +// Returns +// ------- +// out : array_like +// A view of `m` with the rows reversed. Since a view is +// returned, this operation is :math:`\mathcal O(1)`. // -// >>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True) -// >>> np.trapezoid(np.cos(theta), x=np.sin(theta)) -// 3.141571941375841 +// See Also +// -------- +// fliplr : Flip array in the left/right direction. +// flip : Flip array in one or more dimensions. +// rot90 : Rotate array counterclockwise. // -// ``np.trapezoid`` can be applied along a specified axis to do multiple -// computations in one call: +// Notes +// ----- +// Equivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``. +// Requires the array to be at least 1-D. // -// >>> a = np.arange(6).reshape(2, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.trapezoid(a, axis=0) -// array([1.5, 2.5, 3.5]) -// >>> np.trapezoid(a, axis=1) -// array([2., 8.]) +// Examples +// -------- +// >>> A = np.diag([1.0, 2, 3]) +// >>> A +// array([[1., 0., 0.], +// [0., 2., 0.], +// [0., 0., 3.]]) +// >>> np.flipud(A) +// array([[0., 0., 3.], +// [0., 2., 0.], +// [1., 0., 0.]]) +// +// >>> A = np.random.randn(2,3,5) +// >>> np.all(np.flipud(A) == A[::-1,...]) +// True // +// >>> np.flipud([1,2]) +// array([2, 1]) // -//go:linkname Trapezoid py.trapezoid -func Trapezoid(y *py.Object, x *py.Object, dx *py.Object, axis *py.Object) *py.Object -// ascontiguousarray(a, dtype=None, *, like=None) // -// Return a contiguous array (ndim >= 1) in memory (C order). +// +//go:linkname Flipud py.flipud +func Flipud(m *py.Object) *py.Object +// +// Construct an array by executing a function over each coordinate. +// +// The resulting array therefore has a value ``fn(x, y, z)`` at +// coordinate ``(x, y, z)``. // // Parameters // ---------- -// a : array_like -// Input array. -// dtype : str or dtype object, optional -// Data-type of returned array. +// function : callable +// The function is called with N parameters, where N is the rank of +// `shape`. Each parameter represents the coordinates of the array +// varying along a specific axis. For example, if `shape` +// were ``(2, 2)``, then the parameters would be +// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` +// shape : (N,) tuple of ints +// Shape of the output array, which also determines the shape of +// the coordinate arrays passed to `function`. +// dtype : data-type, optional +// Data-type of the coordinate arrays passed to `function`. +// By default, `dtype` is float. // 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 @@ -11997,318 +10596,169 @@ func Trapezoid(y *py.Object, x *py.Object, dx *py.Object, axis *py.Object) *py.O // // Returns // ------- -// out : ndarray -// Contiguous array of same shape and content as `a`, with type `dtype` -// if specified. +// fromfunction : any +// The result of the call to `function` is passed back directly. +// Therefore the shape of `fromfunction` is completely determined by +// `function`. If `function` returns a scalar value, the shape of +// `fromfunction` would not match the `shape` parameter. // // See Also // -------- -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// require : Return an ndarray that satisfies requirements. -// ndarray.flags : Information about the memory layout of the array. +// indices, meshgrid +// +// Notes +// ----- +// Keywords other than `dtype` and `like` are passed to `function`. // // Examples // -------- -// Starting with a Fortran-contiguous array: -// -// >>> import numpy as np -// >>> 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. -// -//go:linkname Ascontiguousarray py.ascontiguousarray -func Ascontiguousarray(a *py.Object, dtype *py.Object) *py.Object -// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Return the floor of the input, element-wise. +// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) +// array([[0., 0.], +// [1., 1.]]) // -// The floor of the scalar `x` is the largest integer `i`, such that -// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. +// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) +// array([[0., 1.], +// [0., 1.]]) // -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) +// array([[ True, False, False], +// [False, True, False], +// [False, False, True]]) // -// Returns -// ------- -// y : ndarray or scalar -// The floor of each element in `x`. -// This is a scalar if `x` is a scalar. +// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) +// array([[0, 1, 2], +// [1, 2, 3], +// [2, 3, 4]]) // -// See Also -// -------- -// ceil, trunc, rint, fix // -// Notes -// ----- -// Some spreadsheet programs calculate the "floor-towards-zero", where -// ``floor(-2.5) == -2``. NumPy instead uses the definition of -// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" -// function is called ``fix`` in NumPy. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.floor(a) -// array([-2., -2., -1., 0., 1., 1., 2.]) +//go:linkname Fromfunction py.fromfunction +func Fromfunction(function *py.Object, shape *py.Object) *py.Object // -//go:linkname Floor py.floor -func Floor(x *py.Object, out *py.Object) *py.Object +// Determine common type following standard coercion rules. // -// is_busday( -// dates, -// weekmask='1111100', -// holidays=None, -// busdaycal=None, -// out=None -// ) +// .. deprecated:: NumPy 1.25 // -// Calculates which of the given dates are valid days, and which are not. +// This function is deprecated, use `numpy.promote_types` or +// `numpy.result_type` instead. To achieve semantics for the +// `scalar_types` argument, use `numpy.result_type` and pass the Python +// values `0`, `0.0`, or `0j`. +// This will give the same results in almost all cases. +// More information and rare exception can be found in the +// `NumPy 1.25 release notes `_. // // Parameters // ---------- -// dates : array_like of datetime64[D] -// The array of dates to process. -// weekmask : str or array_like of bool, optional -// A seven-element array indicating which of Monday through Sunday are -// valid days. May be specified as a length-seven list or array, like -// [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string -// like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for -// weekdays, optionally separated by white space. Valid abbreviations -// are: Mon Tue Wed Thu Fri Sat Sun -// holidays : array_like of datetime64[D], optional -// An array of dates to consider as invalid dates. They may be -// specified in any order, and NaT (not-a-time) dates are ignored. -// This list is saved in a normalized form that is suited for -// fast calculations of valid days. -// busdaycal : busdaycalendar, optional -// A `busdaycalendar` object which specifies the valid days. If this -// parameter is provided, neither weekmask nor holidays may be -// provided. -// out : array of bool, optional -// If provided, this array is filled with the result. +// array_types : sequence +// A list of dtypes or dtype convertible objects representing arrays. +// scalar_types : sequence +// A list of dtypes or dtype convertible objects representing scalars. // // Returns // ------- -// out : array of bool -// An array with the same shape as ``dates``, containing True for -// each valid day, and False for each invalid day. +// datatype : dtype +// The common data type, which is the maximum of `array_types` ignoring +// `scalar_types`, unless the maximum of `scalar_types` is of a +// different kind (`dtype.kind`). If the kind is not understood, then +// None is returned. // // See Also // -------- -// busdaycalendar : An object that specifies a custom set of valid days. -// busday_offset : Applies an offset counted in valid days. -// busday_count : Counts how many valid days are in a half-open date range. +// dtype, common_type, can_cast, mintypecode // // Examples // -------- -// >>> import numpy as np -// >>> # The weekdays are Friday, Saturday, and Monday -// ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'], -// ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) -// array([False, False, True]) +// >>> np.find_common_type([], [np.int64, np.float32, complex]) +// dtype('complex128') +// >>> np.find_common_type([np.int64, np.float32], []) +// dtype('float64') // +// The standard casting rules ensure that a scalar cannot up-cast an +// array unless the scalar is of a fundamentally different kind of data +// (i.e. under a different hierarchy in the data type hierarchy) then +// the array: // -//go:linkname IsBusday py.is_busday -func IsBusday(dates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object +// >>> np.find_common_type([np.float32], [np.int64, np.float64]) +// dtype('float32') // -// Return evenly spaced numbers over a specified interval. +// Complex is of a different type, so it up-casts the float in the +// `array_types` argument: // -// Returns `num` evenly spaced samples, calculated over the -// interval [`start`, `stop`]. +// >>> np.find_common_type([np.float32], [complex]) +// dtype('complex128') // -// The endpoint of the interval can optionally be excluded. +// Type specifier strings are convertible to dtypes and can therefore +// be used instead of dtypes: // -// .. versionchanged:: 1.20.0 -// Values are rounded towards ``-inf`` instead of ``0`` when an -// integer ``dtype`` is specified. The old behavior can -// still be obtained with ``np.linspace(start, stop, num).astype(int)`` +// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) +// dtype('complex128') +// +// +// +//go:linkname FindCommonType py.find_common_type +func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object +// +// Set the size of the buffer used in ufuncs. // // Parameters // ---------- -// start : array_like -// The starting value of the sequence. -// stop : array_like -// The end value of the sequence, unless `endpoint` is set to False. -// In that case, the sequence consists of all but the last of ``num + 1`` -// evenly spaced samples, so that `stop` is excluded. Note that the step -// size changes when `endpoint` is False. -// num : int, optional -// Number of samples to generate. Default is 50. Must be non-negative. -// endpoint : bool, optional -// If True, `stop` is the last sample. Otherwise, it is not included. -// Default is True. -// retstep : bool, optional -// If True, return (`samples`, `step`), where `step` is the spacing -// between samples. -// dtype : dtype, optional -// The type of the output array. If `dtype` is not given, the data type -// is inferred from `start` and `stop`. The inferred dtype will never be -// an integer; `float` is chosen even if the arguments would produce an -// array of integers. -// axis : int, optional -// The axis in the result to store the samples. Relevant only if start -// or stop are array-like. By default (0), the samples will be along a -// new axis inserted at the beginning. Use -1 to get an axis at the end. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. +// size : int +// Size of buffer. // -// .. versionadded:: 2.0.0 // -// Returns -// ------- -// samples : ndarray -// There are `num` equally spaced samples in the closed interval -// ``[start, stop]`` or the half-open interval ``[start, stop)`` -// (depending on whether `endpoint` is True or False). -// step : float, optional -// Only returned if `retstep` is True // -// Size of spacing between samples. +//go:linkname Setbufsize py.setbufsize +func Setbufsize(size *py.Object) *py.Object // +// Estimate a covariance matrix, given data and weights. // -// See Also -// -------- -// arange : Similar to `linspace`, but uses a step size (instead of the -// number of samples). -// geomspace : Similar to `linspace`, but with numbers spaced evenly on a log -// scale (a geometric progression). -// logspace : Similar to `geomspace`, but with the end points specified as -// logarithms. -// :ref:`how-to-partition` -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.linspace(2.0, 3.0, num=5) -// array([2. , 2.25, 2.5 , 2.75, 3. ]) -// >>> np.linspace(2.0, 3.0, num=5, endpoint=False) -// array([2. , 2.2, 2.4, 2.6, 2.8]) -// >>> np.linspace(2.0, 3.0, num=5, retstep=True) -// (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) -// -// Graphical illustration: -// -// >>> import matplotlib.pyplot as plt -// >>> N = 8 -// >>> y = np.zeros(N) -// >>> x1 = np.linspace(0, 10, N, endpoint=True) -// >>> x2 = np.linspace(0, 10, N, endpoint=False) -// >>> plt.plot(x1, y, 'o') -// [] -// >>> plt.plot(x2, y + 0.5, 'o') -// [] -// >>> plt.ylim([-0.5, 1]) -// (-0.5, 1) -// >>> plt.show() -// -// -// -//go:linkname Linspace py.linspace -func Linspace(__llgo_va_list ...interface{}) *py.Object -// Context manager for setting print options. -// -// Set print options for the scope of the `with` block, and restore the old -// options at the end. See `set_printoptions` for the full description of -// available options. -// -// Examples -// -------- -// >>> import numpy as np -// -// >>> from numpy.testing import assert_equal -// >>> with np.printoptions(precision=2): -// ... np.array([2.0]) / 3 -// array([0.67]) -// -// The `as`-clause of the `with`-statement gives the current print options: -// -// >>> with np.printoptions(precision=2) as opts: -// ... assert_equal(opts, np.get_printoptions()) -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// -// -//go:linkname Printoptions py.printoptions -func Printoptions(__llgo_va_list ...interface{}) *py.Object -// -// Return Pearson product-moment correlation coefficients. -// -// Please refer to the documentation for `cov` for more detail. The -// relationship between the correlation coefficient matrix, `R`, and the -// covariance matrix, `C`, is -// -// .. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } } +// Covariance indicates the level to which two variables vary together. +// If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`, +// then 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`. // -// The values of `R` are between -1 and 1, inclusive. +// See the notes for an outline of the algorithm. // // Parameters // ---------- -// x : array_like +// m : array_like // A 1-D or 2-D array containing multiple variables and observations. -// Each row of `x` represents a variable, and each column a single +// Each row of `m` represents a variable, and each column a single // observation of all those variables. Also see `rowvar` below. // y : array_like, optional -// An additional set of variables and observations. `y` has the same -// shape as `x`. +// An additional set of variables and observations. `y` has the same form +// as that of `m`. // rowvar : bool, optional // If `rowvar` is True (default), then each row represents a // variable, with observations in the columns. Otherwise, the relationship // is transposed: each column represents a variable, while the rows // contain observations. -// bias : _NoValue, optional -// Has no effect, do not use. +// bias : bool, optional +// Default normalization (False) is by ``(N - 1)``, where ``N`` is the +// number of observations given (unbiased estimate). If `bias` is True, +// then normalization is by ``N``. These values can be overridden by using +// the keyword ``ddof`` in numpy versions >= 1.5. +// ddof : int, optional +// If not ``None`` the default value implied by `bias` is overridden. +// Note that ``ddof=1`` will return the unbiased estimate, even if both +// `fweights` and `aweights` are specified, and ``ddof=0`` will return +// the simple average. See the notes for the details. The default value +// is ``None``. // -// .. deprecated:: 1.10.0 -// ddof : _NoValue, optional -// Has no effect, do not use. +// .. versionadded:: 1.5 +// fweights : array_like, int, optional +// 1-D array of integer frequency weights; the number of times each +// observation vector should be repeated. // -// .. deprecated:: 1.10.0 +// .. versionadded:: 1.10 +// aweights : array_like, optional +// 1-D array of observation vector weights. These relative weights are +// typically large for observations considered "important" and smaller for +// observations considered less "important". If ``ddof=0`` the array of +// weights can be used to assign probabilities to observation vectors. +// +// .. versionadded:: 1.10 // dtype : data-type, optional // Data-type of the result. By default, the return data-type will have // at least `numpy.float64` precision. @@ -12317,605 +10767,545 @@ func Printoptions(__llgo_va_list ...interface{}) *py.Object // // Returns // ------- -// R : ndarray -// The correlation coefficient matrix of the variables. +// out : ndarray +// The covariance matrix of the variables. // // See Also // -------- -// cov : Covariance matrix +// corrcoef : Normalized covariance matrix // // Notes // ----- -// Due to floating point rounding the resulting array may not be Hermitian, -// the diagonal elements may not be 1, and the elements may not satisfy the -// inequality abs(a) <= 1. The real and imaginary parts are clipped to the -// interval [-1, 1] in an attempt to improve on that situation but is not -// much help in the complex case. +// Assume that the observations are in the columns of the observation +// array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The +// steps to compute the weighted covariance are as follows:: // -// This function accepts but discards arguments `bias` and `ddof`. This is -// for backwards compatibility with previous versions of this function. These -// arguments had no effect on the return values of the function and can be -// safely ignored in this and previous versions of numpy. +// >>> m = np.arange(10, dtype=np.float64) +// >>> f = np.arange(10) * 2 +// >>> a = np.arange(10) ** 2. +// >>> ddof = 1 +// >>> w = f * a +// >>> v1 = np.sum(w) +// >>> v2 = np.sum(w * a) +// >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1 +// >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2) +// +// Note that when ``a == 1``, the normalization factor +// ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)`` +// as it should. // // Examples // -------- -// >>> import numpy as np +// Consider two variables, :math:`x_0` and :math:`x_1`, which +// correlate perfectly, but in opposite directions: // -// In this example we generate two random arrays, ``xarr`` and ``yarr``, and -// compute the row-wise and column-wise Pearson correlation coefficients, -// ``R``. Since ``rowvar`` is true by default, we first find the row-wise -// Pearson correlation coefficients between the variables of ``xarr``. +// >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T +// >>> x +// array([[0, 1, 2], +// [2, 1, 0]]) // -// >>> import numpy as np -// >>> rng = np.random.default_rng(seed=42) -// >>> xarr = rng.random((3, 3)) -// >>> xarr -// array([[0.77395605, 0.43887844, 0.85859792], -// [0.69736803, 0.09417735, 0.97562235], -// [0.7611397 , 0.78606431, 0.12811363]]) -// >>> R1 = np.corrcoef(xarr) -// >>> R1 -// array([[ 1. , 0.99256089, -0.68080986], -// [ 0.99256089, 1. , -0.76492172], -// [-0.68080986, -0.76492172, 1. ]]) +// Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance +// matrix shows this clearly: // -// If we add another set of variables and observations ``yarr``, we can -// compute the row-wise Pearson correlation coefficients between the -// variables in ``xarr`` and ``yarr``. +// >>> np.cov(x) +// array([[ 1., -1.], +// [-1., 1.]]) // -// >>> yarr = rng.random((3, 3)) -// >>> yarr -// array([[0.45038594, 0.37079802, 0.92676499], -// [0.64386512, 0.82276161, 0.4434142 ], -// [0.22723872, 0.55458479, 0.06381726]]) -// >>> R2 = np.corrcoef(xarr, yarr) -// >>> R2 -// array([[ 1. , 0.99256089, -0.68080986, 0.75008178, -0.934284 , -// -0.99004057], -// [ 0.99256089, 1. , -0.76492172, 0.82502011, -0.97074098, -// -0.99981569], -// [-0.68080986, -0.76492172, 1. , -0.99507202, 0.89721355, -// 0.77714685], -// [ 0.75008178, 0.82502011, -0.99507202, 1. , -0.93657855, -// -0.83571711], -// [-0.934284 , -0.97074098, 0.89721355, -0.93657855, 1. , -// 0.97517215], -// [-0.99004057, -0.99981569, 0.77714685, -0.83571711, 0.97517215, -// 1. ]]) +// Note that element :math:`C_{0,1}`, which shows the correlation between +// :math:`x_0` and :math:`x_1`, is negative. // -// Finally if we use the option ``rowvar=False``, the columns are now -// being treated as the variables and we will find the column-wise Pearson -// correlation coefficients between variables in ``xarr`` and ``yarr``. +// Further, note how `x` and `y` are combined: // -// >>> R3 = np.corrcoef(xarr, yarr, rowvar=False) -// >>> R3 -// array([[ 1. , 0.77598074, -0.47458546, -0.75078643, -0.9665554 , -// 0.22423734], -// [ 0.77598074, 1. , -0.92346708, -0.99923895, -0.58826587, -// -0.44069024], -// [-0.47458546, -0.92346708, 1. , 0.93773029, 0.23297648, -// 0.75137473], -// [-0.75078643, -0.99923895, 0.93773029, 1. , 0.55627469, -// 0.47536961], -// [-0.9665554 , -0.58826587, 0.23297648, 0.55627469, 1. , -// -0.46666491], -// [ 0.22423734, -0.44069024, 0.75137473, 0.47536961, -0.46666491, -// 1. ]]) +// >>> x = [-2.1, -1, 4.3] +// >>> y = [3, 1.1, 0.12] +// >>> X = np.stack((x, y), axis=0) +// >>> np.cov(X) +// array([[11.71 , -4.286 ], # may vary +// [-4.286 , 2.144133]]) +// >>> np.cov(x, y) +// array([[11.71 , -4.286 ], # may vary +// [-4.286 , 2.144133]]) +// >>> np.cov(x) +// array(11.71) // // // -//go:linkname Corrcoef py.corrcoef -func Corrcoef(x *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object) *py.Object +//go:linkname Cov py.cov +func Cov(m *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object, fweights *py.Object, aweights *py.Object) *py.Object // -// Rotate an array by 90 degrees in the plane specified by axes. +// Find the sum of two polynomials. // -// Rotation direction is from the first towards the second axis. -// This means for a 2D array with the default `k` and `axes`, the -// rotation will be counterclockwise. +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. +// +// Returns the polynomial resulting from the sum of two input polynomials. +// Each input must be either a poly1d object or a 1D sequence of polynomial +// coefficients, from highest to lowest degree. // // Parameters // ---------- -// m : array_like -// Array of two or more dimensions. -// k : integer -// Number of times the array is rotated by 90 degrees. -// axes : (2,) array_like -// The array is rotated in the plane defined by the axes. -// Axes must be different. +// a1, a2 : array_like or poly1d object +// Input polynomials. // // Returns // ------- -// y : ndarray -// A rotated view of `m`. +// out : ndarray or poly1d object +// The sum of the inputs. If either input is a poly1d object, then the +// output is also a poly1d object. Otherwise, it is a 1D array of +// polynomial coefficients from highest to lowest degree. // // See Also // -------- -// flip : Reverse the order of elements in an array along the given axis. -// fliplr : Flip an array horizontally. -// flipud : Flip an array vertically. -// -// Notes -// ----- -// ``rot90(m, k=1, axes=(1,0))`` is the reverse of -// ``rot90(m, k=1, axes=(0,1))`` -// -// ``rot90(m, k=1, axes=(1,0))`` is equivalent to -// ``rot90(m, k=-1, axes=(0,1))`` +// poly1d : A one-dimensional polynomial class. +// poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval // // Examples // -------- -// >>> import numpy as np -// >>> m = np.array([[1,2],[3,4]], int) -// >>> m -// array([[1, 2], -// [3, 4]]) -// >>> np.rot90(m) -// array([[2, 4], -// [1, 3]]) -// >>> np.rot90(m, 2) -// array([[4, 3], -// [2, 1]]) -// >>> m = np.arange(8).reshape((2,2,2)) -// >>> np.rot90(m, 1, (1,2)) -// array([[[1, 3], -// [0, 2]], -// [[5, 7], -// [4, 6]]]) +// >>> np.polyadd([1, 2], [9, 5, 4]) +// array([9, 6, 6]) // +// Using poly1d objects: // +// >>> p1 = np.poly1d([1, 2]) +// >>> p2 = np.poly1d([9, 5, 4]) +// >>> print(p1) +// 1 x + 2 +// >>> print(p2) +// 2 +// 9 x + 5 x + 4 +// >>> print(np.polyadd(p1, p2)) +// 2 +// 9 x + 6 x + 6 // -//go:linkname Rot90 py.rot90 -func Rot90(m *py.Object, k *py.Object, axes *py.Object) *py.Object // -// dot(a, b, out=None) // -// Dot product of two arrays. Specifically, +//go:linkname Polyadd py.polyadd +func Polyadd(a1 *py.Object, a2 *py.Object) *py.Object +// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// - If both `a` and `b` are 1-D arrays, it is inner product of vectors -// (without complex conjugation). +// Element-wise maximum of array elements. // -// - If both `a` and `b` are 2-D arrays, it is matrix multiplication, -// but using :func:`matmul` or ``a @ b`` is preferred. +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. // -// - 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. +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// - 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`. +// Returns +// ------- +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. // -// - 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`:: +// See Also +// -------- +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. // -// dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) +// fmin, amin, nanmin // -// It uses an optimized BLAS library when possible (see `numpy.linalg`). +// Notes +// ----- +// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when +// neither x1 nor x2 are nans, but it is faster and does proper +// broadcasting. +// +// Examples +// -------- +// >>> np.maximum([2, 3, 4], [1, 5, 2]) +// array([2, 5, 4]) +// +// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) +// +// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.maximum(np.Inf, 1) +// inf +// +//go:linkname Maximum py.maximum +func Maximum(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// +// Return the indices to access the main diagonal of an array. +// +// This returns a tuple of indices that can be used to access the main +// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape +// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for +// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` +// for ``i = [0..n-1]``. // // Parameters // ---------- -// a : array_like -// First argument. -// b : array_like -// Second argument. -// out : ndarray, optional -// Output argument. This must have the exact kind that would be returned -// if it was not used. In particular, it must have the right type, must be -// C-contiguous, and its dtype must be the dtype that would be returned -// for `dot(a,b)`. This is a performance feature. Therefore, if these -// conditions are not met, an exception is raised, instead of attempting -// to be flexible. -// -// Returns -// ------- -// output : ndarray -// Returns the dot product of `a` and `b`. If `a` and `b` are both -// scalars or both 1-D arrays then a scalar is returned; otherwise -// an array is returned. -// If `out` is given, then it is returned. +// n : int +// The size, along each dimension, of the arrays for which the returned +// indices can be used. // -// Raises -// ------ -// ValueError -// If the last dimension of `a` is not the same size as -// the second-to-last dimension of `b`. +// ndim : int, optional +// The number of dimensions. // // See Also // -------- -// vdot : Complex-conjugating dot product. -// vecdot : Vector dot product of two arrays. -// tensordot : Sum products over arbitrary axes. -// einsum : Einstein summation convention. -// matmul : '@' operator as method with out parameter. -// linalg.multi_dot : Chained dot product. +// diag_indices_from +// +// Notes +// ----- +// .. versionadded:: 1.4.0 // // Examples // -------- -// >>> import numpy as np -// >>> np.dot(3, 4) -// 12 +// Create a set of indices to access the diagonal of a (4, 4) array: // -// Neither argument is complex-conjugated: +// >>> di = np.diag_indices(4) +// >>> di +// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// >>> a[di] = 100 +// >>> a +// array([[100, 1, 2, 3], +// [ 4, 100, 6, 7], +// [ 8, 9, 100, 11], +// [ 12, 13, 14, 100]]) // -// >>> np.dot([2j, 3j], [2j, 3j]) -// (-13+0j) +// Now, we create indices to manipulate a 3-D array: // -// For 2-D arrays it is the matrix product: +// >>> d3 = np.diag_indices(2, 3) +// >>> d3 +// (array([0, 1]), array([0, 1]), array([0, 1])) // -// >>> a = [[1, 0], [0, 1]] -// >>> b = [[4, 1], [2, 2]] -// >>> np.dot(a, b) -// array([[4, 1], -// [2, 2]]) +// And use it to set the diagonal of an array of zeros to 1: // -// >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) -// >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) -// >>> np.dot(a, b)[2,3,2,1,2,2] -// 499128 -// >>> sum(a[2,3,2,:] * b[1,2,:,2]) -// 499128 +// >>> a = np.zeros((2, 2, 2), dtype=int) +// >>> a[d3] = 1 +// >>> a +// array([[[1, 0], +// [0, 0]], +// [[0, 0], +// [0, 1]]]) // // // -//go:linkname Dot py.dot -func Dot(a *py.Object, b *py.Object, out *py.Object) *py.Object +//go:linkname DiagIndices py.diag_indices +func DiagIndices(n *py.Object, ndim *py.Object) *py.Object // -// Returns an array with axes transposed. +// Print or write to a file the source code for a NumPy object. // -// 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.atleast_2d(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]``. +// The source code is only returned for objects written in Python. Many +// functions and classes are defined in C and will therefore not return +// useful information. // // 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`. Negative -// indices can also be used to specify axes. 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. +// object : numpy object +// Input object. This can be any object (function, class, module, +// ...). +// output : file object, optional +// If `output` not supplied then source code is printed to screen +// (sys.stdout). File object must be created with either write 'w' or +// append 'a' modes. // // See Also // -------- -// 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 -// when using the `axes` keyword argument. +// lookfor, info // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> a -// array([[1, 2], -// [3, 4]]) -// >>> np.transpose(a) -// array([[1, 3], -// [2, 4]]) +// >>> np.source(np.interp) #doctest: +SKIP +// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py +// def interp(x, xp, fp, left=None, right=None): +// """.... (full docstring printed)""" +// if isinstance(x, (float, int, number)): +// return compiled_interp([x], xp, fp, left, right).item() +// else: +// return compiled_interp(x, xp, fp, left, right) // -// >>> a = np.array([1, 2, 3, 4]) -// >>> a -// array([1, 2, 3, 4]) -// >>> np.transpose(a) -// array([1, 2, 3, 4]) +// The source code is only returned for objects written in Python. // -// >>> a = np.ones((1, 2, 3)) -// >>> np.transpose(a, (1, 0, 2)).shape -// (2, 1, 3) +// >>> np.source(np.array) #doctest: +SKIP +// Not available for this object. // -// >>> a = np.ones((2, 3, 4, 5)) -// >>> np.transpose(a).shape -// (5, 4, 3, 2) // -// >>> a = np.arange(3*4*5).reshape((3, 4, 5)) -// >>> np.transpose(a, (-1, 0, -2)).shape -// (5, 3, 4) // +//go:linkname Source py.source +func Source(object *py.Object, output *py.Object) *py.Object +// arange([start,] stop[, step,], dtype=None, *, like=None) // +// Return evenly spaced values within a given interval. // -//go:linkname Transpose py.transpose -func Transpose(a *py.Object, axes *py.Object) *py.Object +// ``arange`` can be called with a varying number of positional arguments: // -// Return the cumulative product of array elements over a given axis treating Not a -// Numbers (NaNs) as one. The cumulative product does not change when NaNs are -// encountered and leading NaNs are replaced by ones. +// * ``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``. // -// Ones are returned for slices that are all-NaN or empty. +// 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 Warning sections below for more information. // // Parameters // ---------- -// a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative product is computed. By default -// the input is flattened. +// start : integer or real, optional +// Start of interval. The interval includes this value. The default +// start value is 0. +// stop : integer or real +// End of interval. The interval does not include this value, except +// in some cases where `step` is not an integer and floating point +// round-off affects the length of `out`. +// step : integer or real, optional +// Spacing between values. For any output `out`, this is the distance +// 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, optional -// Type of the returned array, as well as of the accumulator in which -// the elements are multiplied. If *dtype* is not specified, it -// defaults to the dtype of `a`, unless `a` has an integer dtype with -// a precision less than that of the default platform integer. In -// that case, the default platform integer is used instead. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type of the resulting values will be cast if necessary. +// The type of the output array. If `dtype` is not given, infer the data +// type from the other input arguments. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // // Returns // ------- -// nancumprod : ndarray -// A new array holding the result is returned unless `out` is -// specified, in which case it is returned. +// arange : ndarray +// Array of evenly spaced values. +// +// For floating point arguments, the length of the result is +// ``ceil((stop - start)/step)``. Because of floating point overflow, +// this rule may result in the last element of `out` being greater +// than `stop`. +// +// Warnings +// -------- +// The length of the output might not be numerically stable. +// +// Another stability issue is due to the internal implementation of +// `numpy.arange`. +// The actual step value used to populate the array is +// ``dtype(start + step) - dtype(start)`` and not `step`. Precision loss +// can occur here, due to casting or due to using floating points when +// `start` is much larger than `step`. This can lead to unexpected +// behaviour. For example:: +// +// >>> np.arange(0, 5, 0.5, dtype=int) +// array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) +// >>> np.arange(-3, 3, 0.5, dtype=int) +// array([-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]) +// +// 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.cumprod : Cumulative product across array propagating NaNs. -// isnan : Show which elements are NaN. +// 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 // -------- -// >>> import numpy as np -// >>> np.nancumprod(1) -// array([1]) -// >>> np.nancumprod([1]) -// array([1]) -// >>> np.nancumprod([1, np.nan]) -// array([1., 1.]) -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nancumprod(a) -// array([1., 2., 6., 6.]) -// >>> np.nancumprod(a, axis=0) -// array([[1., 2.], -// [3., 2.]]) -// >>> np.nancumprod(a, axis=1) -// array([[1., 2.], -// [3., 3.]]) -// -// +// >>> np.arange(3) +// array([0, 1, 2]) +// >>> np.arange(3.0) +// array([ 0., 1., 2.]) +// >>> np.arange(3,7) +// array([3, 4, 5, 6]) +// >>> np.arange(3,7,2) +// array([3, 5]) // -//go:linkname Nancumprod py.nancumprod -func Nancumprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object +//go:linkname Arange py.arange +func Arange(start *py.Object, stop *py.Object, step *py.Object, dtype *py.Object) *py.Object // -// Return the cumulative sum of the elements along a given axis. +// Return a string representation of a number in the given base system. // // Parameters // ---------- -// a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative sum is computed. The default -// (None) is to compute the cumsum over the flattened array. -// dtype : dtype, optional -// Type of the returned array and of the accumulator in which the -// elements are summed. If `dtype` is not specified, it defaults -// to the dtype of `a`, unless `a` has an integer dtype with a -// precision less than that of the default platform integer. In -// that case, the default platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type will be cast if necessary. See :ref:`ufuncs-output-type` -// for more details. +// number : int +// The value to convert. Positive and negative values are handled. +// base : int, optional +// Convert `number` to the `base` number system. The valid range is 2-36, +// the default value is 2. +// padding : int, optional +// Number of zeros padded on the left. Default is 0 (no padding). // // Returns // ------- -// cumsum_along_axis : ndarray. -// A new array holding the result is returned unless `out` is -// specified, in which case a reference to `out` is returned. The -// result has the same size as `a`, and the same shape as `a` if -// `axis` is not None or `a` is a 1-d array. +// out : str +// String representation of `number` in `base` system. // // See Also // -------- -// cumulative_sum : Array API compatible alternative for ``cumsum``. -// sum : Sum array elements. -// trapezoid : Integration of array values using composite trapezoidal rule. -// diff : Calculate the n-th discrete difference along given axis. -// -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. -// -// ``cumsum(a)[-1]`` may not be equal to ``sum(a)`` for floating-point -// values since ``sum`` may use a pairwise summation routine, reducing -// the roundoff-error. See `sum` for more information. +// binary_repr : Faster version of `base_repr` for base 2. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1,2,3], [4,5,6]]) -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.cumsum(a) -// array([ 1, 3, 6, 10, 15, 21]) -// >>> np.cumsum(a, dtype=float) # specifies type of output value(s) -// array([ 1., 3., 6., 10., 15., 21.]) +// >>> np.base_repr(5) +// '101' +// >>> np.base_repr(6, 5) +// '11' +// >>> np.base_repr(7, base=5, padding=3) +// '00012' // -// >>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns -// array([[1, 2, 3], -// [5, 7, 9]]) -// >>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows -// array([[ 1, 3, 6], -// [ 4, 9, 15]]) +// >>> np.base_repr(10, base=16) +// 'A' +// >>> np.base_repr(32, base=16) +// '20' // -// ``cumsum(b)[-1]`` may not be equal to ``sum(b)`` // -// >>> b = np.array([1, 2e-9, 3e-9] * 1000000) -// >>> b.cumsum()[-1] -// 1000000.0050045159 -// >>> b.sum() -// 1000000.0050000029 // +//go:linkname BaseRepr py.base_repr +func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object // +// Return a full array with the same shape and type as a given array. // -//go:linkname Cumsum py.cumsum -func Cumsum(__llgo_va_list ...interface{}) *py.Object +// Parameters +// ---------- +// a : array_like +// The shape and data-type of `a` define these same attributes of +// the returned array. +// fill_value : array_like +// Fill value. +// dtype : data-type, optional +// Overrides the data type of the result. +// order : {'C', 'F', 'A', or 'K'}, optional +// Overrides the memory layout of the result. 'C' means C-order, +// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, +// 'C' otherwise. 'K' means match the layout of `a` as closely +// as possible. +// subok : bool, optional. +// If True, then the newly created array will use the sub-class +// type of `a`, otherwise it will be a base-class array. Defaults +// to True. +// shape : int or sequence of ints, optional. +// Overrides the shape of the result. If order='K' and the number of +// dimensions is unchanged, will try to keep order, otherwise, +// order='C' is implied. // -// Return specified diagonals. -// -// If `a` is 2-D, returns the diagonal of `a` with the given offset, -// i.e., the collection of elements of the form ``a[i, i+offset]``. If -// `a` has more than two dimensions, then the axes specified by `axis1` -// and `axis2` are used to determine the 2-D sub-array whose diagonal is -// returned. The shape of the resulting array can be determined by -// removing `axis1` and `axis2` and appending an index to the right equal -// to the size of the resulting diagonals. -// -// In versions of NumPy prior to 1.7, this function always returned a new, -// independent array containing a copy of the values in the diagonal. -// -// In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, -// but depending on this fact is deprecated. Writing to the resulting -// array continues to work as it used to, but a FutureWarning is issued. -// -// Starting in NumPy 1.9 it returns a read-only view on the original array. -// Attempting to write to the resulting array will produce an error. -// -// In some future release, it will return a read/write view and writing to -// the returned array will alter your original array. The returned array -// will have the same type as the input array. -// -// If you don't write to the array returned by this function, then you can -// just ignore all of the above. -// -// If you depend on the current behavior, then we suggest copying the -// returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead -// of just ``np.diagonal(a)``. This will work with both past and future -// versions of NumPy. -// -// Parameters -// ---------- -// a : array_like -// Array from which the diagonals are taken. -// offset : int, optional -// Offset of the diagonal from the main diagonal. Can be positive or -// negative. Defaults to main diagonal (0). -// axis1 : int, optional -// Axis to be used as the first axis of the 2-D sub-arrays from which -// the diagonals should be taken. Defaults to first axis (0). -// axis2 : int, optional -// Axis to be used as the second axis of the 2-D sub-arrays from -// which the diagonals should be taken. Defaults to second axis (1). +// .. versionadded:: 1.17.0 // // Returns // ------- -// array_of_diagonals : ndarray -// If `a` is 2-D, then a 1-D array containing the diagonal and of the -// same type as `a` is returned unless `a` is a `matrix`, in which case -// a 1-D array rather than a (2-D) `matrix` is returned in order to -// maintain backward compatibility. -// -// If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2` -// are removed, and a new axis inserted at the end corresponding to the -// diagonal. -// -// Raises -// ------ -// ValueError -// If the dimension of `a` is less than 2. +// out : ndarray +// Array of `fill_value` with the same shape and type as `a`. // // See Also // -------- -// diag : MATLAB work-a-like for 1-D and 2-D arrays. -// diagflat : Create diagonal arrays. -// trace : Sum along diagonals. +// empty_like : Return an empty array with shape and type of input. +// ones_like : Return an array of ones with shape and type of input. +// zeros_like : Return an array of zeros with shape and type of input. +// full : Return a new array of given shape filled with value. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.arange(4).reshape(2,2) -// >>> a -// array([[0, 1], -// [2, 3]]) -// >>> a.diagonal() -// array([0, 3]) -// >>> a.diagonal(1) -// array([1]) -// -// A 3-D example: -// -// >>> a = np.arange(8).reshape(2,2,2); a -// array([[[0, 1], -// [2, 3]], -// [[4, 5], -// [6, 7]]]) -// >>> a.diagonal(0, # Main diagonals of two arrays created by skipping -// ... 0, # across the outer(left)-most axis last and -// ... 1) # the "middle" (row) axis first. -// array([[0, 6], -// [1, 7]]) +// >>> x = np.arange(6, dtype=int) +// >>> np.full_like(x, 1) +// array([1, 1, 1, 1, 1, 1]) +// >>> np.full_like(x, 0.1) +// array([0, 0, 0, 0, 0, 0]) +// >>> np.full_like(x, 0.1, dtype=np.double) +// array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) +// >>> np.full_like(x, np.nan, dtype=np.double) +// array([nan, nan, nan, nan, nan, nan]) // -// The sub-arrays whose main diagonals we just obtained; note that each -// corresponds to fixing the right-most (column) axis, and that the -// diagonals are "packed" in rows. +// >>> y = np.arange(6, dtype=np.double) +// >>> np.full_like(y, 0.1) +// array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) // -// >>> a[:,:,0] # main diagonal is [0 6] -// array([[0, 2], -// [4, 6]]) -// >>> a[:,:,1] # main diagonal is [1 7] -// array([[1, 3], -// [5, 7]]) +// >>> 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]]]) // -// The anti-diagonal can be obtained by reversing the order of elements -// using either `numpy.flipud` or `numpy.fliplr`. // -// >>> a = np.arange(9).reshape(3, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// >>> np.fliplr(a).diagonal() # Horizontal flip -// array([2, 4, 6]) -// >>> np.flipud(a).diagonal() # Vertical flip -// array([6, 4, 2]) +//go:linkname FullLike py.full_like +func FullLike(a *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object // -// Note that the order in which the diagonal is retrieved varies depending -// on the flip function. +// Return the maximum of an array or maximum along an axis. // +// `amax` is an alias of `~numpy.max`. // -//go:linkname Diagonal py.diagonal -func Diagonal(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Object) *py.Object -// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// See Also +// -------- +// max : alias of this function +// ndarray.max : equivalent method // -// First array elements raised to powers from second array, element-wise. // -// Raise each base in `x1` to the positionally-corresponding power in -// `x2`. `x1` and `x2` must be broadcastable to the same shape. +//go:linkname Amax py.amax +func Amax(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// An integer type raised to a negative integer power will raise a -// ``ValueError``. +// Trigonometric inverse tangent, element-wise. // -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). +// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. // // Parameters // ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -12934,294 +11324,241 @@ func Diagonal(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Objec // // Returns // ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. +// out : ndarray or scalar +// Out has the same shape as `x`. Its real part is in +// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). +// This is a scalar if `x` is a scalar. // // See Also // -------- -// float_power : power function that promotes integers to float -// -// Examples -// -------- -// >>> import numpy as np -// -// Cube each element in an array. +// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) +// and the positive `x`-axis. +// angle : Argument of complex values. // -// >>> x1 = np.arange(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.power(x1, 3) -// array([ 0, 1, 8, 27, 64, 125]) +// Notes +// ----- +// `arctan` is a multi-valued function: for each `x` there are infinitely +// many numbers `z` such that tan(`z`) = `x`. The convention is to return +// the angle `z` whose real part lies in [-pi/2, pi/2]. // -// Raise the bases to different exponents. +// For real-valued input data types, `arctan` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. // -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) +// For complex-valued input, `arctan` is a complex analytic function that +// has [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous +// from the left on the former and from the right on the latter. // -// The effect of broadcasting. +// The inverse tangent is also known as `atan` or tan^{-1}. // -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.power(x1, x2) -// array([[ 0, 1, 8, 27, 16, 5], -// [ 0, 1, 8, 27, 16, 5]]) +// References +// ---------- +// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, +// 10th printing, New York: Dover, 1964, pp. 79. +// https://personal.math.ubc.ca/~cbm/aands/page_79.htm // -// The ``**`` operator can be used as a shorthand for ``np.power`` on -// ndarrays. +// Examples +// -------- +// We expect the arctan of 0 to be 0, and of 1 to be pi/4: // -// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) -// >>> x1 = np.arange(6) -// >>> x1 ** x2 -// array([ 0, 1, 8, 27, 16, 5]) +// >>> np.arctan([0, 1]) +// array([ 0. , 0.78539816]) // -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). +// >>> np.pi/4 +// 0.78539816339744828 // -// >>> x3 = np.array([-1.0, -4.0]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) +// Plot arctan: // -// To get complex results, give the argument ``dtype=complex``. +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-10, 10) +// >>> plt.plot(x, np.arctan(x)) +// >>> plt.axis('tight') +// >>> plt.show() // -// >>> np.power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) +//go:linkname Arctan py.arctan +func Arctan(x *py.Object, out *py.Object) *py.Object // -//go:linkname Pow py.pow -func Pow(__llgo_va_list ...interface{}) *py.Object +// busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None) // -// Return the Hanning window. +// First adjusts the date to fall on a valid day according to +// the ``roll`` rule, then applies offsets to the given dates +// counted in valid days. // -// The Hanning window is a taper formed by using a weighted cosine. +// .. versionadded:: 1.7.0 // // Parameters // ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray, shape(M,) -// The window, with the maximum value normalized to one (the value -// one appears only if `M` is odd). +// dates : array_like of datetime64[D] +// The array of dates to process. +// offsets : array_like of int +// The array of offsets, which is broadcast with ``dates``. +// roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional +// How to treat dates that do not fall on a valid day. The default +// is 'raise'. // -// See Also -// -------- -// bartlett, blackman, hamming, kaiser -// -// Notes -// ----- -// The Hanning window is defined as -// -// .. 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. -// It is also known as the Cosine Bell. Some authors prefer that it be -// called a Hann window, to help avoid confusion with the very similar -// Hamming window. +// * 'raise' means to raise an exception for an invalid day. +// * 'nat' means to return a NaT (not-a-time) for an invalid day. +// * 'forward' and 'following' mean to take the first valid day +// later in time. +// * 'backward' and 'preceding' mean to take the first valid day +// earlier in time. +// * 'modifiedfollowing' means to take the first valid day +// later in time unless it is across a Month boundary, in which +// case to take the first valid day earlier in time. +// * 'modifiedpreceding' means to take the first valid day +// earlier in time unless it is across a Month boundary, in which +// case to take the first valid day later in time. +// weekmask : str or array_like of bool, optional +// A seven-element array indicating which of Monday through Sunday are +// valid days. May be specified as a length-seven list or array, like +// [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string +// like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for +// weekdays, optionally separated by white space. Valid abbreviations +// are: Mon Tue Wed Thu Fri Sat Sun +// holidays : array_like of datetime64[D], optional +// An array of dates to consider as invalid dates. They may be +// specified in any order, and NaT (not-a-time) dates are ignored. +// This list is saved in a normalized form that is suited for +// fast calculations of valid days. +// busdaycal : busdaycalendar, optional +// A `busdaycalendar` object which specifies the valid days. If this +// parameter is provided, neither weekmask nor holidays may be +// provided. +// out : array of datetime64[D], optional +// If provided, this array is filled with the result. // -// Most references to the Hanning window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. +// Returns +// ------- +// out : array of datetime64[D] +// An array with a shape from broadcasting ``dates`` and ``offsets`` +// together, containing the dates with offsets applied. // -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 106-108. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. +// See Also +// -------- +// busdaycalendar : An object that specifies a custom set of valid days. +// is_busday : Returns a boolean array indicating valid days. +// busday_count : Counts how many valid days are in a half-open date range. // // Examples // -------- -// >>> import numpy as np -// >>> np.hanning(12) -// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, -// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, -// 0.07937323, 0. ]) -// -// Plot the window and its frequency response. -// -// .. plot:: -// :include-source: -// -// import matplotlib.pyplot as plt -// from numpy.fft import fft, fftshift -// window = np.hanning(51) -// plt.plot(window) -// plt.title("Hann window") -// plt.ylabel("Amplitude") -// plt.xlabel("Sample") -// plt.show() -// -// plt.figure() -// A = fft(window, 2048) / 25.5 -// mag = np.abs(fftshift(A)) -// freq = np.linspace(-0.5, 0.5, len(A)) -// with np.errstate(divide='ignore', invalid='ignore'): -// response = 20 * np.log10(mag) -// response = np.clip(response, -100, 100) -// plt.plot(freq, response) -// plt.title("Frequency response of the Hann window") -// plt.ylabel("Magnitude [dB]") -// plt.xlabel("Normalized frequency [cycles per sample]") -// plt.axis('tight') -// plt.show() -// +// >>> # First business day in October 2011 (not accounting for holidays) +// ... np.busday_offset('2011-10', 0, roll='forward') +// numpy.datetime64('2011-10-03') +// >>> # Last business day in February 2012 (not accounting for holidays) +// ... np.busday_offset('2012-03', -1, roll='forward') +// numpy.datetime64('2012-02-29') +// >>> # Third Wednesday in January 2011 +// ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed') +// numpy.datetime64('2011-01-19') +// >>> # 2012 Mother's Day in Canada and the U.S. +// ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun') +// numpy.datetime64('2012-05-13') // +// >>> # First business day on or after a date +// ... np.busday_offset('2011-03-20', 0, roll='forward') +// numpy.datetime64('2011-03-21') +// >>> np.busday_offset('2011-03-22', 0, roll='forward') +// numpy.datetime64('2011-03-22') +// >>> # First business day after a date +// ... np.busday_offset('2011-03-20', 1, roll='backward') +// numpy.datetime64('2011-03-21') +// >>> np.busday_offset('2011-03-22', 1, roll='backward') +// numpy.datetime64('2011-03-23') // -//go:linkname Hanning py.hanning -func Hanning(M *py.Object) *py.Object // -// ravel_multi_index(multi_index, dims, mode='raise', order='C') +//go:linkname BusdayOffset py.busday_offset +func BusdayOffset(dates *py.Object, offsets *py.Object, roll *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object // -// Converts a tuple of index arrays into an array of flat -// indices, applying boundary modes to the multi-index. +// Return the indices for the upper-triangle of an (n, m) array. // // Parameters // ---------- -// multi_index : tuple of array_like -// A tuple of integer arrays, one array for each dimension. -// dims : tuple of ints -// The shape of array into which the indices from ``multi_index`` apply. -// mode : {'raise', 'wrap', 'clip'}, optional -// Specifies how out-of-bounds indices are handled. Can specify -// either one mode or a tuple of modes, one mode per index. +// n : int +// The size of the arrays for which the returned indices will +// be valid. +// k : int, optional +// Diagonal offset (see `triu` for details). +// m : int, optional +// .. versionadded:: 1.9.0 // -// * 'raise' -- raise an error (default) -// * 'wrap' -- wrap around -// * 'clip' -- clip to the range +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. // -// In 'clip' mode, a negative index which would normally -// wrap will clip to 0 instead. -// order : {'C', 'F'}, optional -// Determines whether the multi-index should be viewed as -// indexing in row-major (C-style) or column-major -// (Fortran-style) order. // // Returns // ------- -// raveled_indices : ndarray -// An array of indices into the flattened version of an array -// of dimensions ``dims``. +// inds : tuple, shape(2) of ndarrays, shape(`n`) +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. Can be used +// to slice a ndarray of shape(`n`, `n`). // -// See Also +// See also // -------- -// unravel_index +// tril_indices : similar function, for lower-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// triu, tril +// +// Notes +// ----- +// .. versionadded:: 1.4.0 // // Examples // -------- -// >>> import numpy as np -// >>> arr = np.array([[3,6,6],[4,5,1]]) -// >>> np.ravel_multi_index(arr, (7,6)) -// array([22, 41, 37]) -// >>> np.ravel_multi_index(arr, (7,6), order='F') -// array([31, 41, 13]) -// >>> np.ravel_multi_index(arr, (4,6), mode='clip') -// array([22, 23, 19]) -// >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap')) -// array([12, 13, 13]) -// -// >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9)) -// 1621 -// -// -//go:linkname RavelMultiIndex py.ravel_multi_index -func RavelMultiIndex(multiIndex *py.Object, dims *py.Object, mode *py.Object, order *py.Object) *py.Object -// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Compute two different sets of indices to access 4x4 arrays, one for the +// upper triangular part starting at the main diagonal, and one starting two +// diagonals further right: // -// Inverse hyperbolic cosine, element-wise. +// >>> iu1 = np.triu_indices(4) +// >>> iu2 = np.triu_indices(4, 2) // -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Here is how they can be used with a sample array: // -// Returns -// ------- -// arccosh : ndarray -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) // -// See Also -// -------- +// Both for indexing: // -// cosh, arcsinh, sinh, arctanh, tanh +// >>> a[iu1] +// array([ 0, 1, 2, ..., 10, 11, 15]) // -// Notes -// ----- -// `arccosh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `cosh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in ``[-pi, pi]`` and the real part in -// ``[0, inf]``. +// And for assigning values: // -// For real-valued input data types, `arccosh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. +// >>> a[iu1] = -1 +// >>> a +// array([[-1, -1, -1, -1], +// [ 4, -1, -1, -1], +// [ 8, 9, -1, -1], +// [12, 13, 14, -1]]) // -// For complex-valued input, `arccosh` is a complex analytical function that -// has a branch cut `[-inf, 1]` and is continuous from above on it. +// These cover only a small part of the whole array (two diagonals right +// of the main one): // -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arccosh +// >>> a[iu2] = -10 +// >>> a +// array([[ -1, -1, -10, -10], +// [ 4, -1, -1, -10], +// [ 8, 9, -1, -1], +// [ 12, 13, 14, -1]]) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.arccosh([np.e, 10.0]) -// array([ 1.65745445, 2.99322285]) -// >>> np.arccosh(1) -// 0.0 // -//go:linkname Arccosh py.arccosh -func Arccosh(x *py.Object, out *py.Object) *py.Object -// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Compute the bit-wise OR of two arrays element-wise. +//go:linkname TriuIndices py.triu_indices +func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +//go:linkname GreaterEqual py.greater_equal +func GreaterEqual(__llgo_va_list ...interface{}) *py.Object +// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Computes the bit-wise OR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``|``. +// Round elements of the array to the nearest integer. // // Parameters // ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Input array. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -13241,333 +11578,370 @@ func Arccosh(x *py.Object, out *py.Object) *py.Object // Returns // ------- // out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. +// Output array is same shape and type as `x`. +// This is a scalar if `x` is a scalar. // // See Also // -------- -// logical_or -// bitwise_and -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. +// fix, ceil, floor, trunc +// +// Notes +// ----- +// 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. // // Examples // -------- -// >>> import numpy as np +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.rint(a) +// array([-2., -2., -0., 0., 2., 2., 2.]) // -// The number 13 has the binary representation ``00001101``. Likewise, -// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is -// then ``00011101``, or 29: +//go:linkname Rint py.rint +func Rint(x *py.Object, out *py.Object) *py.Object // -// >>> np.bitwise_or(13, 16) -// 29 -// >>> np.binary_repr(29) -// '11101' +// datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind') // -// >>> np.bitwise_or(32, 2) -// 34 -// >>> np.bitwise_or([33, 4], 1) -// array([33, 5]) -// >>> np.bitwise_or([33, 4], [1, 2]) -// array([33, 6]) +// Convert an array of datetimes into an array of strings. // -// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) -// array([ 6, 5, 255]) -// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) -// array([ 6, 5, 255]) -// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), -// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) -// array([ 6, 5, 255, 2147483647], dtype=int32) -// >>> np.bitwise_or([True, True], [False, True]) -// array([ True, True]) +// Parameters +// ---------- +// arr : array_like of datetime64 +// The array of UTC timestamps to format. +// unit : str +// One of None, 'auto', or a :ref:`datetime unit `. +// timezone : {'naive', 'UTC', 'local'} or tzinfo +// Timezone information to use when displaying the datetime. If 'UTC', end +// with a Z to indicate UTC time. If 'local', convert to the local timezone +// first, and suffix with a +-#### timezone offset. If a tzinfo object, +// then do as with 'local', but use the specified timezone. +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'} +// Casting to allow when changing between datetime units. // -// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on -// ndarrays. +// Returns +// ------- +// str_arr : ndarray +// An array of strings the same shape as `arr`. // -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([4, 4, 4]) -// >>> x1 | x2 -// array([ 6, 5, 255]) +// Examples +// -------- +// >>> import pytz +// >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]') +// >>> d +// array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30', +// '2002-10-27T07:30'], dtype='datetime64[m]') // -//go:linkname BitwiseOr py.bitwise_or -func BitwiseOr(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Setting the timezone to UTC shows the same information, but with a Z suffix // -// Calculate `2**p` for all `p` in the input array. +// >>> np.datetime_as_string(d, timezone='UTC') +// array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z', +// '2002-10-27T07:30Z'], dtype='`. +// Note that we picked datetimes that cross a DST boundary. Passing in a +// ``pytz`` timezone object will print the appropriate offset // -// Returns -// ------- -// out : ndarray or scalar -// Element-wise 2 to the power `x`. -// This is a scalar if `x` is a scalar. +// >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern')) +// array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400', +// '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='>> import numpy as np -// >>> np.exp2([2, 3]) -// array([ 4., 8.]) +// >>> np.datetime_as_string(d, unit='h') +// array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'], +// dtype='>> np.datetime_as_string(d, unit='s') +// array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00', +// '2002-10-27T07:30:00'], dtype=' x2) element-wise. +// >>> np.datetime_as_string(d, unit='h', casting='safe') +// Traceback (most recent call last): +// ... +// TypeError: Cannot create a datetime string as units 'h' from a NumPy +// datetime with units 'm' according to the rule 'safe' // -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. // -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. +//go:linkname DatetimeAsString py.datetime_as_string +func DatetimeAsString(arr *py.Object, unit *py.Object, timezone *py.Object, casting *py.Object) *py.Object // +// Split an array into multiple sub-arrays vertically (row-wise). // -// See Also -// -------- -// greater_equal, less, less_equal, equal, not_equal +// Please refer to the ``split`` documentation. ``vsplit`` is equivalent +// to ``split`` with `axis=0` (default), the array is always split along the +// first axis regardless of the array dimension. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.greater([4,2],[2,2]) -// array([ True, False]) +// See Also +// -------- +// split : Split an array into multiple sub-arrays of equal size. // -// The ``>`` operator can be used as a shorthand for ``np.greater`` on -// ndarrays. +// Examples +// -------- +// >>> x = np.arange(16.0).reshape(4, 4) +// >>> x +// array([[ 0., 1., 2., 3.], +// [ 4., 5., 6., 7.], +// [ 8., 9., 10., 11.], +// [12., 13., 14., 15.]]) +// >>> np.vsplit(x, 2) +// [array([[0., 1., 2., 3.], +// [4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.], +// [12., 13., 14., 15.]])] +// >>> np.vsplit(x, np.array([3, 6])) +// [array([[ 0., 1., 2., 3.], +// [ 4., 5., 6., 7.], +// [ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)] // -// >>> a = np.array([4, 2]) -// >>> b = np.array([2, 2]) -// >>> a > b -// array([ True, False]) +// With a higher dimensional array the split is still along the first axis. // -//go:linkname Greater py.greater -func Greater(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// >>> x = np.arange(8.0).reshape(2, 2, 2) +// >>> x +// array([[[0., 1.], +// [2., 3.]], +// [[4., 5.], +// [6., 7.]]]) +// >>> np.vsplit(x, 2) +// [array([[[0., 1.], +// [2., 3.]]]), array([[[4., 5.], +// [6., 7.]]])] // -// Compute the outer product of two vectors. // -// Given two vectors `a` and `b` of length ``M`` and ``N``, respectively, -// the outer product [1]_ is:: // -// [[a_0*b_0 a_0*b_1 ... a_0*b_{N-1} ] -// [a_1*b_0 . -// [ ... . -// [a_{M-1}*b_0 a_{M-1}*b_{N-1} ]] +//go:linkname Vsplit py.vsplit +func Vsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object +// +// Return the indices for the lower-triangle of an (n, m) array. // // Parameters // ---------- -// a : (M,) array_like -// First input vector. Input is flattened if -// not already 1-dimensional. -// b : (N,) array_like -// Second input vector. Input is flattened if -// not already 1-dimensional. -// out : (M, N) ndarray, optional -// A location where the result is stored +// n : int +// The row dimension of the arrays for which the returned +// indices will be valid. +// k : int, optional +// Diagonal offset (see `tril` for details). +// m : int, optional +// .. versionadded:: 1.9.0 +// +// The column dimension of the arrays for which the returned +// arrays will be valid. +// By default `m` is taken equal to `n`. +// // // Returns // ------- -// out : (M, N) ndarray -// ``out[i, j] = a[i] * b[j]`` +// inds : tuple of arrays +// The indices for the triangle. The returned tuple contains two arrays, +// each with the indices along one dimension of the array. // // See also // -------- -// inner -// einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent. -// ufunc.outer : A generalization to dimensions other than 1D and other -// operations. ``np.multiply.outer(a.ravel(), b.ravel())`` -// is the equivalent. -// linalg.outer : An Array API compatible variation of ``np.outer``, -// which accepts 1-dimensional inputs only. -// tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))`` -// is the equivalent. +// triu_indices : similar function, for upper-triangular. +// mask_indices : generic function accepting an arbitrary mask function. +// tril, triu // -// References -// ---------- -// .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd -// ed., Baltimore, MD, Johns Hopkins University Press, 1996, -// pg. 8. +// Notes +// ----- +// .. versionadded:: 1.4.0 // // Examples // -------- -// Make a (*very* coarse) grid for computing a Mandelbrot set: -// -// >>> import numpy as np -// >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)) -// >>> rl -// array([[-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.]]) -// >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,))) -// >>> im -// array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j], -// [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j], -// [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], -// [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j], -// [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]]) -// >>> grid = rl + im -// >>> grid -// array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j], -// [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j], -// [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j], -// [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], -// [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) +// Compute two different sets of indices to access 4x4 arrays, one for the +// lower triangular part starting at the main diagonal, and one starting two +// diagonals further right: // -// An example using a "vector" of letters: +// >>> il1 = np.tril_indices(4) +// >>> il2 = np.tril_indices(4, 2) // -// >>> x = np.array(['a', 'b', 'c'], dtype=object) -// >>> np.outer(x, [1, 2, 3]) -// array([['a', 'aa', 'aaa'], -// ['b', 'bb', 'bbb'], -// ['c', 'cc', 'ccc']], dtype=object) +// Here is how they can be used with a sample array: // +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) // +// Both for indexing: // -//go:linkname Outer py.outer -func Outer(a *py.Object, b *py.Object, out *py.Object) *py.Object +// >>> a[il1] +// array([ 0, 4, 5, ..., 13, 14, 15]) // -// Return the Blackman window. +// And for assigning values: // -// The Blackman window is a taper formed by using the first three -// terms of a summation of cosines. It was designed to have close to the -// minimal leakage possible. It is close to optimal, only slightly worse -// than a Kaiser window. +// >>> a[il1] = -1 +// >>> a +// array([[-1, 1, 2, 3], +// [-1, -1, 6, 7], +// [-1, -1, -1, 11], +// [-1, -1, -1, -1]]) +// +// These cover almost the whole array (two diagonals right of the main one): +// +// >>> a[il2] = -10 +// >>> a +// array([[-10, -10, -10, 3], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10], +// [-10, -10, -10, -10]]) +// +// +// +//go:linkname TrilIndices py.tril_indices +func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// +// Save several arrays into a single file in compressed ``.npz`` format. +// +// Provide arrays as keyword arguments to store them under the +// corresponding name in the output file: ``savez(fn, x=x, y=y)``. +// +// If arrays are specified as positional arguments, i.e., ``savez(fn, +// x, y)``, their names will be `arr_0`, `arr_1`, etc. // // Parameters // ---------- -// M : int -// Number of points in the output window. If zero or less, an empty -// array is returned. +// file : str or file +// Either the filename (string) or an open file (file-like object) +// where the data will be saved. If file is a string or a Path, the +// ``.npz`` extension will be appended to the filename if it is not +// already there. +// args : Arguments, optional +// Arrays to save to the file. Please use keyword arguments (see +// `kwds` below) to assign names to arrays. Arrays specified as +// args will be named "arr_0", "arr_1", and so on. +// kwds : Keyword arguments, optional +// Arrays to save to the file. Each array will be saved to the +// output file with its corresponding keyword name. // // Returns // ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value one -// appears only if the number of samples is odd). +// None // // See Also // -------- -// bartlett, hamming, hanning, kaiser +// numpy.save : Save a single array to a binary file in NumPy format. +// numpy.savetxt : Save an array to a file as plain text. +// numpy.savez : Save several arrays into an uncompressed ``.npz`` file format +// numpy.load : Load the files created by savez_compressed. // // Notes // ----- -// The Blackman window is defined as +// The ``.npz`` file format is a zipped archive of files named after the +// variables they contain. The archive is compressed with +// ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable +// in ``.npy`` format. For a description of the ``.npy`` format, see +// :py:mod:`numpy.lib.format`. // -// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) // -// Most references to the Blackman window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. It is known as a -// "near optimal" tapering function, almost as good (by some measures) -// as the kaiser window. +// When opening the saved ``.npz`` file with `load` a `NpzFile` object is +// returned. This is a dictionary-like object which can be queried for +// its list of arrays (with the ``.files`` attribute), and for the arrays +// themselves. // -// References +// Examples +// -------- +// >>> test_array = np.random.rand(3, 2) +// >>> test_vector = np.random.rand(4) +// >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector) +// >>> loaded = np.load('/tmp/123.npz') +// >>> print(np.array_equal(test_array, loaded['a'])) +// True +// >>> print(np.array_equal(test_vector, loaded['b'])) +// True +// +// +// +//go:linkname SavezCompressed py.savez_compressed +func SavezCompressed(file *py.Object, __llgo_va_list ...interface{}) *py.Object +// +// where(condition, [x, y], /) +// +// Return elements chosen from `x` or `y` depending on `condition`. +// +// .. note:: +// When only `condition` is provided, this function is a shorthand for +// ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be +// preferred, as it behaves correctly for subclasses. The rest of this +// documentation covers only the case where all three arguments are +// provided. +// +// Parameters // ---------- -// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, -// Dover Publications, New York. +// condition : array_like, bool +// Where True, yield `x`, otherwise yield `y`. +// x, y : array_like +// Values from which to choose. `x`, `y` and `condition` need to be +// broadcastable to some shape. // -// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. -// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. +// Returns +// ------- +// out : ndarray +// An array with elements from `x` where `condition` is True, and elements +// from `y` elsewhere. +// +// See Also +// -------- +// choose +// nonzero : The function that is called when x and y are omitted +// +// Notes +// ----- +// If all the arrays are 1-D, `where` is equivalent to:: +// +// [xv if c else yv +// for c, xv, yv in zip(condition, x, y)] // // Examples // -------- -// >>> import numpy as np -// >>> import matplotlib.pyplot as plt -// >>> np.blackman(12) -// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary -// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, -// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, -// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) +// >>> a = np.arange(10) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// >>> np.where(a < 5, a, 10*a) +// array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90]) // -// Plot the window and the frequency response. +// This can be used on multidimensional arrays too: // -// .. plot:: -// :include-source: +// >>> np.where([[True, False], [True, True]], +// ... [[1, 2], [3, 4]], +// ... [[9, 8], [7, 6]]) +// array([[1, 8], +// [3, 4]]) // -// import matplotlib.pyplot as plt -// from numpy.fft import fft, fftshift -// window = np.blackman(51) -// plt.plot(window) -// plt.title("Blackman window") -// plt.ylabel("Amplitude") -// plt.xlabel("Sample") -// plt.show() # doctest: +SKIP -// -// plt.figure() -// A = fft(window, 2048) / 25.5 -// mag = np.abs(fftshift(A)) -// freq = np.linspace(-0.5, 0.5, len(A)) -// with np.errstate(divide='ignore', invalid='ignore'): -// response = 20 * np.log10(mag) -// response = np.clip(response, -100, 100) -// plt.plot(freq, response) -// plt.title("Frequency response of Blackman window") -// plt.ylabel("Magnitude [dB]") -// plt.xlabel("Normalized frequency [cycles per sample]") -// plt.axis('tight') -// plt.show() +// The shapes of x, y, and the condition are broadcast together: // +// >>> x, y = np.ogrid[:3, :4] +// >>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast +// array([[10, 0, 0, 0], +// [10, 11, 1, 1], +// [10, 11, 12, 2]]) // +// >>> a = np.array([[0, 1, 2], +// ... [0, 2, 4], +// ... [0, 3, 6]]) +// >>> np.where(a < 4, a, -1) # -1 is broadcast +// array([[ 0, 1, 2], +// [ 0, 2, -1], +// [ 0, 3, -1]]) // -//go:linkname Blackman py.blackman -func Blackman(M *py.Object) *py.Object -// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Inverse hyperbolic tangent element-wise. +//go:linkname Where py.where +func Where(condition *py.Object, x *py.Object, y *py.Object) *py.Object +// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns the element-wise remainder of division. +// +// This is the NumPy implementation of the C library function fmod, the +// remainder has the same sign as the dividend `x1`. It is equivalent to +// the Matlab(TM) ``rem`` function and should not be confused with the +// Python modulus operator ``x1 % x2``. // // Parameters // ---------- -// x : array_like -// Input array. +// x1 : array_like +// Dividend. +// x2 : array_like +// Divisor. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -13586,172 +11960,134 @@ func Blackman(M *py.Object) *py.Object // // Returns // ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. +// y : array_like +// The remainder of the division of `x1` by `x2`. +// This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// emath.arctanh +// remainder : Equivalent to the Python ``%`` operator. +// divide // // Notes // ----- -// `arctanh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``tanh(z) = x``. The convention is to return -// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arctanh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arctanh` is a complex analytical function -// that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from -// above on the former and from below on the latter. -// -// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arctanh +// The result of the modulo operation for negative dividend and divisors +// is bound by conventions. For `fmod`, the sign of result is the sign of +// the dividend, while for `remainder` the sign of the result is the sign +// of the divisor. The `fmod` function is equivalent to the Matlab(TM) +// ``rem`` function. // // Examples // -------- -// >>> import numpy as np -// >>> np.arctanh([0, -0.5]) -// array([ 0. , -0.54930614]) -// -//go:linkname Arctanh py.arctanh -func Arctanh(x *py.Object, out *py.Object) *py.Object +// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) +// array([-1, 0, -1, 1, 0, 1]) +// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) +// array([1, 0, 1, 1, 0, 1]) // -// Return the indices of the minimum values in the specified axis ignoring -// NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results -// cannot be trusted if a slice contains only NaNs and Infs. +// >>> np.fmod([5, 3], [2, 2.]) +// array([ 1., 1.]) +// >>> a = np.arange(-3, 3).reshape(3, 2) +// >>> a +// array([[-3, -2], +// [-1, 0], +// [ 1, 2]]) +// >>> np.fmod(a, [2,2]) +// array([[-1, 0], +// [-1, 0], +// [ 1, 0]]) // -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : int, optional -// Axis along which to operate. By default flattened input is used. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. +//go:linkname Fmod py.fmod +func Fmod(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// .. versionadded:: 1.22.0 -// 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 array. +// Test element-wise for finiteness (not infinity and not Not a Number). // -// .. versionadded:: 1.22.0 +// The result is returned as a boolean array. // -// Returns -// ------- -// index_array : ndarray -// An array of indices or a single index value. -// -// See Also -// -------- -// argmin, nanargmax -// -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[np.nan, 4], [2, 3]]) -// >>> np.argmin(a) -// 0 -// >>> np.nanargmin(a) -// 2 -// >>> np.nanargmin(a, axis=0) -// array([1, 1]) -// >>> np.nanargmin(a, axis=1) -// array([1, 0]) -// -// -// -//go:linkname Nanargmin py.nanargmin -func Nanargmin(__llgo_va_list ...interface{}) *py.Object -// -// Return the cumulative product of elements along a given axis. -// -// This function is an Array API compatible alternative to `numpy.cumprod`. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative product is computed. The default -// (None) is only allowed for one-dimensional arrays. For arrays -// with more than one dimension ``axis`` is required. -// dtype : dtype, optional -// Type of the returned array, as well as of the accumulator in which -// the elements are multiplied. If ``dtype`` is not specified, it -// defaults to the dtype of ``x``, unless ``x`` has an integer dtype -// with a precision less than that of the default platform integer. -// In that case, the default platform integer is used instead. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type of the resulting values will be cast if necessary. -// See :ref:`ufuncs-output-type` for more details. -// include_initial : bool, optional -// Boolean indicating whether to include the initial value (ones) as -// the first value in the output. With ``include_initial=True`` -// the shape of the output is different than the shape of the input. -// Default: ``False``. -// -// Returns -// ------- -// cumulative_prod_along_axis : ndarray -// A new array holding the result is returned unless ``out`` is -// specified, in which case a reference to ``out`` is returned. The -// result has the same shape as ``x`` if ``include_initial=False``. -// -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// Examples -// -------- -// >>> a = np.array([1, 2, 3]) -// >>> np.cumulative_prod(a) # intermediate results 1, 1*2 -// ... # total product 1*2*3 = 6 -// array([1, 2, 6]) -// >>> a = np.array([1, 2, 3, 4, 5, 6]) -// >>> np.cumulative_prod(a, dtype=float) # specify type of output -// array([ 1., 2., 6., 24., 120., 720.]) +// Returns +// ------- +// y : ndarray, bool +// True where ``x`` is not positive infinity, negative infinity, +// or NaN; false otherwise. +// This is a scalar if `x` is a scalar. // -// The cumulative product for each column (i.e., over the rows) of ``b``: +// See Also +// -------- +// isinf, isneginf, isposinf, isnan // -// >>> b = np.array([[1, 2, 3], [4, 5, 6]]) -// >>> np.cumulative_prod(b, axis=0) -// array([[ 1, 2, 3], -// [ 4, 10, 18]]) +// Notes +// ----- +// Not a Number, positive infinity and negative infinity are considered +// to be non-finite. // -// The cumulative product for each row (i.e. over the columns) of ``b``: +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). This means that Not a Number is not equivalent to infinity. +// Also that positive infinity is not equivalent to negative infinity. But +// infinity is equivalent to positive infinity. Errors result if the +// second argument is also supplied when `x` is a scalar input, or if +// first and second arguments have different shapes. // -// >>> np.cumulative_prod(b, axis=1) -// array([[ 1, 2, 6], -// [ 4, 20, 120]]) +// Examples +// -------- +// >>> np.isfinite(1) +// True +// >>> np.isfinite(0) +// True +// >>> np.isfinite(np.nan) +// False +// >>> np.isfinite(np.inf) +// False +// >>> np.isfinite(np.NINF) +// False +// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) +// array([False, True, False]) // +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isfinite(x, y) +// array([0, 1, 0]) +// >>> y +// array([0, 1, 0]) // +//go:linkname Isfinite py.isfinite +func Isfinite(x *py.Object, out *py.Object) *py.Object +// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname CumulativeProd py.cumulative_prod -func CumulativeProd(x *py.Object) *py.Object -// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Element-wise minimum of array elements. // -// Numerical negative, element-wise. +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then that +// element is returned. If both elements are NaNs then the first is +// returned. The latter distinction is important for complex NaNs, which +// are defined as at least one of the real or imaginary parts being a NaN. +// The net effect is that NaNs are propagated. // // Parameters // ---------- -// x : array_like or scalar -// Input array. +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -13771,331 +12107,514 @@ func CumulativeProd(x *py.Object) *py.Object // Returns // ------- // y : ndarray or scalar -// Returned array or scalar: `y = -x`. -// This is a scalar if `x` is a scalar. +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. +// +// fmax, amax, nanmax +// +// Notes +// ----- +// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when +// neither x1 nor x2 are NaNs, but it is faster and does proper +// broadcasting. // // Examples // -------- -// >>> import numpy as np -// >>> np.negative([1.,-1.]) -// array([-1., 1.]) +// >>> np.minimum([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) // -// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on -// ndarrays. +// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) // -// >>> x1 = np.array(([1., -1.])) -// >>> -x1 -// array([-1., 1.]) +// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([nan, nan, nan]) +// >>> np.minimum(-np.Inf, 1) +// -inf // -//go:linkname Negative py.negative -func Negative(x *py.Object, out *py.Object) *py.Object +//go:linkname Minimum py.minimum +func Minimum(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Append values to the end of an array. +// ravel_multi_index(multi_index, dims, mode='raise', order='C') +// +// Converts a tuple of index arrays into an array of flat +// indices, applying boundary modes to the multi-index. // // Parameters // ---------- -// arr : array_like -// Values are appended to a copy of this array. -// values : array_like -// These values are appended to a copy of `arr`. It must be of the -// correct shape (the same shape as `arr`, excluding `axis`). If -// `axis` is not specified, `values` can be any shape and will be -// flattened before use. -// axis : int, optional -// The axis along which `values` are appended. If `axis` is not -// given, both `arr` and `values` are flattened before use. +// multi_index : tuple of array_like +// A tuple of integer arrays, one array for each dimension. +// dims : tuple of ints +// The shape of array into which the indices from ``multi_index`` apply. +// mode : {'raise', 'wrap', 'clip'}, optional +// Specifies how out-of-bounds indices are handled. Can specify +// either one mode or a tuple of modes, one mode per index. +// +// * 'raise' -- raise an error (default) +// * 'wrap' -- wrap around +// * 'clip' -- clip to the range +// +// In 'clip' mode, a negative index which would normally +// wrap will clip to 0 instead. +// order : {'C', 'F'}, optional +// Determines whether the multi-index should be viewed as +// indexing in row-major (C-style) or column-major +// (Fortran-style) order. // // Returns // ------- -// append : ndarray -// A copy of `arr` with `values` appended to `axis`. Note that -// `append` does not occur in-place: a new array is allocated and -// filled. If `axis` is None, `out` is a flattened array. +// raveled_indices : ndarray +// An array of indices into the flattened version of an array +// of dimensions ``dims``. // // See Also // -------- -// insert : Insert elements into an array. -// delete : Delete elements from an array. +// unravel_index +// +// Notes +// ----- +// .. versionadded:: 1.6.0 // // Examples // -------- -// >>> import numpy as np -// >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]]) -// array([1, 2, 3, ..., 7, 8, 9]) +// >>> arr = np.array([[3,6,6],[4,5,1]]) +// >>> np.ravel_multi_index(arr, (7,6)) +// array([22, 41, 37]) +// >>> np.ravel_multi_index(arr, (7,6), order='F') +// array([31, 41, 13]) +// >>> np.ravel_multi_index(arr, (4,6), mode='clip') +// array([22, 23, 19]) +// >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap')) +// array([12, 13, 13]) // -// When `axis` is specified, `values` must have the correct shape. +// >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9)) +// 1621 // -// >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0) -// array([[1, 2, 3], -// [4, 5, 6], -// [7, 8, 9]]) // -// >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0) -// Traceback (most recent call last): -// ... -// ValueError: all the input arrays must have same number of dimensions, but -// the array at index 0 has 2 dimension(s) and the array at index 1 has 1 -// dimension(s) +//go:linkname RavelMultiIndex py.ravel_multi_index +func RavelMultiIndex(multiIndex *py.Object, dims *py.Object, mode *py.Object, order *py.Object) *py.Object // -// >>> a = np.array([1, 2], dtype=int) -// >>> c = np.append(a, []) -// >>> c -// array([1., 2.]) -// >>> c.dtype -// float64 +// Compute the weighted average along the specified axis. // -// Default dtype for empty ndarrays is `float64` thus making the output of dtype -// `float64` when appended with dtype `int64` +// Parameters +// ---------- +// a : array_like +// Array containing data to be averaged. If `a` is not an array, a +// conversion is attempted. +// axis : None or int or tuple of ints, optional +// Axis or axes along which to average `a`. The default, +// axis=None, will average over all of the elements of the input array. +// If axis is negative it counts from the last to the first axis. // +// .. versionadded:: 1.7.0 // +// If axis is a tuple of ints, averaging is performed on all of the axes +// specified in the tuple instead of a single axis or all the axes as +// before. +// weights : array_like, optional +// An array of weights associated with the values in `a`. Each value in +// `a` contributes to the average according to its associated weight. +// The weights array can either be 1-D (in which case its length must be +// the size of `a` along the given axis) or of the same shape as `a`. +// If `weights=None`, then all data in `a` are assumed to have a +// weight equal to one. The 1-D calculation is:: // -//go:linkname Append py.append -func Append(arr *py.Object, values *py.Object, axis *py.Object) *py.Object -// -// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. +// avg = sum(a * weights) / sum(weights) // -// .. warning:: Loading files that contain object arrays uses the ``pickle`` -// module, which is not secure against erroneous or maliciously -// constructed data. Consider passing ``allow_pickle=False`` to -// load data that is known not to contain object arrays for the -// safer handling of untrusted sources. +// The only constraint on `weights` is that `sum(weights)` must not be 0. +// returned : bool, optional +// Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`) +// 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`. // -// Parameters -// ---------- -// file : file-like object, string, or pathlib.Path -// The file to read. File-like objects must support 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 -// `numpy.memmap` for a detailed description of the modes). A -// memory-mapped array is kept on disk. However, it can be accessed -// and sliced like any ndarray. Memory mapping is especially useful -// for accessing small fragments of large files without reading the -// entire file into memory. -// allow_pickle : bool, optional -// Allow loading pickled object arrays stored in npy files. Reasons for -// disallowing pickles include security, as loading pickled data can -// execute arbitrary code. If pickles are disallowed, loading object -// arrays will fail. Default: False -// fix_imports : bool, optional -// Only useful when loading Python 2 generated pickled files, -// which includes npy/npz files containing object arrays. If `fix_imports` -// is True, pickle will try to map the old Python 2 names to the new names -// used in Python 3. -// encoding : str, optional -// What encoding to use when reading Python 2 strings. Only useful when -// loading Python 2 generated pickled files, which includes -// 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:func:`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. +// .. versionadded:: 1.23.0 // // Returns // ------- -// result : array, tuple, dict, etc. -// Data stored in the file. For ``.npz`` files, the returned instance -// of NpzFile class must be closed to avoid leaking file descriptors. +// retval, [sum_of_weights] : array_type or double +// Return the average along the specified axis. When `returned` is `True`, +// return a tuple with the average as the first element and the sum +// of the weights as the second element. `sum_of_weights` is of the +// same type as `retval`. The result dtype follows a genereal pattern. +// If `weights` is None, the result dtype will be that of `a` , or ``float64`` +// if `a` is integral. Otherwise, if `weights` is not None and `a` is non- +// integral, the result type will be the type of lowest precision capable of +// representing values of both `a` and `weights`. If `a` happens to be +// integral, the previous rules still applies but the result dtype will +// at least be ``float64``. // // Raises // ------ -// OSError -// If the input file does not exist or cannot be read. -// UnpicklingError -// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. -// ValueError -// The file contains an object array, but ``allow_pickle=False`` given. -// EOFError -// When calling ``np.load`` multiple times on the same file handle, -// if all data has already been read +// ZeroDivisionError +// When all weights along axis are zero. See `numpy.ma.average` for a +// version robust to this type of error. +// TypeError +// When the length of 1D `weights` is not the same as the shape of `a` +// along axis. // // See Also // -------- -// save, savez, savez_compressed, loadtxt -// memmap : Create a memory-map to an array stored in a file on disk. -// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. -// -// Notes -// ----- -// - If the file contains pickle data, then whatever object is stored -// in the pickle is returned. -// - If the file is a ``.npy`` file, then a single array is returned. -// - If the file is a ``.npz`` file, then a dictionary-like object is -// returned, containing ``{filename: array}`` key-value pairs, one for -// each file in the archive. -// - If the file is a ``.npz`` file, the returned value supports the -// context manager protocol in a similar fashion to the open function:: -// -// with load('foo.npz') as data: -// a = data['a'] +// mean // -// The underlying file descriptor is closed when exiting the 'with' -// block. +// ma.average : average for masked arrays -- useful if your data contains +// "missing" values +// numpy.result_type : Returns the type that results from applying the +// numpy type promotion rules to the arguments. // // Examples // -------- -// >>> import numpy as np -// -// Store data to disk, and load it again: +// >>> data = np.arange(1, 5) +// >>> data +// array([1, 2, 3, 4]) +// >>> np.average(data) +// 2.5 +// >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1)) +// 4.0 // -// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) -// >>> np.load('/tmp/123.npy') -// array([[1, 2, 3], -// [4, 5, 6]]) +// >>> data = np.arange(6).reshape((3, 2)) +// >>> data +// array([[0, 1], +// [2, 3], +// [4, 5]]) +// >>> np.average(data, axis=1, weights=[1./4, 3./4]) +// array([0.75, 2.75, 4.75]) +// >>> np.average(data, weights=[1./4, 3./4]) +// Traceback (most recent call last): +// ... +// TypeError: Axis must be specified when shapes of a and weights differ. // -// Store compressed data to disk, and load it again: +// >>> a = np.ones(5, dtype=np.float128) +// >>> w = np.ones(5, dtype=np.complex64) +// >>> avg = np.average(a, weights=w) +// >>> print(avg.dtype) +// complex256 // -// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) -// >>> b=np.array([1, 2]) -// >>> np.savez('/tmp/123.npz', a=a, b=b) -// >>> data = np.load('/tmp/123.npz') -// >>> data['a'] -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> data['b'] -// array([1, 2]) -// >>> data.close() +// With ``keepdims=True``, the following result has shape (3, 1). // -// Mem-map the stored array, and then access the second row -// directly from disk: +// >>> np.average(data, axis=1, keepdims=True) +// array([[0.5], +// [2.5], +// [4.5]]) // -// >>> X = np.load('/tmp/123.npy', mmap_mode='r') -// >>> X[1, :] -// memmap([4, 5, 6]) // +//go:linkname Average py.average +func Average(a *py.Object, axis *py.Object, weights *py.Object, returned *py.Object) *py.Object +// array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, +// like=None) // +// Create an array. // -//go:linkname Load py.load -func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object +// Parameters +// ---------- +// object : array_like +// An array, any object exposing the array interface, an object whose +// ``__array__`` method returns an array, or any (nested) sequence. +// If object is a scalar, a 0-dimensional array containing object is +// returned. +// dtype : data-type, optional +// The desired data-type for the array. If not given, NumPy will try to use +// a default ``dtype`` that can represent the values (by applying promotion +// rules when necessary.) +// copy : bool, optional +// If true (default), then the object is copied. Otherwise, a copy will +// only be made if ``__array__`` returns a copy, if obj is a nested +// sequence, or if a copy is needed to satisfy any of the other +// requirements (``dtype``, ``order``, etc.). +// order : {'K', 'A', 'C', 'F'}, optional +// Specify the memory layout of the array. If object is not an array, the +// newly created array will be in C order (row major) unless 'F' is +// specified, in which case it will be in Fortran order (column major). +// If object is an array the following holds. // -// datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind') +// ===== ========= =================================================== +// order no copy copy=True +// ===== ========= =================================================== +// 'K' unchanged F & C order preserved, otherwise most similar order +// 'A' unchanged F order if input is F and not C, otherwise C order +// 'C' C order C order +// 'F' F order F order +// ===== ========= =================================================== // -// Convert an array of datetimes into an array of strings. +// When ``copy=False`` and a copy is made for other reasons, the result is +// the same as if ``copy=True``, with some exceptions for 'A', see the +// Notes section. The default order is 'K'. +// subok : bool, optional +// If True, then sub-classes will be passed-through, otherwise +// 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 prepended to the shape as +// needed to meet this requirement. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. // -// Parameters -// ---------- -// arr : array_like of datetime64 -// The array of UTC timestamps to format. -// unit : str -// One of None, 'auto', or -// a :ref:`datetime unit `. -// timezone : {'naive', 'UTC', 'local'} or tzinfo -// Timezone information to use when displaying the datetime. If 'UTC', -// end with a Z to indicate UTC time. If 'local', convert to the local -// timezone first, and suffix with a +-#### timezone offset. If a tzinfo -// object, then do as with 'local', but use the specified timezone. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'} -// Casting to allow when changing between datetime units. +// .. versionadded:: 1.20.0 // // Returns // ------- -// str_arr : ndarray -// An array of strings the same shape as `arr`. +// out : ndarray +// An array object satisfying the specified requirements. // -// Examples +// See Also // -------- -// >>> import numpy as np -// >>> import pytz -// >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]') -// >>> d -// array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30', -// '2002-10-27T07:30'], dtype='datetime64[m]') +// empty_like : Return an empty array with shape and type of input. +// ones_like : Return an array of ones with shape and type of input. +// zeros_like : Return an array of zeros with shape and type of input. +// full_like : Return a new array with shape of input filled with value. +// empty : Return a new uninitialized array. +// ones : Return a new array setting values to one. +// zeros : Return a new array setting values to zero. +// full : Return a new array of given shape filled with value. // -// Setting the timezone to UTC shows the same information, but with a Z suffix // -// >>> np.datetime_as_string(d, timezone='UTC') -// array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z', -// '2002-10-27T07:30Z'], dtype='>> np.array([1, 2, 3]) +// array([1, 2, 3]) // -// >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern')) -// array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400', -// '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='>> np.array([1, 2, 3.0]) +// array([ 1., 2., 3.]) // -// >>> np.datetime_as_string(d, unit='h') -// array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'], -// dtype='>> np.datetime_as_string(d, unit='s') -// array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00', -// '2002-10-27T07:30:00'], dtype='>> np.array([[1, 2], [3, 4]]) +// array([[1, 2], +// [3, 4]]) // -// >>> np.datetime_as_string(d, unit='h', casting='safe') -// Traceback (most recent call last): -// ... -// TypeError: Cannot create a datetime string as units 'h' from a NumPy -// datetime with units 'm' according to the rule 'safe' +// Minimum dimensions 2: // +// >>> np.array([1, 2, 3], ndmin=2) +// array([[1, 2, 3]]) // -//go:linkname DatetimeAsString py.datetime_as_string -func DatetimeAsString(arr *py.Object, unit *py.Object, timezone *py.Object, casting *py.Object) *py.Object -//go:linkname Log1p py.log1p -func Log1p(__llgo_va_list ...interface{}) *py.Object -//go:linkname Nextafter py.nextafter -func Nextafter(__llgo_va_list ...interface{}) *py.Object +// Type provided: // -// Return the directory that contains the NumPy \*.h header files. +// >>> np.array([1, 2, 3], dtype=complex) +// array([ 1.+0.j, 2.+0.j, 3.+0.j]) // -// Extension modules that need to compile against NumPy may need to use this -// function to locate the appropriate include directory. +// Data-type consisting of more than one element: // -// Notes -// ----- -// When using ``setuptools``, for example in ``setup.py``:: +// >>> x = np.array([(1,2),(3,4)],dtype=[('a','>> x['a'] +// array([1, 3]) // -// import numpy as np -// ... -// Extension('extension_name', ... -// include_dirs=[np.get_include()]) -// ... +// Creating an array from sub-classes: +// +// >>> np.array(np.mat('1 2; 3 4')) +// array([[1, 2], +// [3, 4]]) +// +// >>> np.array(np.mat('1 2; 3 4'), subok=True) +// matrix([[1, 2], +// [3, 4]]) +// +//go:linkname Array py.array +func Array(object *py.Object, dtype *py.Object) *py.Object +// fromstring(string, dtype=float, count=-1, *, sep, like=None) +// +// A new 1-D array initialized from text data in a string. +// +// Parameters +// ---------- +// string : str +// A string containing the data. +// dtype : data-type, optional +// The data type of the array; default: float. For binary input data, +// the data must be in exactly this format. Most builtin numeric types are +// supported and extension types may be supported. +// +// .. versionadded:: 1.18.0 +// Complex dtypes. +// +// count : int, optional +// Read this number of `dtype` elements from the data. If this is +// negative (the default), the count will be determined from the +// length of the data. +// sep : str, optional +// The string separating numbers in the data; extra whitespace between +// elements is also ignored. +// +// .. deprecated:: 1.14 +// Passing ``sep=''``, the default, is deprecated since it will +// trigger the deprecated binary mode of this function. This mode +// interprets `string` as binary bytes, rather than ASCII text with +// 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 utf-8, which will not produce sane results. +// +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // -// Note that a CLI tool ``numpy-config`` was introduced in NumPy 2.0, using -// that is likely preferred for build systems other than ``setuptools``:: +// Returns +// ------- +// arr : ndarray +// The constructed array. // -// $ numpy-config --cflags -// -I/path/to/site-packages/numpy/_core/include +// Raises +// ------ +// ValueError +// If the string is not the correct size to satisfy the requested +// `dtype` and `count`. // -// # Or rely on pkg-config: -// $ export PKG_CONFIG_PATH=$(numpy-config --pkgconfigdir) -// $ pkg-config --cflags -// -I/path/to/site-packages/numpy/_core/include +// See Also +// -------- +// frombuffer, fromfile, fromiter // // Examples // -------- -// >>> np.get_include() -// '.../site-packages/numpy/core/include' # may vary +// >>> np.fromstring('1 2', dtype=int, sep=' ') +// array([1, 2]) +// >>> np.fromstring('1, 2', dtype=int, sep=',') +// array([1, 2]) // +//go:linkname Fromstring py.fromstring +func Fromstring(string *py.Object, dtype *py.Object, count *py.Object) *py.Object // +// Repeat each element of an array after themselves // -//go:linkname GetInclude py.get_include -func GetInclude() *py.Object -// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Parameters +// ---------- +// a : array_like +// Input array. +// repeats : int or array of ints +// The number of repetitions for each element. `repeats` is broadcasted +// to fit the shape of the given axis. +// axis : int, optional +// The axis along which to repeat values. By default, use the +// flattened input array, and return a flat output array. // -// Shift the bits of an integer to the right. +// Returns +// ------- +// repeated_array : ndarray +// Output array which has the same shape as `a`, except along +// the given axis. // -// Bits are shifted to the right `x2`. Because the internal -// representation of numbers is in binary format, this operation is -// equivalent to dividing `x1` by ``2**x2``. +// See Also +// -------- +// tile : Tile an array. +// unique : Find the unique elements of an array. +// +// Examples +// -------- +// >>> np.repeat(3, 4) +// array([3, 3, 3, 3]) +// >>> x = np.array([[1,2],[3,4]]) +// >>> np.repeat(x, 2) +// array([1, 1, 2, 2, 3, 3, 4, 4]) +// >>> np.repeat(x, 3, axis=1) +// array([[1, 1, 1, 2, 2, 2], +// [3, 3, 3, 4, 4, 4]]) +// >>> np.repeat(x, [1, 2], axis=0) +// array([[1, 2], +// [3, 4], +// [3, 4]]) +// +// +// +//go:linkname Repeat py.repeat +func Repeat(a *py.Object, repeats *py.Object, axis *py.Object) *py.Object +// +// Return the sum along diagonals of the array. +// +// If `a` is 2-D, the sum along its diagonal with the given offset +// is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i. +// +// If `a` has more than two dimensions, then the axes specified by axis1 and +// axis2 are used to determine the 2-D sub-arrays whose traces are returned. +// The shape of the resulting array is the same as that of `a` with `axis1` +// and `axis2` removed. +// +// Parameters +// ---------- +// a : array_like +// Input array, from which the diagonals are taken. +// offset : int, optional +// Offset of the diagonal from the main diagonal. Can be both positive +// and negative. Defaults to 0. +// axis1, axis2 : int, optional +// Axes to be used as the first and second axis of the 2-D sub-arrays +// from which the diagonals should be taken. Defaults are the first two +// axes of `a`. +// dtype : dtype, optional +// Determines the data-type of the returned array and of the accumulator +// where the elements are summed. If dtype has the value None and `a` is +// of integer type of precision less than the default integer +// precision, then the default integer precision is used. Otherwise, +// the precision is the same as that of `a`. +// out : ndarray, optional +// Array into which the output is placed. Its type is preserved and +// it must be of the right shape to hold the output. +// +// Returns +// ------- +// sum_along_diagonals : ndarray +// If `a` is 2-D, the sum along the diagonal is returned. If `a` has +// larger dimensions, then an array of sums along diagonals is returned. +// +// See Also +// -------- +// diag, diagonal, diagflat +// +// Examples +// -------- +// >>> np.trace(np.eye(3)) +// 3.0 +// >>> a = np.arange(8).reshape((2,2,2)) +// >>> np.trace(a) +// array([6, 8]) +// +// >>> a = np.arange(24).reshape((2,2,2,3)) +// >>> np.trace(a).shape +// (2, 3) +// +// +// +//go:linkname Trace py.trace +func Trace(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Object, dtype *py.Object, out *py.Object) *py.Object +// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the base 10 logarithm of the input array, element-wise. // // Parameters // ---------- -// x1 : array_like, int +// x : array_like // Input values. -// x2 : array_like, int -// Number of bits to remove at the right of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -14114,1216 +12633,1140 @@ func GetInclude() *py.Object // // Returns // ------- -// out : ndarray, int -// Return `x1` with bits shifted `x2` times to the right. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray +// The logarithm to the base 10 of `x`, element-wise. NaNs are +// returned where x is negative. +// This is a scalar if `x` is a scalar. // // See Also // -------- -// left_shift : Shift the bits of an integer to the left. -// binary_repr : Return the binary representation of the input number -// as a string. +// emath.log10 // -// Examples -// -------- -// >>> import numpy as np -// >>> np.binary_repr(10) -// '1010' -// >>> np.right_shift(10, 1) -// 5 -// >>> np.binary_repr(5) -// '101' +// Notes +// ----- +// 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]`. // -// >>> np.right_shift(10, [1,2,3]) -// array([5, 2, 1]) +// For real-valued input data types, `log10` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. // -// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on -// ndarrays. +// For complex-valued input, `log10` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. +// `log10` handles the floating-point negative zero as an infinitesimal +// negative number, conforming to the C99 standard. // -// >>> x1 = 10 -// >>> x2 = np.array([1,2,3]) -// >>> x1 >> x2 -// array([5, 2, 1]) +// 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`. // -//go:linkname BitwiseRightShift py.bitwise_right_shift -func BitwiseRightShift(__llgo_va_list ...interface{}) *py.Object -// gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 67. +// https://personal.math.ubc.ca/~cbm/aands/page_67.htm +// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm // -// Returns the greatest common divisor of ``|x1|`` and ``|x2|`` +// Examples +// -------- +// >>> np.log10([1e-15, -3.]) +// array([-15., nan]) // -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The greatest common divisor of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// lcm : The lowest common multiple -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.gcd(12, 20) -// 4 -// >>> np.gcd.reduce([15, 25, 35]) -// 5 -// >>> np.gcd(np.arange(6), 20) -// array([20, 1, 2, 1, 4, 5]) -// -//go:linkname Gcd py.gcd -func Gcd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// bincount(x, /, weights=None, minlength=0) +//go:linkname Log10 py.log10 +func Log10(x *py.Object, out *py.Object) *py.Object // -// Count number of occurrences of each value in array of non-negative ints. +// Modified Bessel function of the first kind, order 0. // -// The number of bins (of size 1) is one larger than the largest value in -// `x`. If `minlength` is specified, there will be at least this number -// of bins in the output array (though it will be longer if necessary, -// depending on the contents of `x`). -// Each bin gives the number of occurrences of its index value in `x`. -// If `weights` is specified the input array is weighted by it, i.e. if a -// value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead -// of ``out[n] += 1``. +// Usually denoted :math:`I_0`. // // Parameters // ---------- -// x : array_like, 1 dimension, nonnegative ints -// Input array. -// weights : array_like, optional -// Weights, array of the same shape as `x`. -// minlength : int, optional -// A minimum number of bins for the output array. +// x : array_like of float +// Argument of the Bessel function. // // Returns // ------- -// out : ndarray of ints -// The result of binning the input array. -// The length of `out` is equal to ``np.amax(x)+1``. -// -// Raises -// ------ -// ValueError -// If the input is not 1-dimensional, or contains elements with negative -// values, or if `minlength` is negative. -// TypeError -// If the type of the input is float or complex. +// out : ndarray, shape = x.shape, dtype = float +// The modified Bessel function evaluated at each of the elements of `x`. // // See Also // -------- -// histogram, digitize, unique +// scipy.special.i0, scipy.special.iv, scipy.special.ive // -// Examples -// -------- -// >>> import numpy as np -// >>> np.bincount(np.arange(5)) -// array([1, 1, 1, 1, 1]) -// >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) -// array([1, 3, 1, 1, 0, 0, 0, 1]) +// Notes +// ----- +// The scipy implementation is recommended over this function: it is a +// proper ufunc written in C, and more than an order of magnitude faster. // -// >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) -// >>> np.bincount(x).size == np.amax(x)+1 -// True +// We use the algorithm published by Clenshaw [1]_ and referenced by +// Abramowitz and Stegun [2]_, for which the function domain is +// partitioned into the two intervals [0,8] and (8,inf), and Chebyshev +// polynomial expansions are employed in each interval. Relative error on +// the domain [0,30] using IEEE arithmetic is documented [3]_ as having a +// peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000). // -// The input array needs to be of integer dtype, otherwise a -// TypeError is raised: +// References +// ---------- +// .. [1] C. W. Clenshaw, "Chebyshev series for mathematical functions", in +// *National Physical Laboratory Mathematical Tables*, vol. 5, London: +// Her Majesty's Stationery Office, 1962. +// .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical +// Functions*, 10th printing, New York: Dover, 1964, pp. 379. +// https://personal.math.ubc.ca/~cbm/aands/page_379.htm +// .. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero // -// >>> np.bincount(np.arange(5, dtype=float)) -// Traceback (most recent call last): -// ... -// TypeError: Cannot cast array data from dtype('float64') to dtype('int64') -// according to the rule 'safe' +// Examples +// -------- +// >>> np.i0(0.) +// array(1.0) +// >>> np.i0([0, 1, 2, 3]) +// array([1. , 1.26606588, 2.2795853 , 4.88079259]) // -// A possible use of ``bincount`` is to perform sums over -// variable-size chunks of an array, using the ``weights`` keyword. // -// >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights -// >>> x = np.array([0, 1, 1, 2, 2, 2]) -// >>> np.bincount(x, weights=w) -// array([ 0.3, 0.7, 1.1]) // +//go:linkname I0 py.i0 +func I0(x *py.Object) *py.Object // +// Round to nearest integer towards zero. // -//go:linkname Bincount py.bincount -func Bincount(x *py.Object, weights *py.Object, minlength *py.Object) *py.Object +// Round an array of floats element-wise to nearest integer towards zero. +// The rounded values are returned as floats. // -// Split an array into multiple sub-arrays vertically (row-wise). +// Parameters +// ---------- +// x : array_like +// An array of floats to be rounded +// out : ndarray, optional +// A location into which the result is stored. If provided, it must have +// a shape that the input broadcasts to. If not provided or None, a +// freshly-allocated array is returned. // -// Please refer to the ``split`` documentation. ``vsplit`` is equivalent -// to ``split`` with `axis=0` (default), the array is always split along the -// first axis regardless of the array dimension. +// Returns +// ------- +// out : ndarray of floats +// A float array with the same dimensions as the input. +// If second argument is not supplied then a float array is returned +// with the rounded values. +// +// If a second argument is supplied the result is stored there. +// The return value `out` is then a reference to that array. // // See Also // -------- -// split : Split an array into multiple sub-arrays of equal size. +// rint, trunc, floor, ceil +// around : Round to given number of decimals // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(16.0).reshape(4, 4) -// >>> x -// array([[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.], -// [ 8., 9., 10., 11.], -// [12., 13., 14., 15.]]) -// >>> np.vsplit(x, 2) -// [array([[0., 1., 2., 3.], -// [4., 5., 6., 7.]]), -// array([[ 8., 9., 10., 11.], -// [12., 13., 14., 15.]])] -// >>> np.vsplit(x, np.array([3, 6])) -// [array([[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.], -// [ 8., 9., 10., 11.]]), -// array([[12., 13., 14., 15.]]), -// array([], shape=(0, 4), dtype=float64)] -// -// With a higher dimensional array the split is still along the first axis. +// >>> np.fix(3.14) +// 3.0 +// >>> np.fix(3) +// 3.0 +// >>> np.fix([2.1, 2.9, -2.1, -2.9]) +// array([ 2., 2., -2., -2.]) // -// >>> x = np.arange(8.0).reshape(2, 2, 2) -// >>> x -// array([[[0., 1.], -// [2., 3.]], -// [[4., 5.], -// [6., 7.]]]) -// >>> np.vsplit(x, 2) -// [array([[[0., 1.], -// [2., 3.]]]), -// array([[[4., 5.], -// [6., 7.]]])] // // +//go:linkname Fix py.fix +func Fix(x *py.Object, out *py.Object) *py.Object // -//go:linkname Vsplit py.vsplit -func Vsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object +// Find the coefficients of a polynomial with the given sequence of roots. // -// Test whether any array element along a given axis evaluates to True. +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. // -// Returns single boolean if `axis` is ``None`` +// Returns the coefficients of the polynomial whose leading coefficient +// is one for the given sequence of zeros (multiple roots must be included +// in the sequence as many times as their multiplicity; see Examples). +// A square matrix (or array, which will be treated as a matrix) can also +// be given, in which case the coefficients of the characteristic polynomial +// of the matrix are returned. // // Parameters // ---------- -// a : array_like -// Input array or object that can be converted to an array. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a logical OR reduction is performed. -// The default (``axis=None``) is to perform a logical OR over all -// the dimensions of the input array. `axis` may be negative, in -// which case it counts from the last to the first axis. If this -// is a tuple of ints, a reduction is performed on multiple -// axes, instead of a single axis or all the axes as before. -// out : ndarray, optional -// Alternate output array in which to place the result. It must have -// the same shape as the expected output and its type is preserved -// (e.g., if it is of type float, then it will remain so, returning -// 1.0 for True and 0.0 for False, regardless of the type of `a`). -// See :ref:`ufuncs-output-type` for more details. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `any` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// where : array_like of bool, optional -// Elements to include in checking for any `True` values. -// See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.20.0 +// seq_of_zeros : array_like, shape (N,) or (N, N) +// A sequence of polynomial roots, or a square array or matrix object. // // Returns // ------- -// any : bool or ndarray -// A new boolean or `ndarray` is returned unless `out` is specified, -// in which case a reference to `out` is returned. +// c : ndarray +// 1D array of polynomial coefficients from highest to lowest degree: +// +// ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]`` +// where c[0] always equals 1. +// +// Raises +// ------ +// ValueError +// If input is the wrong shape (the input must be a 1-D or square +// 2-D array). // // See Also // -------- -// ndarray.any : equivalent method -// -// all : Test whether all elements along a given axis evaluate to True. +// polyval : Compute polynomial values. +// roots : Return the roots of a polynomial. +// polyfit : Least squares polynomial fit. +// poly1d : A one-dimensional polynomial class. // // Notes // ----- -// Not a Number (NaN), positive infinity and negative infinity evaluate -// to `True` because these are not equal to zero. -// -// .. versionchanged:: 2.0 -// Before NumPy 2.0, ``any`` did not return booleans for object dtype -// input arrays. -// This behavior is still available via ``np.logical_or.reduce``. +// Specifying the roots of a polynomial still leaves one degree of +// freedom, typically represented by an undetermined leading +// coefficient. [1]_ In the case of this function, that coefficient - +// the first one in the returned array - is always taken as one. (If +// for some reason you have one other point, the only automatic way +// presently to leverage that information is to use ``polyfit``.) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.any([[True, False], [True, True]]) -// True +// The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n` +// matrix **A** is given by // -// >>> np.any([[True, False, True ], -// ... [False, False, False]], axis=0) -// array([ True, False, True]) +// :math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`, // -// >>> np.any([-1, 0, 5]) -// True +// where **I** is the `n`-by-`n` identity matrix. [2]_ // -// >>> np.any([[np.nan], [np.inf]], axis=1, keepdims=True) -// array([[ True], -// [ True]]) +// References +// ---------- +// .. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trigonometry, +// Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996. // -// >>> np.any([[True, False], [False, False]], where=[[False], [True]]) -// False +// .. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition," +// Academic Press, pg. 182, 1980. // -// >>> a = np.array([[1, 0, 0], -// ... [0, 0, 1], -// ... [0, 0, 0]]) -// >>> np.any(a, axis=0) -// array([ True, False, True]) -// >>> np.any(a, axis=1) -// array([ True, True, False]) +// Examples +// -------- +// Given a sequence of a polynomial's zeros: // -// >>> o=np.array(False) -// >>> z=np.any([-1, 4, 5], out=o) -// >>> z, o -// (array(True), array(True)) -// >>> # Check now that z is a reference to o -// >>> z is o -// True -// >>> id(z), id(o) # identity of z and o # doctest: +SKIP -// (191614240, 191614240) +// >>> np.poly((0, 0, 0)) # Multiple root example +// array([1., 0., 0., 0.]) // +// The line above represents z**3 + 0*z**2 + 0*z + 0. // +// >>> np.poly((-1./2, 0, 1./2)) +// array([ 1. , 0. , -0.25, 0. ]) // -//go:linkname Any py.any -func Any(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object) *py.Object -// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// The line above represents z**3 - z/4 // -// First array elements raised to powers from second array, element-wise. +// >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0])) +// array([ 1. , -0.77086955, 0.08618131, 0. ]) # random // -// Raise each base in `x1` to the positionally-corresponding power in `x2`. -// `x1` and `x2` must be broadcastable to the same shape. This differs from -// the power function in that integers, float16, and float32 are promoted to -// floats with a minimum precision of float64 so that the result is always -// inexact. The intent is that the function will return a usable result for -// negative powers and seldom overflow for positive powers. +// Given a square array object: // -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). +// >>> P = np.array([[0, 1./3], [-1./2, 0]]) +// >>> np.poly(P) +// array([1. , 0. , 0.16666667]) // -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Note how in all cases the leading coefficient is always 1. // -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. // -// See Also -// -------- -// power : power function that preserves type // -// Examples -// -------- -// >>> import numpy as np +//go:linkname Poly py.poly +func Poly(seqOfZeros *py.Object) *py.Object // -// Cube each element in a list. +// Return indices that are non-zero in the flattened version of a. // -// >>> x1 = range(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.float_power(x1, 3) -// array([ 0., 1., 8., 27., 64., 125.]) +// This is equivalent to ``np.nonzero(np.ravel(a))[0]``. // -// Raise the bases to different exponents. +// Parameters +// ---------- +// a : array_like +// Input data. // -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.float_power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) +// Returns +// ------- +// res : ndarray +// Output array, containing the indices of the elements of ``a.ravel()`` +// that are non-zero. // -// The effect of broadcasting. +// See Also +// -------- +// nonzero : Return the indices of the non-zero elements of the input array. +// ravel : Return a 1-D array containing the elements of the input array. // -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.float_power(x1, x2) -// array([[ 0., 1., 8., 27., 16., 5.], -// [ 0., 1., 8., 27., 16., 5.]]) +// Examples +// -------- +// >>> x = np.arange(-2, 3) +// >>> x +// array([-2, -1, 0, 1, 2]) +// >>> np.flatnonzero(x) +// array([0, 1, 3, 4]) // -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). +// Use the indices of the non-zero elements as an index array to extract +// these elements: // -// >>> x3 = np.array([-1, -4]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.float_power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) +// >>> x.ravel()[np.flatnonzero(x)] +// array([-2, -1, 1, 2]) // -// To get complex results, give the argument ``dtype=complex``. // -// >>> np.float_power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) // -//go:linkname FloatPower py.float_power -func FloatPower(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Flatnonzero py.flatnonzero +func Flatnonzero(a *py.Object) *py.Object // -// Returns the element-wise remainder of division. +// Return the product of array elements over a given axis. // -// This is the NumPy implementation of the C library function fmod, the -// remainder has the same sign as the dividend `x1`. It is equivalent to -// the Matlab(TM) ``rem`` function and should not be confused with the -// Python modulus operator ``x1 % x2``. +// Parameters +// ---------- +// a : array_like +// Input data. +// axis : None or int or tuple of ints, optional +// Axis or axes along which a product is performed. The default, +// axis=None, will calculate the product of all the elements in the +// input array. If axis is negative it counts from the last to the +// first axis. // -// Parameters -// ---------- -// x1 : array_like -// Dividend. -// x2 : array_like -// Divisor. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// .. versionadded:: 1.7.0 // -// Returns -// ------- -// y : array_like -// The remainder of the division of `x1` by `x2`. -// This is a scalar if both `x1` and `x2` are scalars. +// If axis is a tuple of ints, a product is performed on all of the +// axes specified in the tuple instead of a single axis or all the +// axes as before. +// dtype : dtype, optional +// The type of the returned array, as well as of the accumulator in +// which the elements are multiplied. The dtype of `a` is used by +// default unless `a` has an integer dtype of less precision than the +// default platform integer. In that case, if `a` is signed then the +// platform integer is used while if `a` is unsigned then an unsigned +// integer of the same precision as the platform integer is used. +// out : ndarray, optional +// Alternative output array in which to place the result. It must have +// the same shape as the expected output, but the type of the output +// values will be cast if necessary. +// 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 input array. // -// See Also -// -------- -// remainder : Equivalent to the Python ``%`` operator. -// divide +// If the default value is passed, then `keepdims` will not be +// passed through to the `prod` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. +// initial : scalar, optional +// The starting value for this product. See `~numpy.ufunc.reduce` for details. // -// Notes -// ----- -// The result of the modulo operation for negative dividend and divisors -// is bound by conventions. For `fmod`, the sign of result is the sign of -// the dividend, while for `remainder` the sign of the result is the sign -// of the divisor. The `fmod` function is equivalent to the Matlab(TM) -// ``rem`` function. +// .. versionadded:: 1.15.0 // -// Examples -// -------- -// >>> import numpy as np -// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) -// array([-1, 0, -1, 1, 0, 1]) -// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) -// array([1, 0, 1, 1, 0, 1]) +// where : array_like of bool, optional +// Elements to include in the product. See `~numpy.ufunc.reduce` for details. // -// >>> np.fmod([5, 3], [2, 2.]) -// array([ 1., 1.]) -// >>> a = np.arange(-3, 3).reshape(3, 2) -// >>> a -// array([[-3, -2], -// [-1, 0], -// [ 1, 2]]) -// >>> np.fmod(a, [2,2]) -// array([[-1, 0], -// [-1, 0], -// [ 1, 0]]) +// .. versionadded:: 1.17.0 // -//go:linkname Fmod py.fmod -func Fmod(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// Returns +// ------- +// product_along_axis : ndarray, see `dtype` parameter above. +// An array shaped as `a` but with the specified axis removed. +// Returns a reference to `out` if specified. // -// Stack arrays in sequence horizontally (column wise). +// See Also +// -------- +// ndarray.prod : equivalent method +// :ref:`ufuncs-output-type` // -// This is equivalent to concatenation along the second axis, except for 1-D -// arrays where it concatenates along the first axis. Rebuilds arrays divided -// by `hsplit`. +// Notes +// ----- +// Arithmetic is modular when using integer types, and no error is +// raised on overflow. That means that, on a 32-bit platform: // -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// and r/g/b channels (third axis). The functions `concatenate`, `stack` and -// `block` provide more general stacking and concatenation operations. +// >>> x = np.array([536870910, 536870910, 536870910, 536870910]) +// >>> np.prod(x) +// 16 # may vary // -// Parameters -// ---------- -// tup : sequence of ndarrays -// The arrays must have the same shape along all but the second axis, -// except 1-D arrays which can be any length. In the case of a single -// array_like input, it will be treated as a sequence of arrays; i.e., -// each element along the zeroth axis is treated as a separate array. +// The product of an empty array is the neutral element 1: // -// dtype : str or dtype -// If provided, the destination array will have this dtype. Cannot be -// provided together with `out`. +// >>> np.prod([]) +// 1.0 // -// .. versionadded:: 1.24 +// Examples +// -------- +// By default, calculate the product of all elements: // -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Defaults to 'same_kind'. +// >>> np.prod([1.,2.]) +// 2.0 // -// .. versionadded:: 1.24 +// Even when the input array is two-dimensional: // -// Returns -// ------- -// stacked : ndarray -// The array formed by stacking the given arrays. +// >>> a = np.array([[1., 2.], [3., 4.]]) +// >>> np.prod(a) +// 24.0 // -// See Also -// -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// vstack : Stack arrays in sequence vertically (row wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// hsplit : Split an array into multiple sub-arrays -// horizontally (column-wise). -// unstack : Split an array into a tuple of sub-arrays along an axis. +// But we can also specify the axis over which to multiply: // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array((1,2,3)) -// >>> b = np.array((4,5,6)) -// >>> np.hstack((a,b)) -// array([1, 2, 3, 4, 5, 6]) -// >>> a = np.array([[1],[2],[3]]) -// >>> b = np.array([[4],[5],[6]]) -// >>> np.hstack((a,b)) -// array([[1, 4], -// [2, 5], -// [3, 6]]) +// >>> 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]) +// 3.0 // -//go:linkname Hstack py.hstack -func Hstack(tup *py.Object) *py.Object -// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// If the type of `x` is unsigned, then the output type is +// the unsigned platform integer: // -// Test element-wise for NaN and return result as a boolean array. +// >>> x = np.array([1, 2, 3], dtype=np.uint8) +// >>> np.prod(x).dtype == np.uint +// True // -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// If `x` is of a signed integer type, then the output type +// is the default platform integer: // -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaN, false otherwise. -// This is a scalar if `x` is a scalar. +// >>> x = np.array([1, 2, 3], dtype=np.int8) +// >>> np.prod(x).dtype == int +// True // -// See Also -// -------- -// isinf, isneginf, isposinf, isfinite, isnat +// You can also start the product with a value other than one: // -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. +// >>> np.prod([1, 2], initial=5) +// 10 // -// Examples -// -------- -// >>> import numpy as np -// >>> np.isnan(np.nan) -// True -// >>> np.isnan(np.inf) -// False -// >>> np.isnan([np.log(-1.),1.,np.log(0)]) -// array([ True, False, False]) // -//go:linkname Isnan py.isnan -func Isnan(x *py.Object, out *py.Object) *py.Object +//go:linkname Prod py.prod +func Prod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object // -// Return a new array with sub-arrays along an axis deleted. For a one -// dimensional array, this returns those entries not returned by -// `arr[obj]`. +// Check whether some values are true. // -// Parameters -// ---------- -// arr : array_like -// Input array. -// obj : slice, int, array-like of ints or bools -// Indicate indices of sub-arrays to remove along the specified axis. +// Refer to `any` for full documentation. // -// .. versionchanged:: 1.19.0 -// Boolean indices are now treated as a mask of elements to remove, -// rather than being cast to the integers 0 and 1. +// .. deprecated:: 1.25.0 +// ``sometrue`` is deprecated as of NumPy 1.25.0, and will be +// removed in NumPy 2.0. Please use `any` instead. // -// axis : int, optional -// The axis along which to delete the subarray defined by `obj`. -// If `axis` is None, `obj` is applied to the flattened array. +// See Also +// -------- +// any : equivalent function; see for details. +// +// +//go:linkname Sometrue py.sometrue +func Sometrue(__llgo_va_list ...interface{}) *py.Object +// +// Return the Bartlett window. +// +// The Bartlett window is very similar to a triangular window, except +// that the end points are at zero. It is often used in signal +// processing for tapering a signal, without generating too much +// ripple in the frequency domain. +// +// Parameters +// ---------- +// M : int +// Number of points in the output window. If zero or less, an +// empty array is returned. // // Returns // ------- -// out : ndarray -// A copy of `arr` with the elements specified by `obj` removed. Note -// that `delete` does not occur in-place. If `axis` is None, `out` is -// a flattened array. +// out : array +// The triangular window, with the maximum value normalized to one +// (the value one appears only if the number of samples is odd), with +// the first and last samples equal to zero. // // See Also // -------- -// insert : Insert elements into an array. -// append : Append elements at the end of an array. +// blackman, hamming, hanning, kaiser // // Notes // ----- -// Often it is preferable to use a boolean mask. For example: +// The Bartlett window is defined as // -// >>> arr = np.arange(12) + 1 -// >>> mask = np.ones(len(arr), dtype=bool) -// >>> mask[[0,2,4]] = False -// >>> result = arr[mask,...] +// .. math:: w(n) = \frac{2}{M-1} \left( +// \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right| +// \right) // -// Is equivalent to ``np.delete(arr, [0,2,4], axis=0)``, but allows further -// use of `mask`. +// 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 +// ---------- +// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", +// Biometrika 37, 1-16, 1950. +// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", +// The University of Alberta Press, 1975, pp. 109-110. +// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal +// Processing", Prentice-Hall, 1999, pp. 468-471. +// .. [4] Wikipedia, "Window function", +// https://en.wikipedia.org/wiki/Window_function +// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, +// "Numerical Recipes", Cambridge University Press, 1986, page 429. // // Examples // -------- -// >>> import numpy as np -// >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) -// >>> arr -// array([[ 1, 2, 3, 4], -// [ 5, 6, 7, 8], -// [ 9, 10, 11, 12]]) -// >>> np.delete(arr, 1, 0) -// array([[ 1, 2, 3, 4], -// [ 9, 10, 11, 12]]) +// >>> import matplotlib.pyplot as plt +// >>> np.bartlett(12) +// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary +// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, +// 0.18181818, 0. ]) // -// >>> np.delete(arr, np.s_[::2], 1) -// array([[ 2, 4], -// [ 6, 8], -// [10, 12]]) -// >>> np.delete(arr, [1,3,5], None) -// array([ 1, 3, 5, 7, 8, 9, 10, 11, 12]) +// Plot the window and its frequency response (requires SciPy and matplotlib): // +// >>> from numpy.fft import fft, fftshift +// >>> window = np.bartlett(51) +// >>> plt.plot(window) +// [] +// >>> plt.title("Bartlett window") +// Text(0.5, 1.0, 'Bartlett window') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("Sample") +// Text(0.5, 0, 'Sample') +// >>> plt.show() // +// >>> plt.figure() +//
+// >>> A = fft(window, 2048) / 25.5 +// >>> mag = np.abs(fftshift(A)) +// >>> freq = np.linspace(-0.5, 0.5, len(A)) +// >>> with np.errstate(divide='ignore', invalid='ignore'): +// ... response = 20 * np.log10(mag) +// ... +// >>> response = np.clip(response, -100, 100) +// >>> plt.plot(freq, response) +// [] +// >>> plt.title("Frequency response of Bartlett window") +// Text(0.5, 1.0, 'Frequency response of Bartlett window') +// >>> plt.ylabel("Magnitude [dB]") +// Text(0, 0.5, 'Magnitude [dB]') +// >>> plt.xlabel("Normalized frequency [cycles per sample]") +// Text(0.5, 0, 'Normalized frequency [cycles per sample]') +// >>> _ = plt.axis('tight') +// >>> plt.show() // -//go:linkname Delete py.delete -func Delete(arr *py.Object, obj *py.Object, axis *py.Object) *py.Object // -// Apply a function to 1-D slices along the given axis. // -// Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays -// and `a` is a 1-D slice of `arr` along `axis`. +//go:linkname Bartlett py.bartlett +func Bartlett(M *py.Object) *py.Object // -// This is equivalent to (but faster than) the following use of `ndindex` and -// `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices:: +// Add documentation to an existing object, typically one defined in C // -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// f = func1d(arr[ii + s_[:,] + kk]) -// Nj = f.shape -// for jj in ndindex(Nj): -// out[ii + jj + kk] = f[jj] +// The purpose is to allow easier editing of the docstrings without requiring +// a re-compile. This exists primarily for internal use within numpy itself. // -// Equivalently, eliminating the inner loop, this can be expressed as:: +// Parameters +// ---------- +// place : str +// The absolute name of the module to import from +// obj : str +// The name of the object to add documentation to, typically a class or +// function name +// doc : {str, Tuple[str, str], List[Tuple[str, str]]} +// If a string, the documentation to apply to `obj` // -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk]) +// If a tuple, then the first element is interpreted as an attribute of +// `obj` and the second as the docstring to apply - ``(method, docstring)`` +// +// If a list, then each element of the list should be a tuple of length +// two - ``[(method1, docstring1), (method2, docstring2), ...]`` +// warn_on_python : bool +// If True, the default, emit `UserWarning` if this is used to attach +// documentation to a pure-python object. +// +// Notes +// ----- +// This routine never raises an error if the docstring can't be written, but +// will raise an error if the object being documented does not exist. +// +// This routine cannot modify read-only docstrings, as appear +// in new-style classes or built-in functions. Because this +// routine never raises an error the caller must check manually +// that the docstrings were changed. +// +// Since this function grabs the ``char *`` from a c-level str object and puts +// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of +// C-API best-practices, by: +// +// - modifying a `PyTypeObject` after calling `PyType_Ready` +// - calling `Py_INCREF` on the str and losing the reference, so the str +// will never be released +// +// If possible it should be avoided. +// +// +//go:linkname AddNewdoc py.add_newdoc +func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object +// +// Show libraries and system information on which NumPy was built +// and is being used // // Parameters // ---------- -// func1d : function (M,) -> (Nj...) -// This function should accept 1-D arrays. It is applied to 1-D -// slices of `arr` along the specified axis. -// axis : integer -// Axis along which `arr` is sliced. -// arr : ndarray (Ni..., M, Nk...) -// Input array. -// args : any -// Additional arguments to `func1d`. -// kwargs : any -// Additional named arguments to `func1d`. +// mode : {`'stdout'`, `'dicts'`}, optional. +// Indicates how to display the config information. +// `'stdout'` prints to console, `'dicts'` returns a dictionary +// of the configuration. // // Returns // ------- -// out : ndarray (Ni..., Nj..., Nk...) -// The output array. The shape of `out` is identical to the shape of -// `arr`, except along the `axis` dimension. This axis is removed, and -// replaced with new dimensions equal to the shape of the return value -// of `func1d`. So if `func1d` returns a scalar `out` will have one -// fewer dimensions than `arr`. +// out : {`dict`, `None`} +// If mode is `'dicts'`, a dict is returned, else None // // See Also // -------- -// apply_over_axes : Apply a function repeatedly over multiple axes. -// -// Examples -// -------- -// >>> import numpy as np -// >>> def my_func(a): -// ... """Average first and last element of a 1-D array""" -// ... return (a[0] + a[-1]) * 0.5 -// >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) -// >>> np.apply_along_axis(my_func, 0, b) -// array([4., 5., 6.]) -// >>> np.apply_along_axis(my_func, 1, b) -// array([2., 5., 8.]) +// get_include : Returns the directory containing NumPy C +// header files. // -// For a function that returns a 1D array, the number of dimensions in -// `outarr` is the same as `arr`. +// Notes +// ----- +// 1. The `'stdout'` mode will give more readable +// output if ``pyyaml`` is installed // -// >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]]) -// >>> np.apply_along_axis(sorted, 1, b) -// array([[1, 7, 8], -// [3, 4, 9], -// [2, 5, 6]]) // -// For a function that returns a higher dimensional array, those dimensions -// are inserted in place of the `axis` dimension. // -// >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) -// >>> np.apply_along_axis(np.diag, -1, b) -// array([[[1, 0, 0], -// [0, 2, 0], -// [0, 0, 3]], -// [[4, 0, 0], -// [0, 5, 0], -// [0, 0, 6]], -// [[7, 0, 0], -// [0, 8, 0], -// [0, 0, 9]]]) +//go:linkname ShowConfig py.show_config +func ShowConfig(mode *py.Object) *py.Object // +// result_type(*arrays_and_dtypes) // -//go:linkname ApplyAlongAxis py.apply_along_axis -func ApplyAlongAxis(func1d *py.Object, axis *py.Object, arr *py.Object, __llgo_va_list ...interface{}) *py.Object +// Returns the type that results from applying the NumPy +// type promotion rules to the arguments. // -// Format a floating-point scalar as a decimal string in scientific notation. +// Type promotion in NumPy works similarly to the rules in languages +// like C++, with some slight differences. When both scalars and +// arrays are used, the array's type takes precedence and the actual value +// of the scalar is taken into account. // -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// For example, calculating 3*a, where a is an array of 32-bit floats, +// intuitively should result in a 32-bit float output. If the 3 is a +// 32-bit integer, the NumPy rules indicate it can't convert losslessly +// into a 32-bit float, so a 64-bit float should be the result type. +// By examining the value of the constant, '3', we see that it fits in +// an 8-bit integer, which can be cast losslessly into the 32-bit float. // // Parameters // ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed. If `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// exp_digits : non-negative integer, optional -// Pad the exponent with zeros until it contains at least this -// many digits. If omitted, the exponent will be at least 2 digits. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. This only has an effect for -// `unique=True`. In that case more digits than necessary to uniquely -// identify the value may be printed and rounded unbiased. -// -// .. versionadded:: 1.21.0 +// arrays_and_dtypes : list of arrays and dtypes +// The operands of some operation whose result type is needed. // // Returns // ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_positional +// out : dtype +// The result type. // -// Examples +// See also // -------- -// >>> import numpy as np -// >>> np.format_float_scientific(np.float32(np.pi)) -// '3.1415927e+00' -// >>> s = np.float32(1.23e24) -// >>> np.format_float_scientific(s, unique=False, precision=15) -// '1.230000071797338e+24' -// >>> np.format_float_scientific(s, exp_digits=4) -// '1.23e+0024' -// +// dtype, promote_types, min_scalar_type, can_cast // -//go:linkname FormatFloatScientific py.format_float_scientific -func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object +// Notes +// ----- +// .. versionadded:: 1.6.0 // -// Return an array of ones with the same shape and type as a given array. +// The specific algorithm used is as follows. // -// Parameters -// ---------- -// a : array_like -// The shape and data-type of `a` define these same attributes of -// the returned array. -// dtype : data-type, optional -// Overrides the data type of the result. -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `a`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// device : str, optional -// The device on which to place the created array. Default: None. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. +// Categories are determined by first checking which of boolean, +// integer (int/uint), or floating point (float/complex) the maximum +// kind of all the arrays and the scalars are. // -// .. versionadded:: 2.0.0 +// If there are only scalars or the maximum category of the scalars +// is higher than the maximum category of the arrays, +// the data types are combined with :func:`promote_types` +// to produce the return value. // -// Returns -// ------- -// out : ndarray -// Array of ones with the same shape and type as `a`. +// Otherwise, `min_scalar_type` is called on each scalar, and +// the resulting data types are all combined with :func:`promote_types` +// to produce the return value. // -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// ones : Return a new array setting values to one. +// The set of int values is not a subset of the uint values for types +// with the same number of bits, something not reflected in +// :func:`min_scalar_type`, but handled as a special case in `result_type`. // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(6) -// >>> x = x.reshape((2, 3)) -// >>> x -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.ones_like(x) -// array([[1, 1, 1], -// [1, 1, 1]]) +// >>> np.result_type(3, np.arange(7, dtype='i1')) +// dtype('int8') // -// >>> y = np.arange(3, dtype=float) -// >>> y -// array([0., 1., 2.]) -// >>> np.ones_like(y) -// array([1., 1., 1.]) +// >>> np.result_type('i4', 'c8') +// dtype('complex128') // +// >>> np.result_type(3.0, -2) +// dtype('float64') // // -//go:linkname OnesLike py.ones_like -func OnesLike(a *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object // -// Return a new array with the specified shape. +//go:linkname ResultType py.result_type +func ResultType(__llgo_va_list ...interface{}) *py.Object +// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// If the new array is larger than the original array, then the new -// array is filled with repeated copies of `a`. Note that this behavior -// is different from a.resize(new_shape) which fills with zeros instead -// of repeated copies of `a`. +// Return the truth value of (x1 <= x2) element-wise. // -// Parameters -// ---------- -// a : array_like -// Array to be resized. +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// new_shape : int or tuple of int -// Shape of resized array. +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise comparison of `x1` and `x2`. +// Typically of type bool, unless ``dtype=object`` is passed. +// This is a scalar if both `x1` and `x2` are scalars. // -// Returns -// ------- -// reshaped_array : ndarray -// The new array is formed from the data in the old array, repeated -// if necessary to fill out the required number of elements. The -// data are repeated iterating over the array in C-order. -// -// See Also -// -------- -// numpy.reshape : Reshape an array without changing the total size. -// numpy.pad : Enlarge and pad an array. -// numpy.repeat : Repeat elements of an array. -// ndarray.resize : resize an array in-place. -// -// Notes -// ----- -// When the total size of the array does not change `~numpy.reshape` should -// be used. In most other cases either indexing (to reduce the size) -// or padding (to increase the size) may be a more appropriate solution. +// See Also +// -------- +// greater, less, greater_equal, equal, not_equal // -// Warning: This functionality does **not** consider axes separately, -// i.e. it does not apply interpolation/extrapolation. -// It fills the return array with the required number of elements, iterating -// over `a` in C-order, disregarding axes (and cycling back from the start if -// the new shape is larger). This functionality is therefore not suitable to -// resize images, or data where each axis represents a separate and distinct -// entity. +// Examples +// -------- +// >>> np.less_equal([4, 2, 1], [2, 2, 2]) +// array([False, True, True]) // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[0,1],[2,3]]) -// >>> np.resize(a,(2,3)) -// array([[0, 1, 2], -// [3, 0, 1]]) -// >>> np.resize(a,(1,4)) -// array([[0, 1, 2, 3]]) -// >>> np.resize(a,(2,4)) -// array([[0, 1, 2, 3], -// [0, 1, 2, 3]]) +// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on +// ndarrays. // +// >>> a = np.array([4, 2, 1]) +// >>> b = np.array([2, 2, 2]) +// >>> a <= b +// array([False, True, True]) // +//go:linkname LessEqual py.less_equal +func LessEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname Resize py.resize -func Resize(a *py.Object, newShape *py.Object) *py.Object +// Divide arguments element-wise. // -// The differences between consecutive elements of an array. +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// Parameters -// ---------- -// ary : array_like -// If necessary, will be flattened before the differences are taken. -// to_end : array_like, optional -// Number(s) to append at the end of the returned differences. -// to_begin : array_like, optional -// Number(s) to prepend at the beginning of the returned differences. +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. // -// Returns -// ------- -// ediff1d : ndarray -// The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``. +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. // -// See Also -// -------- -// diff, gradient +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. // -// Notes -// ----- -// When applied to masked arrays, this function drops the mask information -// if the `to_begin` and/or `to_end` parameters are used. +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([1, 2, 4, 7, 0]) -// >>> np.ediff1d(x) -// array([ 1, 2, 3, -7]) +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> 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. ]]) // -// >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) -// array([-99, 1, 2, ..., -7, 88, 99]) +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. // -// The returned array is always 1D. +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) // -// >>> y = [[1, 2, 4], [1, 6, 24]] -// >>> np.ediff1d(y) -// array([ 1, 2, -3, 5, 18]) +//go:linkname TrueDivide py.true_divide +func TrueDivide(__llgo_va_list ...interface{}) *py.Object // +// einsum(subscripts, *operands, out=None, dtype=None, order='K', +// casting='safe', optimize=False) // +// Evaluates the Einstein summation convention on the operands. // -//go:linkname Ediff1d py.ediff1d -func Ediff1d(ary *py.Object, toEnd *py.Object, toBegin *py.Object) *py.Object +// Using the Einstein summation convention, many common multi-dimensional, +// linear algebraic array operations can be represented in a simple fashion. +// In *implicit* mode `einsum` computes these values. // -// Return the Hamming window. +// In *explicit* mode, `einsum` provides further flexibility to compute +// other array operations that might not be considered classical Einstein +// summation operations, by disabling, or forcing summation over specified +// subscript labels. // -// The Hamming window is a taper formed by using a weighted cosine. +// See the notes and examples for clarification. // // Parameters // ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. +// subscripts : str +// Specifies the subscripts for summation as comma separated list of +// subscript labels. An implicit (classical Einstein summation) +// calculation is performed unless the explicit indicator '->' is +// included as well as subscript labels of the precise output form. +// operands : list of array_like +// These are the arrays for the operation. +// out : ndarray, optional +// If provided, the calculation is done into this array. +// dtype : {data-type, None}, optional +// If provided, forces the calculation to use the data type specified. +// Note that you may have to also give a more liberal `casting` +// parameter to allow the conversions. Default is None. +// order : {'C', 'F', 'A', 'K'}, optional +// Controls the memory layout of the output. 'C' means it should +// be C contiguous. 'F' means it should be Fortran contiguous, +// 'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise. +// 'K' means it should be as close to the layout as the inputs as +// is possible, including arbitrarily permuted axes. +// Default is 'K'. +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional +// Controls what kind of data casting may occur. Setting this to +// 'unsafe' is not recommended, as it can adversely affect accumulations. +// +// * 'no' means the data types should not be cast at all. +// * 'equiv' means only byte-order changes are allowed. +// * 'safe' means only casts which can preserve values are allowed. +// * 'same_kind' means only safe casts or casts within a kind, +// like float64 to float32, are allowed. +// * 'unsafe' means any data conversions may be done. +// +// Default is 'safe'. +// optimize : {False, True, 'greedy', 'optimal'}, optional +// Controls if intermediate optimization should occur. No optimization +// will occur if False and True will default to the 'greedy' algorithm. +// Also accepts an explicit contraction list from the ``np.einsum_path`` +// function. See ``np.einsum_path`` for more details. Defaults to False. // // Returns // ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). +// output : ndarray +// The calculation based on the Einstein summation convention. // // See Also // -------- -// bartlett, blackman, hanning, kaiser +// einsum_path, dot, inner, outer, tensordot, linalg.multi_dot +// einops : +// similar verbose interface is provided by +// `einops `_ package to cover +// additional operations: transpose, reshape/flatten, repeat/tile, +// squeeze/unsqueeze and reductions. +// opt_einsum : +// `opt_einsum `_ +// optimizes contraction order for einsum-like expressions +// in backend-agnostic manner. // // Notes // ----- -// The Hamming window is defined as -// -// .. 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 -// and is described in Blackman and Tukey. It was recommended for -// smoothing the truncated autocovariance function in the time domain. -// Most references to the Hamming window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 109-110. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.hamming(12) -// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary -// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, -// 0.15302337, 0.08 ]) +// .. versionadded:: 1.6.0 // -// Plot the window and the frequency response. +// The Einstein summation convention can be used to compute +// many multi-dimensional, linear algebraic array operations. `einsum` +// provides a succinct way of representing these. // -// .. plot:: -// :include-source: +// A non-exhaustive list of these operations, +// which can be computed by `einsum`, is shown below along with examples: // -// import matplotlib.pyplot as plt -// from numpy.fft import fft, fftshift -// window = np.hamming(51) -// plt.plot(window) -// plt.title("Hamming window") -// plt.ylabel("Amplitude") -// plt.xlabel("Sample") -// plt.show() +// * Trace of an array, :py:func:`numpy.trace`. +// * Return a diagonal, :py:func:`numpy.diag`. +// * Array axis summations, :py:func:`numpy.sum`. +// * Transpositions and permutations, :py:func:`numpy.transpose`. +// * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`. +// * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`. +// * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`. +// * Tensor contractions, :py:func:`numpy.tensordot`. +// * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`. // -// plt.figure() -// A = fft(window, 2048) / 25.5 -// mag = np.abs(fftshift(A)) -// freq = np.linspace(-0.5, 0.5, len(A)) -// response = 20 * np.log10(mag) -// response = np.clip(response, -100, 100) -// plt.plot(freq, response) -// plt.title("Frequency response of Hamming window") -// plt.ylabel("Magnitude [dB]") -// plt.xlabel("Normalized frequency [cycles per sample]") -// plt.axis('tight') -// plt.show() +// The subscripts string is a comma-separated list of subscript labels, +// where each label refers to a dimension of the corresponding operand. +// Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)`` +// is equivalent to :py:func:`np.inner(a,b) `. If a label +// appears only once, it is not summed, so ``np.einsum('i', a)`` produces a +// view of ``a`` with no changes. A further example ``np.einsum('ij,jk', a, b)`` +// describes traditional matrix multiplication and is equivalent to +// :py:func:`np.matmul(a,b) `. Repeated subscript labels in one +// operand take the diagonal. For example, ``np.einsum('ii', a)`` is equivalent +// to :py:func:`np.trace(a) `. // +// In *implicit mode*, the chosen subscripts are important +// since the axes of the output are reordered alphabetically. This +// means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while +// ``np.einsum('ji', a)`` takes its transpose. Additionally, +// ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while, +// ``np.einsum('ij,jh', a, b)`` returns the transpose of the +// multiplication since subscript 'h' precedes subscript 'i'. // +// In *explicit mode* the output can be directly controlled by +// specifying output subscript labels. This requires the +// identifier '->' as well as the list of output subscript labels. +// This feature increases the flexibility of the function since +// summing can be disabled or forced when required. The call +// ``np.einsum('i->', a)`` is like :py:func:`np.sum(a, axis=-1) `, +// and ``np.einsum('ii->i', a)`` is like :py:func:`np.diag(a) `. +// The difference is that `einsum` does not allow broadcasting by default. +// Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the +// order of the output subscript labels and therefore returns matrix +// multiplication, unlike the example above in implicit mode. // -//go:linkname Hamming py.hamming -func Hamming(M *py.Object) *py.Object -// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The lowest common multiple of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// gcd : The greatest common divisor +// To enable and control broadcasting, use an ellipsis. Default +// NumPy-style broadcasting is done by adding an ellipsis +// to the left of each term, like ``np.einsum('...ii->...i', a)``. +// To take the trace along the first and last axes, +// you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix +// product with the left-most indices instead of rightmost, one can do +// ``np.einsum('ij...,jk...->ik...', a, b)``. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.lcm(12, 20) -// 60 -// >>> np.lcm.reduce([3, 12, 20]) -// 60 -// >>> np.lcm.reduce([40, 12, 20]) -// 120 -// >>> np.lcm(np.arange(6), 20) -// array([ 0, 20, 20, 60, 20, 20]) +// When there is only one operand, no axes are summed, and no output +// parameter is provided, a view into the operand is returned instead +// of a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)`` +// produces a view (changed in version 1.10.0). // -//go:linkname Lcm py.lcm -func Lcm(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -//go:linkname Matvec py.matvec -func Matvec(__llgo_va_list ...interface{}) *py.Object +// `einsum` also provides an alternative way to provide the subscripts +// and operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. +// If the output shape is not provided in this format `einsum` will be +// calculated in implicit mode, otherwise it will be performed explicitly. +// The examples below have corresponding `einsum` calls with the two +// parameter methods. // -// putmask(a, mask, values) +// .. versionadded:: 1.10.0 // -// Changes elements of an array based on conditional and input values. +// Views returned from einsum are now writeable whenever the input array +// is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now +// have the same effect as :py:func:`np.swapaxes(a, 0, 2) ` +// and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal +// of a 2D array. // -// Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``. +// .. versionadded:: 1.12.0 // -// If `values` is not the same size as `a` and `mask` then it will repeat. -// This gives behavior different from ``a[mask] = values``. +// Added the ``optimize`` argument which will optimize the contraction order +// of an einsum expression. For a contraction with three or more operands this +// can greatly increase the computational efficiency at the cost of a larger +// memory footprint during computation. // -// Parameters -// ---------- -// a : ndarray -// Target array. -// mask : array_like -// Boolean mask array. It has to be the same shape as `a`. -// values : array_like -// Values to put into `a` where `mask` is True. If `values` is smaller -// than `a` it will be repeated. +// Typically a 'greedy' algorithm is applied which empirical tests have shown +// returns the optimal path in the majority of cases. In some cases 'optimal' +// will return the superlative path through a more expensive, exhaustive search. +// For iterative calculations it may be advisable to calculate the optimal path +// once and reuse that path by supplying it as an argument. An example is given +// below. // -// See Also -// -------- -// place, put, take, copyto +// See :py:func:`numpy.einsum_path` for more details. // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(6).reshape(2, 3) -// >>> np.putmask(x, x>2, x**2) -// >>> x -// array([[ 0, 1, 2], -// [ 9, 16, 25]]) -// -// If `values` is smaller than `a` it is repeated: -// -// >>> x = np.arange(5) -// >>> np.putmask(x, x>1, [-33, -44]) -// >>> x -// array([ 0, 1, -33, -44, -33]) +// >>> a = np.arange(25).reshape(5,5) +// >>> b = np.arange(5) +// >>> c = np.arange(6).reshape(2,3) // +// Trace of a matrix: // +// >>> np.einsum('ii', a) +// 60 +// >>> np.einsum(a, [0,0]) +// 60 +// >>> np.trace(a) +// 60 // -//go:linkname Putmask py.putmask -func Putmask(a *py.Object, mask *py.Object, values *py.Object) *py.Object +// Extract the diagonal (requires explicit form): // -// Sort a complex array using the real part first, then the imaginary part. +// >>> np.einsum('ii->i', a) +// array([ 0, 6, 12, 18, 24]) +// >>> np.einsum(a, [0,0], [0]) +// array([ 0, 6, 12, 18, 24]) +// >>> np.diag(a) +// array([ 0, 6, 12, 18, 24]) // -// Parameters -// ---------- -// a : array_like -// Input array +// Sum over an axis (requires explicit form): // -// Returns -// ------- -// out : complex ndarray -// Always returns a sorted complex array. +// >>> np.einsum('ij->i', a) +// array([ 10, 35, 60, 85, 110]) +// >>> np.einsum(a, [0,1], [0]) +// array([ 10, 35, 60, 85, 110]) +// >>> np.sum(a, axis=1) +// array([ 10, 35, 60, 85, 110]) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.sort_complex([5, 3, 6, 2, 1]) -// array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j]) +// For higher dimensional arrays summing a single axis can be done with ellipsis: // -// >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]) -// array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j]) +// >>> np.einsum('...j->...', a) +// array([ 10, 35, 60, 85, 110]) +// >>> np.einsum(a, [Ellipsis,1], [Ellipsis]) +// array([ 10, 35, 60, 85, 110]) // +// Compute a matrix transpose, or reorder any number of axes: // +// >>> np.einsum('ji', c) +// array([[0, 3], +// [1, 4], +// [2, 5]]) +// >>> np.einsum('ij->ji', c) +// array([[0, 3], +// [1, 4], +// [2, 5]]) +// >>> np.einsum(c, [1,0]) +// array([[0, 3], +// [1, 4], +// [2, 5]]) +// >>> np.transpose(c) +// array([[0, 3], +// [1, 4], +// [2, 5]]) // -//go:linkname SortComplex py.sort_complex -func SortComplex(a *py.Object) *py.Object +// Vector inner products: // -// Difference (subtraction) of two polynomials. +// >>> np.einsum('i,i', b, b) +// 30 +// >>> np.einsum(b, [0], b, [0]) +// 30 +// >>> np.inner(b,b) +// 30 // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. +// Matrix vector multiplication: // -// Given two polynomials `a1` and `a2`, returns ``a1 - a2``. -// `a1` and `a2` can be either array_like sequences of the polynomials' -// coefficients (including coefficients equal to zero), or `poly1d` objects. +// >>> np.einsum('ij,j', a, b) +// array([ 30, 80, 130, 180, 230]) +// >>> np.einsum(a, [0,1], b, [1]) +// array([ 30, 80, 130, 180, 230]) +// >>> np.dot(a, b) +// array([ 30, 80, 130, 180, 230]) +// >>> np.einsum('...j,j', a, b) +// array([ 30, 80, 130, 180, 230]) // -// Parameters -// ---------- -// a1, a2 : array_like or poly1d -// Minuend and subtrahend polynomials, respectively. +// Broadcasting and scalar multiplication: // -// Returns -// ------- -// out : ndarray or poly1d -// Array or `poly1d` object of the difference polynomial's coefficients. +// >>> np.einsum('..., ...', 3, c) +// array([[ 0, 3, 6], +// [ 9, 12, 15]]) +// >>> np.einsum(',ij', 3, c) +// array([[ 0, 3, 6], +// [ 9, 12, 15]]) +// >>> np.einsum(3, [Ellipsis], c, [Ellipsis]) +// array([[ 0, 3, 6], +// [ 9, 12, 15]]) +// >>> np.multiply(3, c) +// array([[ 0, 3, 6], +// [ 9, 12, 15]]) // -// See Also -// -------- -// polyval, polydiv, polymul, polyadd +// Vector outer product: // -// Examples -// -------- +// >>> np.einsum('i,j', np.arange(2)+1, b) +// array([[0, 1, 2, 3, 4], +// [0, 2, 4, 6, 8]]) +// >>> np.einsum(np.arange(2)+1, [0], b, [1]) +// array([[0, 1, 2, 3, 4], +// [0, 2, 4, 6, 8]]) +// >>> np.outer(np.arange(2)+1, b) +// array([[0, 1, 2, 3, 4], +// [0, 2, 4, 6, 8]]) // -// .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2) +// Tensor contraction: // -// >>> import numpy as np +// >>> a = np.arange(60.).reshape(3,4,5) +// >>> b = np.arange(24.).reshape(4,3,2) +// >>> np.einsum('ijk,jil->kl', a, b) +// array([[4400., 4730.], +// [4532., 4874.], +// [4664., 5018.], +// [4796., 5162.], +// [4928., 5306.]]) +// >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) +// array([[4400., 4730.], +// [4532., 4874.], +// [4664., 5018.], +// [4796., 5162.], +// [4928., 5306.]]) +// >>> np.tensordot(a,b, axes=([1,0],[0,1])) +// array([[4400., 4730.], +// [4532., 4874.], +// [4664., 5018.], +// [4796., 5162.], +// [4928., 5306.]]) // -// >>> np.polysub([2, 10, -2], [3, 10, -4]) -// array([-1, 0, 2]) +// Writeable returned arrays (since version 1.10.0): // +// >>> a = np.zeros((3, 3)) +// >>> np.einsum('ii->i', a)[:] = 1 +// >>> a +// array([[1., 0., 0.], +// [0., 1., 0.], +// [0., 0., 1.]]) // +// Example of ellipsis use: // -//go:linkname Polysub py.polysub -func Polysub(a1 *py.Object, a2 *py.Object) *py.Object +// >>> a = np.arange(6).reshape((3,2)) +// >>> b = np.arange(12).reshape((4,3)) +// >>> np.einsum('ki,jk->ij', a, b) +// array([[10, 28, 46, 64], +// [13, 40, 67, 94]]) +// >>> np.einsum('ki,...k->i...', a, b) +// array([[10, 28, 46, 64], +// [13, 40, 67, 94]]) +// >>> np.einsum('k...,jk', a, b) +// array([[10, 28, 46, 64], +// [13, 40, 67, 94]]) +// +// Chained array operations. For more complicated contractions, speed ups +// might be achieved by repeatedly computing a 'greedy' path or pre-computing the +// 'optimal' path and repeatedly applying it, using an +// `einsum_path` insertion (since version 1.12.0). Performance improvements can be +// particularly significant with larger arrays: +// +// >>> a = np.ones(64).reshape(2,4,8) +// +// Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.) +// +// >>> for iteration in range(500): +// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a) +// +// Sub-optimal `einsum` (due to repeated path calculation time): ~330ms +// +// >>> for iteration in range(500): +// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal') +// +// Greedy `einsum` (faster optimal path approximation): ~160ms +// +// >>> for iteration in range(500): +// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy') +// +// Optimal `einsum` (best usage pattern in some use cases): ~110ms +// +// >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0] +// >>> for iteration in range(500): +// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path) +// +// +// +//go:linkname Einsum py.einsum +func Einsum(__llgo_va_list ...interface{}) *py.Object // // Stack 1-D arrays as columns into a 2-D array. // @@ -15348,7 +13791,6 @@ func Polysub(a1 *py.Object, a2 *py.Object) *py.Object // // Examples // -------- -// >>> import numpy as np // >>> a = np.array((1,2,3)) // >>> b = np.array((2,3,4)) // >>> np.column_stack((a,b)) @@ -15361,262 +13803,302 @@ func Polysub(a1 *py.Object, a2 *py.Object) *py.Object //go:linkname ColumnStack py.column_stack func ColumnStack(tup *py.Object) *py.Object // -// Return the imaginary part of the complex argument. +// Load data from a text file, with missing values handled as specified. +// +// Each line past the first `skip_header` lines is split at the `delimiter` +// character, and characters following the `comments` character are discarded. // // Parameters // ---------- -// val : array_like -// Input array. -// -// Returns -// ------- -// out : ndarray or scalar -// The imaginary component of the complex argument. If `val` is real, -// the type of `val` is used for the output. If `val` has complex -// elements, the returned type is float. -// -// See Also -// -------- -// real, angle, real_if_close -// -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([1+2j, 3+4j, 5+6j]) -// >>> a.imag -// array([2., 4., 6.]) -// >>> a.imag = np.array([8, 10, 12]) -// >>> a -// array([1. +8.j, 3.+10.j, 5.+12.j]) -// >>> np.imag(1 + 1j) -// 1.0 -// -// +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : dtype, optional +// Data type of the resulting array. +// If None, the dtypes will be determined by the contents of each +// column, individually. +// comments : str, optional +// The character used to indicate the start of a comment. +// All the characters occurring on a line after a comment are discarded. +// delimiter : str, int, or sequence, optional +// The string used to separate values. By default, any consecutive +// whitespaces act as delimiter. An integer or sequence of integers +// can also be provided as width(s) of each field. +// skiprows : int, optional +// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. +// skip_header : int, optional +// The number of lines to skip at the beginning of the file. +// skip_footer : int, optional +// The number of lines to skip at the end of the file. +// converters : variable, optional +// The set of functions that convert the data of a column to a value. +// The converters can also be used to provide a default value +// for missing data: ``converters = {3: lambda s: float(s or 0)}``. +// missing : variable, optional +// `missing` was removed in numpy 1.10. Please use `missing_values` +// instead. +// missing_values : variable, optional +// The set of strings corresponding to missing data. +// filling_values : variable, optional +// The set of values to be used as default when the data are missing. +// usecols : sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. +// names : {None, True, str, sequence}, optional +// If `names` is True, the field names are read from the first line after +// the first `skip_header` lines. This line can optionally be preceded +// by a comment delimiter. If `names` is a sequence or a single-string of +// comma-separated names, the names will be used to define the field names +// in a structured dtype. If `names` is None, the names of the dtype +// fields will be used, if any. +// excludelist : sequence, optional +// A list of names to exclude. This list is appended to the default list +// ['return','file','print']. Excluded names are appended with an +// underscore: for example, `file` would become `file_`. +// deletechars : str, optional +// A string combining invalid characters that must be deleted from the +// names. +// defaultfmt : str, optional +// A format used to define default field names, such as "f%i" or "f_%02i". +// autostrip : bool, optional +// Whether to automatically strip white spaces from the variables. +// replace_space : char, optional +// Character(s) used in replacement of white spaces in the variable +// names. By default, use a '_'. +// case_sensitive : {True, False, 'upper', 'lower'}, optional +// If True, field names are case sensitive. +// If False or 'upper', field names are converted to upper case. +// If 'lower', field names are converted to lower case. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = genfromtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// usemask : bool, optional +// If True, return a masked array. +// If False, return a regular array. +// loose : bool, optional +// If True, do not raise errors for invalid values. +// invalid_raise : bool, optional +// If True, an exception is raised if an inconsistency is detected in the +// number of columns. +// If False, a warning is emitted and the offending lines are skipped. +// max_rows : int, optional +// The maximum number of rows to read. Must not be used with skip_footer +// at the same time. If given, the value must be at least 1. Default is +// to read the entire file. // -//go:linkname Imag py.imag -func Imag(val *py.Object) *py.Object +// .. versionadded:: 1.10.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply when `fname` is +// a file object. The special value 'bytes' enables backward compatibility +// workarounds that ensure that you receive byte arrays when possible +// and passes latin1 encoded strings to converters. Override this value to +// receive unicode arrays and pass strings as input to converters. If set +// to None the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// ndmin : int, optional +// Same parameter as `loadtxt` // -// Test element-wise for negative infinity, return result as bool array. +// .. versionadded:: 1.23.0 +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. // -// Parameters -// ---------- -// x : array_like -// The input array. -// out : array_like, optional -// A location into which the result is stored. If provided, it must have a -// shape that the input broadcasts to. If not provided or None, a -// freshly-allocated boolean array is returned. +// .. versionadded:: 1.20.0 // // Returns // ------- // out : ndarray -// A boolean array with the same dimensions as the input. -// If second argument is not supplied then a numpy boolean array is -// returned with values True where the corresponding element of the -// input is negative infinity and values False where the element of -// the input is not negative infinity. -// -// If a second argument is supplied the result is stored there. If the -// type of that array is a numeric type the result is represented as -// zeros and ones, if the type is boolean then as False and True. The -// return value `out` is then a reference to that array. +// Data read from the text file. If `usemask` is True, this is a +// masked array. // // See Also // -------- -// isinf, isposinf, isnan, isfinite +// numpy.loadtxt : equivalent function when no data is missing. // // Notes // ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). +// * When spaces are used as delimiters, or when no delimiter has been given +// as input, there should not be any missing data between two fields. +// * When the variables are named (either by a flexible dtype or with `names`), +// there must not be any header in the file (else a ValueError +// exception is raised). +// * Individual values are not stripped of spaces by default. +// When using a custom converter, make sure the function does remove spaces. // -// Errors result if the second argument is also supplied when x is a scalar -// input, if first and second arguments have different shapes, or if the -// first argument has complex values. +// References +// ---------- +// .. [1] NumPy User Guide, section `I/O with NumPy +// `_. // // Examples // -------- +// >>> from io import StringIO // >>> import numpy as np -// >>> np.isneginf(-np.inf) -// True -// >>> np.isneginf(np.inf) -// False -// >>> np.isneginf([-np.inf, 0., np.inf]) -// array([ True, False, False]) // -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isneginf(x, y) -// array([1, 0, 0]) -// >>> y -// array([1, 0, 0]) +// Comma delimited file with mixed dtype // +// >>> s = StringIO(u"1,1.3,abcde") +// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), +// ... ('mystring','S5')], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only +// >>> data = np.genfromtxt(s, dtype=None, +// ... names = ['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '`. +// >>> _ = s.seek(0) +// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", +// ... names=['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('myint', '>> s = StringIO(u"11.3abcde") +// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], +// ... delimiter=[1,3,5]) +// >>> data +// array((1, 1.3, b'abcde'), +// dtype=[('intvar', '>> f = StringIO(''' +// ... text,# of chars +// ... hello world,11 +// ... numpy,5''') +// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') +// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], +// dtype=[('f0', 'S12'), ('f1', 'S12')]) // -// For real-valued input data types, `arccosh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// yields ``nan`` and sets the `invalid` floating point error flag. // -// For complex-valued input, `arccosh` is a complex analytical function that -// has a branch cut `[-inf, 1]` and is continuous from above on it. // -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arccosh +//go:linkname Genfromtxt py.genfromtxt +func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object // -// Examples -// -------- -// >>> import numpy as np -// >>> np.arccosh([np.e, 10.0]) -// array([ 1.65745445, 2.99322285]) -// >>> np.arccosh(1) -// 0.0 +// Take elements from an array along an axis. // -//go:linkname Acosh py.acosh -func Acosh(__llgo_va_list ...interface{}) *py.Object -// frompyfunc(func, /, nin, nout, *[, identity]) +// When axis is not None, this function does the same thing as "fancy" +// indexing (indexing arrays using arrays); however, it can be easier to use +// if you need elements along a given axis. A call such as +// ``np.take(arr, indices, axis=3)`` is equivalent to +// ``arr[:,:,:,indices,...]``. // -// Takes an arbitrary Python function and returns a NumPy ufunc. +// Explained without fancy indexing, this is equivalent to the following use +// of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of +// indices:: // -// Can be used, for example, to add broadcasting to a built-in Python -// function (see Examples section). +// Ni, Nk = a.shape[:axis], a.shape[axis+1:] +// Nj = indices.shape +// for ii in ndindex(Ni): +// for jj in ndindex(Nj): +// for kk in ndindex(Nk): +// out[ii + jj + kk] = a[ii + (indices[jj],) + kk] // // Parameters // ---------- -// func : Python function object -// An arbitrary Python function. -// nin : int -// The number of input arguments. -// nout : int -// The number of objects returned by `func`. -// identity : object, optional -// The value to use for the `~numpy.ufunc.identity` attribute of the resulting -// object. If specified, this is equivalent to setting the underlying -// C ``identity`` field to ``PyUFunc_IdentityValue``. -// If omitted, the identity is set to ``PyUFunc_None``. Note that this is -// _not_ equivalent to setting the identity to ``None``, which implies the -// operation is reorderable. +// a : array_like (Ni..., M, Nk...) +// The source array. +// indices : array_like (Nj...) +// The indices of the values to extract. +// +// .. versionadded:: 1.8.0 +// +// Also allow scalars for indices. +// axis : int, optional +// The axis over which to select values. By default, the flattened +// input array is used. +// out : ndarray, optional (Ni..., Nj..., Nk...) +// If provided, the result will be placed in this array. It should +// be of the appropriate shape and dtype. Note that `out` is always +// buffered if `mode='raise'`; use other modes for better performance. +// mode : {'raise', 'wrap', 'clip'}, optional +// Specifies how out-of-bounds indices will behave. +// +// * 'raise' -- raise an error (default) +// * 'wrap' -- wrap around +// * 'clip' -- clip to the range +// +// 'clip' mode means that all indices that are too large are replaced +// by the index that addresses the last element along that axis. Note +// that this disables indexing with negative numbers. // // Returns // ------- -// out : ufunc -// Returns a NumPy universal function (``ufunc``) object. +// out : ndarray (Ni..., Nj..., Nk...) +// The returned array has the same type as `a`. // // See Also // -------- -// vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy. +// compress : Take elements using a boolean mask +// ndarray.take : equivalent method +// take_along_axis : Take elements by matching the array and the index arrays // // Notes // ----- -// The returned ufunc always returns PyObject arrays. -// -// Examples -// -------- -// Use frompyfunc to add broadcasting to the Python function ``oct``: -// -// >>> import numpy as np -// >>> oct_array = np.frompyfunc(oct, 1, 1) -// >>> oct_array(np.array((10, 30, 100))) -// array(['0o12', '0o36', '0o144'], dtype=object) -// >>> np.array((oct(10), oct(30), oct(100))) # for comparison -// array(['0o12', '0o36', '0o144'], dtype='>> a = [4, 3, 5, 7, 6, 8] +// >>> indices = [0, 1, 4] +// >>> np.take(a, indices) +// array([4, 3, 6]) // -// Returns -// ------- -// out : ndarray -// The unique elements of an input array. +// In this example if `a` is an ndarray, "fancy" indexing can be used. // -// See Also -// -------- -// unique : Find the unique elements of an array. +// >>> a = np.array(a) +// >>> a[indices] +// array([4, 3, 6]) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.unique_values([1, 1, 2]) -// array([1, 2]) # may vary +// If `indices` is not one dimensional, the output also has these dimensions. // +// >>> np.take(a, [[0, 1], [2, 3]]) +// array([[4, 3], +// [5, 7]]) // // -//go:linkname UniqueValues py.unique_values -func UniqueValues(x *py.Object) *py.Object -// bitwise_count(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Take py.take +func Take(a *py.Object, indices *py.Object, axis *py.Object, out *py.Object, mode *py.Object) *py.Object +// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Computes the number of 1-bits in the absolute value of ``x``. -// Analogous to the builtin `int.bit_count` or ``popcount`` in C++. +// Base-2 logarithm of `x`. // // Parameters // ---------- -// x : array_like, unsigned int -// Input array. +// x : array_like +// Input values. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -15636,39 +14118,54 @@ func UniqueValues(x *py.Object) *py.Object // Returns // ------- // y : ndarray -// The corresponding number of 1-bits in the input. -// Returns uint8 for all integer types +// Base-2 logarithm of `x`. // This is a scalar if `x` is a scalar. // -// References -// ---------- -// .. [1] https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel +// See Also +// -------- +// log, log10, log1p, emath.log2 +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// 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]`. +// +// For real-valued input data types, `log2` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. // -// .. [2] Wikipedia, "Hamming weight", -// https://en.wikipedia.org/wiki/Hamming_weight +// For complex-valued input, `log2` is a complex analytical function that +// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` +// handles the floating-point negative zero as an infinitesimal negative +// number, conforming to the C99 standard. // -// .. [3] http://aggregate.ee.engr.uky.edu/MAGIC/#Population%20Count%20(Ones%20Count) +// 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 // -------- -// >>> import numpy as np -// >>> np.bitwise_count(1023) -// np.uint8(10) -// >>> a = np.array([2**i - 1 for i in range(16)]) -// >>> np.bitwise_count(a) -// array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], -// dtype=uint8) -// -//go:linkname BitwiseCount py.bitwise_count -func BitwiseCount(x *py.Object, out *py.Object) *py.Object -// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> x = np.array([0, 1, 2, 2**4]) +// >>> np.log2(x) +// array([-Inf, 0., 1., 4.]) // -// Calculate the exponential of all elements in the input array. +// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) +// >>> np.log2(xi) +// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) +// +//go:linkname Log2 py.log2 +func Log2(x *py.Object, out *py.Object) *py.Object +// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Convert angles from radians to degrees. // // Parameters // ---------- // x : array_like -// Input values. +// Angle in radians. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -15687,901 +14184,735 @@ func BitwiseCount(x *py.Object, out *py.Object) *py.Object // // Returns // ------- -// out : ndarray or scalar -// Output array, element-wise exponential of `x`. +// y : ndarray +// The corresponding angle in degrees. // This is a scalar if `x` is a scalar. // // See Also // -------- -// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. -// exp2 : Calculate ``2**x`` for all elements in the array. +// deg2rad : Convert angles from degrees to radians. +// unwrap : Remove large jumps in angle by wrapping. // // Notes // ----- -// The irrational number ``e`` is also known as Euler's number. It is -// approximately 2.718281, and is the base of the natural logarithm, -// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, -// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. -// -// For complex arguments, ``x = a + ib``, we can write -// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already -// known (it is the real argument, described above). The second term, -// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with -// magnitude 1 and a periodic phase. +// .. versionadded:: 1.3.0 // -// References -// ---------- -// .. [1] Wikipedia, "Exponential function", -// https://en.wikipedia.org/wiki/Exponential_function -// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions -// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, -// https://personal.math.ubc.ca/~cbm/aands/page_69.htm +// rad2deg(x) is ``180 * x / pi``. // // Examples // -------- -// Plot the magnitude and phase of ``exp(x)`` in the complex plane: +// >>> np.rad2deg(np.pi/2) +// 90.0 // -// >>> import numpy as np +//go:linkname Rad2deg py.rad2deg +func Rad2deg(x *py.Object, out *py.Object) *py.Object // -// >>> import matplotlib.pyplot as plt -// >>> import numpy as np +// Display a message on a device. // -// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) -// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane -// >>> out = np.exp(xx) +// Parameters +// ---------- +// mesg : str +// Message to display. +// device : object +// Device to write message. If None, defaults to ``sys.stdout`` which is +// very similar to ``print``. `device` needs to have ``write()`` and +// ``flush()`` methods. +// linefeed : bool, optional +// Option whether to print a line feed or not. Defaults to True. // -// >>> plt.subplot(121) -// >>> plt.imshow(np.abs(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') -// >>> plt.title('Magnitude of exp(x)') +// Raises +// ------ +// AttributeError +// If `device` does not have a ``write()`` or ``flush()`` method. // -// >>> plt.subplot(122) -// >>> plt.imshow(np.angle(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') -// >>> plt.title('Phase (angle) of exp(x)') -// >>> plt.show() +// Examples +// -------- +// Besides ``sys.stdout``, a file-like object can also be used as it has +// both required methods: // -//go:linkname Exp py.exp -func Exp(x *py.Object, out *py.Object) *py.Object -//go:linkname Rint py.rint -func Rint(__llgo_va_list ...interface{}) *py.Object +// >>> from io import StringIO +// >>> buf = StringIO() +// >>> np.disp(u'"Display" in a file', device=buf) +// >>> buf.getvalue() +// '"Display" in a file\n' // -// Compute the standard deviation along the specified axis. // -// Returns the standard deviation, a measure of the spread of a distribution, -// of the array elements. The standard deviation is computed for the -// flattened array by default, otherwise over the specified axis. +// +//go:linkname Disp py.disp +func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object +// +// Load ASCII data stored in a comma-separated file. +// +// The returned array is a record array (if ``usemask=False``, see +// `recarray`) or a masked record array (if ``usemask=True``, +// see `ma.mrecords.MaskedRecords`). // // Parameters // ---------- -// a : array_like -// Calculate the standard deviation of these values. -// axis : None or int or tuple of ints, optional -// Axis or axes along which the standard deviation is computed. The -// default is to compute the standard deviation of the flattened array. -// If this is a tuple of ints, a standard deviation is performed over -// multiple axes, instead of a single axis or all the axes as before. -// dtype : dtype, optional -// Type to use in computing the standard deviation. For arrays of -// integer type the default is float64, for arrays of float types it is -// the same as the array type. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output but the type (of the calculated -// values) will be cast if necessary. -// See :ref:`ufuncs-output-type` for more details. -// ddof : {int, float}, optional -// Means Delta Degrees of Freedom. The divisor used in calculations -// is ``N - ddof``, where ``N`` represents the number of elements. -// By default `ddof` is zero. See Notes for details about use of `ddof`. -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `std` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// where : array_like of bool, optional -// Elements to include in the standard deviation. -// See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.20.0 -// -// mean : array_like, optional -// Provide the mean to prevent its recalculation. The mean should have -// a shape as if it was calculated with ``keepdims=True``. -// The axis for the calculation of the mean should be the same as used in -// the call to this std function. -// -// .. versionadded:: 2.0.0 -// -// correction : {int, float}, optional -// Array API compatible name for the ``ddof`` parameter. Only one of them -// can be provided at the same time. -// -// .. versionadded:: 2.0.0 -// -// Returns -// ------- -// standard_deviation : ndarray, see dtype parameter above. -// If `out` is None, return a new array containing the standard deviation, -// otherwise return a reference to the output array. +// fname, kwargs : For a description of input parameters, see `genfromtxt`. // // See Also // -------- -// var, mean, nanmean, nanstd, nanvar -// :ref:`ufuncs-output-type` +// numpy.genfromtxt : generic function to load ASCII data. // // Notes // ----- -// There are several common variants of the array standard deviation -// calculation. Assuming the input `a` is a one-dimensional NumPy array -// and ``mean`` is either provided as an argument or computed as -// ``a.mean()``, NumPy computes the standard deviation of an array as:: -// -// N = len(a) -// d2 = abs(a - mean)**2 # abs is for complex `a` -// var = d2.sum() / (N - ddof) # note use of `ddof` -// std = var**0.5 -// -// Different values of the argument `ddof` are useful in different -// contexts. NumPy's default ``ddof=0`` corresponds with the expression: +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. // -// .. math:: // -// \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N}} // -// which is sometimes called the "population standard deviation" in the field -// of statistics because it applies the definition of standard deviation to -// `a` as if `a` were a complete population of possible observations. +//go:linkname Recfromcsv py.recfromcsv +func Recfromcsv(fname *py.Object) *py.Object // -// Many other libraries define the standard deviation of an array -// differently, e.g.: +// Return the cumulative sum of array elements over a given axis treating Not a +// Numbers (NaNs) as zero. The cumulative sum does not change when NaNs are +// encountered and leading NaNs are replaced by zeros. // -// .. math:: +// Zeros are returned for slices that are all-NaN or empty. // -// \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N - 1}} +// .. versionadded:: 1.12.0 // -// In statistics, the resulting quantity is sometimes called the "sample -// standard deviation" because if `a` is a random sample from a larger -// population, this calculation provides the square root of an unbiased -// estimate of the variance of the population. The use of :math:`N-1` in the -// denominator is often called "Bessel's correction" because it corrects for -// bias (toward lower values) in the variance estimate introduced when the -// sample mean of `a` is used in place of the true mean of the population. -// The resulting estimate of the standard deviation is still biased, but less -// than it would have been without the correction. For this quantity, use -// ``ddof=1``. +// Parameters +// ---------- +// a : array_like +// Input array. +// axis : int, optional +// Axis along which the cumulative sum is computed. The default +// (None) is to compute the cumsum over the flattened array. +// dtype : dtype, optional +// Type of the returned array and of the accumulator in which the +// elements are summed. If `dtype` is not specified, it defaults +// to the dtype of `a`, unless `a` has an integer dtype with a +// precision less than that of the default platform integer. In +// that case, the default platform integer is used. +// out : ndarray, optional +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output +// but the type will be cast if necessary. See :ref:`ufuncs-output-type` for +// more details. // -// Note that, for complex numbers, `std` takes the absolute -// value before squaring, so that the result is always real and nonnegative. +// Returns +// ------- +// nancumsum : ndarray. +// A new array holding the result is returned unless `out` is +// specified, in which it is returned. The result has the same +// size as `a`, and the same shape as `a` if `axis` is not None +// or `a` is a 1-d array. // -// For floating-point input, the standard deviation is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for float32 (see example below). -// Specifying a higher-accuracy accumulator using the `dtype` keyword can -// alleviate this issue. +// See Also +// -------- +// numpy.cumsum : Cumulative sum across array propagating NaNs. +// isnan : Show which elements are NaN. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> np.std(a) -// 1.1180339887498949 # may vary -// >>> np.std(a, axis=0) +// >>> np.nancumsum(1) +// array([1]) +// >>> np.nancumsum([1]) +// array([1]) +// >>> np.nancumsum([1, np.nan]) // array([1., 1.]) -// >>> np.std(a, axis=1) -// array([0.5, 0.5]) -// -// In single precision, std() can be inaccurate: -// -// >>> a = np.zeros((2, 512*512), dtype=np.float32) -// >>> a[0, :] = 1.0 -// >>> a[1, :] = 0.1 -// >>> np.std(a) -// np.float32(0.45000005) -// -// Computing the standard deviation in float64 is more accurate: -// -// >>> np.std(a, dtype=np.float64) -// 0.44999999925494177 # may vary -// -// Specifying a where argument: -// -// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) -// >>> np.std(a) -// 2.614064523559687 # may vary -// >>> np.std(a, where=[[True], [True], [False]]) -// 2.0 -// -// Using the mean keyword to save computation time: -// -// >>> import numpy as np -// >>> from timeit import timeit -// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) -// >>> mean = np.mean(a, axis=1, keepdims=True) -// >>> -// >>> g = globals() -// >>> n = 10000 -// >>> t1 = timeit("std = np.std(a, axis=1, mean=mean)", globals=g, number=n) -// >>> t2 = timeit("std = np.std(a, axis=1)", globals=g, number=n) -// >>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%') -// #doctest: +SKIP -// Percentage execution time saved 30% -// -// +// >>> a = np.array([[1, 2], [3, np.nan]]) +// >>> np.nancumsum(a) +// array([1., 3., 6., 6.]) +// >>> np.nancumsum(a, axis=0) +// array([[1., 2.], +// [4., 2.]]) +// >>> np.nancumsum(a, axis=1) +// array([[1., 3.], +// [3., 3.]]) // -//go:linkname Std py.std -func Std(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object // -// Take elements from an array along an axis. // -// When axis is not None, this function does the same thing as "fancy" -// indexing (indexing arrays using arrays); however, it can be easier to use -// if you need elements along a given axis. A call such as -// ``np.take(arr, indices, axis=3)`` is equivalent to -// ``arr[:,:,:,indices,...]``. +//go:linkname Nancumsum py.nancumsum +func Nancumsum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object +// Return a contiguous flattened array. // -// Explained without fancy indexing, this is equivalent to the following use -// of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of -// indices:: +// A 1-D array, containing the elements of the input, is returned. A copy is +// made only if needed. // -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// Nj = indices.shape -// for ii in ndindex(Ni): -// for jj in ndindex(Nj): -// for kk in ndindex(Nk): -// out[ii + jj + kk] = a[ii + (indices[jj],) + kk] +// As of NumPy 1.10, the returned array will have the same type as the input +// array. (for example, a masked array will be returned for a masked array +// input) // // Parameters // ---------- -// a : array_like (Ni..., M, Nk...) -// The source array. -// indices : array_like (Nj...) -// The indices of the values to extract. -// Also allow scalars for indices. -// axis : int, optional -// The axis over which to select values. By default, the flattened -// input array is used. -// out : ndarray, optional (Ni..., Nj..., Nk...) -// If provided, the result will be placed in this array. It should -// be of the appropriate shape and dtype. Note that `out` is always -// buffered if `mode='raise'`; use other modes for better performance. -// mode : {'raise', 'wrap', 'clip'}, optional -// Specifies how out-of-bounds indices will behave. -// -// * 'raise' -- raise an error (default) -// * 'wrap' -- wrap around -// * 'clip' -- clip to the range +// a : array_like +// Input array. The elements in `a` are read in the order specified by +// `order`, and packed as a 1-D array. +// order : {'C','F', 'A', 'K'}, optional // -// 'clip' mode means that all indices that are too large are replaced -// by the index that addresses the last element along that axis. Note -// that this disables indexing with negative numbers. +// The elements of `a` are read using this index order. 'C' means +// to index the elements in row-major, C-style order, +// with the last axis index changing fastest, back to the first +// axis index changing slowest. 'F' means to index the elements +// in column-major, Fortran-style order, with the +// first index changing fastest, and the last index changing +// slowest. Note that the 'C' and 'F' options take no account of +// the memory layout of the underlying array, and only refer to +// the order of axis indexing. 'A' means to read the elements in +// Fortran-like index order if `a` is Fortran *contiguous* in +// memory, C-like order 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. // // Returns // ------- -// out : ndarray (Ni..., Nj..., Nk...) -// The returned array has the same type as `a`. +// y : array_like +// y is a contiguous 1-D array of the same subtype as `a`, +// with shape ``(a.size,)``. +// Note that matrices are special cased for backward compatibility, +// if `a` is a matrix, then y is a 1-D ndarray. // // See Also // -------- -// compress : Take elements using a boolean mask -// ndarray.take : equivalent method -// take_along_axis : Take elements by matching the array and the index arrays +// ndarray.flat : 1-D iterator over an array. +// ndarray.flatten : 1-D array copy of the elements of an array +// in row-major order. +// ndarray.reshape : Change the shape of an array without changing its data. // // Notes // ----- -// By eliminating the inner loop in the description above, and using `s_` to -// build simple slice objects, `take` can be expressed in terms of applying -// fancy indexing to each 1-d slice:: -// -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// for ii in ndindex(Ni): -// for kk in ndindex(Nj): -// out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices] -// -// For this reason, it is equivalent to (but faster than) the following use -// of `apply_along_axis`:: +// In row-major, C-style order, in two dimensions, the row index +// varies the slowest, and the column index the quickest. This can +// be generalized to multiple dimensions, where row-major order +// implies that the index along the first axis varies slowest, and +// the index along the last quickest. The opposite holds for +// column-major, Fortran-style index ordering. // -// out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a) +// When a view is desired in as many cases as possible, ``arr.reshape(-1)`` +// may be preferable. However, ``ravel`` supports ``K`` in the optional +// ``order`` argument while ``reshape`` does not. // // Examples // -------- -// >>> import numpy as np -// >>> a = [4, 3, 5, 7, 6, 8] -// >>> indices = [0, 1, 4] -// >>> np.take(a, indices) -// array([4, 3, 6]) -// -// In this example if `a` is an ndarray, "fancy" indexing can be used. -// -// >>> a = np.array(a) -// >>> a[indices] -// array([4, 3, 6]) +// It is equivalent to ``reshape(-1, order=order)``. // -// If `indices` is not one dimensional, the output also has these dimensions. +// >>> x = np.array([[1, 2, 3], [4, 5, 6]]) +// >>> np.ravel(x) +// array([1, 2, 3, 4, 5, 6]) // -// >>> np.take(a, [[0, 1], [2, 3]]) -// array([[4, 3], -// [5, 7]]) +// >>> x.reshape(-1) +// array([1, 2, 3, 4, 5, 6]) // +// >>> np.ravel(x, order='F') +// array([1, 4, 2, 5, 3, 6]) // -//go:linkname Take py.take -func Take(a *py.Object, indices *py.Object, axis *py.Object, out *py.Object, mode *py.Object) *py.Object +// When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering: // -// Construct an array from a text file, using regular expression parsing. +// >>> np.ravel(x.T) +// array([1, 4, 2, 5, 3, 6]) +// >>> np.ravel(x.T, order='A') +// array([1, 2, 3, 4, 5, 6]) // -// The returned array is always a structured array, and is constructed from -// all matches of the regular expression in the file. Groups in the regular -// expression are converted to fields of the structured array. +// When ``order`` is 'K', it will preserve orderings that are neither 'C' +// nor 'F', but won't reverse axes: // -// Parameters -// ---------- -// file : file, str, or pathlib.Path -// Filename or file object to read. +// >>> a = np.arange(3)[::-1]; a +// array([2, 1, 0]) +// >>> a.ravel(order='C') +// array([2, 1, 0]) +// >>> a.ravel(order='K') +// array([2, 1, 0]) // -// .. versionchanged:: 1.22.0 -// Now accepts `os.PathLike` implementations. -// -// regexp : str or regexp -// Regular expression used to parse the file. -// Groups in the regular expression correspond to fields in the dtype. -// dtype : dtype or list of dtypes -// Dtype for the structured array; must be a structured datatype. -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// -// Returns -// ------- -// output : ndarray -// The output array, containing the part of the content of `file` that -// was matched by `regexp`. `output` is always a structured array. +// >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a +// array([[[ 0, 2, 4], +// [ 1, 3, 5]], +// [[ 6, 8, 10], +// [ 7, 9, 11]]]) +// >>> a.ravel(order='C') +// array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11]) +// >>> a.ravel(order='K') +// array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) // -// Raises -// ------ -// TypeError -// When `dtype` is not a valid dtype for a structured array. // -// See Also -// -------- -// fromstring, loadtxt // -// Notes -// ----- -// Dtypes for structured arrays can be specified in several forms, but all -// forms specify at least the data type and field name. For details see -// `basics.rec`. +//go:linkname Ravel py.ravel +func Ravel(a *py.Object, order *py.Object) *py.Object +// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Examples -// -------- -// >>> import numpy as np -// >>> from io import StringIO -// >>> text = StringIO("1312 foo\n1534 bar\n444 qux") +// Return (x1 == x2) element-wise. // -// >>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything] -// >>> output = np.fromregex(text, regexp, -// ... [('num', np.int64), ('key', 'S3')]) -// >>> output -// array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')], -// dtype=[('num', '>> output['num'] -// array([1312, 1534, 444]) +// Parameters +// ---------- +// x1, x2 : array_like +// Input arrays. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise comparison of `x1` and `x2`. +// Typically of type bool, unless ``dtype=object`` is passed. +// This is a scalar if both `x1` and `x2` are scalars. // +// See Also +// -------- +// not_equal, greater_equal, less_equal, greater, less // -//go:linkname Fromregex py.fromregex -func Fromregex(file *py.Object, regexp *py.Object, dtype *py.Object, encoding *py.Object) *py.Object +// Examples +// -------- +// >>> np.equal([0, 1, 3], np.arange(3)) +// array([ True, True, False]) // -// busday_count( -// begindates, -// enddates, -// weekmask='1111100', -// holidays=[], -// busdaycal=None, -// out=None -// ) +// What is compared are values, not types. So an int (1) and an array of +// length one can evaluate as True: // -// Counts the number of valid days between `begindates` and -// `enddates`, not including the day of `enddates`. +// >>> np.equal(1, np.ones(1)) +// array([ True]) // -// If ``enddates`` specifies a date value that is earlier than the -// corresponding ``begindates`` date value, the count will be negative. +// The ``==`` operator can be used as a shorthand for ``np.equal`` on +// ndarrays. // -// Parameters -// ---------- -// begindates : array_like of datetime64[D] -// The array of the first dates for counting. -// enddates : array_like of datetime64[D] -// The array of the end dates for counting, which are excluded -// from the count themselves. -// weekmask : str or array_like of bool, optional -// A seven-element array indicating which of Monday through Sunday are -// valid days. May be specified as a length-seven list or array, like -// [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string -// like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for -// weekdays, optionally separated by white space. Valid abbreviations -// are: Mon Tue Wed Thu Fri Sat Sun -// holidays : array_like of datetime64[D], optional -// An array of dates to consider as invalid dates. They may be -// specified in any order, and NaT (not-a-time) dates are ignored. -// This list is saved in a normalized form that is suited for -// fast calculations of valid days. -// busdaycal : busdaycalendar, optional -// A `busdaycalendar` object which specifies the valid days. If this -// parameter is provided, neither weekmask nor holidays may be -// provided. -// out : array of int, optional -// If provided, this array is filled with the result. +// >>> a = np.array([2, 4, 6]) +// >>> b = np.array([2, 4, 2]) +// >>> a == b +// array([ True, True, False]) // -// Returns -// ------- -// out : array of int -// An array with a shape from broadcasting ``begindates`` and ``enddates`` -// together, containing the number of valid days between -// the begin and end dates. +//go:linkname Equal py.equal +func Equal(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// See Also -// -------- -// busdaycalendar : An object that specifies a custom set of valid days. -// is_busday : Returns a boolean array indicating valid days. -// busday_offset : Applies an offset counted in valid days. +// Compute the truth value of x1 XOR x2, element-wise. // -// Examples -// -------- -// >>> import numpy as np -// >>> # Number of weekdays in January 2011 -// ... np.busday_count('2011-01', '2011-02') -// 21 -// >>> # Number of weekdays in 2011 -// >>> np.busday_count('2011', '2012') -// 260 -// >>> # Number of Saturdays in 2011 -// ... np.busday_count('2011', '2012', weekmask='Sat') -// 53 +// Parameters +// ---------- +// x1, x2 : array_like +// Logical XOR is applied to the elements of `x1` and `x2`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // +// Returns +// ------- +// y : bool or ndarray of bool +// Boolean result of the logical XOR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. +// This is a scalar if both `x1` and `x2` are scalars. // -//go:linkname BusdayCount py.busday_count -func BusdayCount(begindates *py.Object, enddates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object +// See Also +// -------- +// logical_and, logical_or, logical_not, bitwise_xor // -// concatenate( -// (a1, a2, ...), -// axis=0, -// out=None, -// dtype=None, -// casting="same_kind" -// ) +// Examples +// -------- +// >>> np.logical_xor(True, False) +// True +// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) +// array([False, True, True, False]) // -// Join a sequence of arrays along an existing axis. +// >>> x = np.arange(5) +// >>> np.logical_xor(x < 1, x > 3) +// array([ True, False, False, False, True]) // -// Parameters -// ---------- -// a1, a2, ... : sequence of array_like -// The arrays must have the same shape, except in the dimension -// corresponding to `axis` (the first, by default). -// axis : int, optional -// The axis along which the arrays will be joined. If axis is None, -// arrays are flattened before use. Default is 0. -// out : ndarray, optional -// If provided, the destination to place the result. The shape must be -// correct, matching that of what concatenate 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`. +// Simple example showing support of broadcasting // -// .. versionadded:: 1.20.0 +// >>> np.logical_xor(0, np.eye(2)) +// array([[ True, False], +// [False, True]]) // -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Defaults to 'same_kind'. -// For a description of the options, please see :term:`casting`. +//go:linkname LogicalXor py.logical_xor +func LogicalXor(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// .. versionadded:: 1.20.0 +// Returns the element-wise remainder of division. // -// Returns -// ------- -// res : ndarray -// The concatenated array. +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. // -// See Also -// -------- -// ma.concatenate : Concatenate function that preserves input masks. -// array_split : Split an array into multiple sub-arrays of equal or -// near-equal size. -// split : Split array into a list of multiple sub-arrays of equal size. -// hsplit : Split array into multiple sub-arrays horizontally (column wise). -// vsplit : Split array into multiple sub-arrays vertically (row wise). -// dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). -// stack : Stack a sequence of arrays along a new axis. -// block : Assemble arrays from blocks. -// hstack : Stack arrays in sequence horizontally (column wise). -// vstack : Stack arrays in sequence vertically (row wise). -// dstack : Stack arrays in sequence depth wise (along third dimension). -// column_stack : Stack 1-D arrays as columns into a 2-D array. +// .. warning:: // -// Notes -// ----- -// When one or more of the arrays to be concatenated is a MaskedArray, -// this function will return a MaskedArray object instead of an ndarray, -// but the input masks are *not* preserved. In cases where a MaskedArray -// is expected as input, use the ma.concatenate function from the masked -// array module instead. +// This should not be confused with: // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> b = np.array([[5, 6]]) -// >>> np.concatenate((a, b), axis=0) -// array([[1, 2], -// [3, 4], -// [5, 6]]) -// >>> np.concatenate((a, b.T), axis=1) -// array([[1, 2, 5], -// [3, 4, 6]]) -// >>> np.concatenate((a, b), axis=None) -// array([1, 2, 3, 4, 5, 6]) +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. // -// This function will not preserve masking of MaskedArray inputs. +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> a = np.ma.arange(3) -// >>> a[1] = np.ma.masked -// >>> b = np.arange(2, 5) -// >>> a -// masked_array(data=[0, --, 2], -// mask=[False, True, False], -// fill_value=999999) -// >>> b -// array([2, 3, 4]) -// >>> np.concatenate([a, b]) -// masked_array(data=[0, 1, 2, 2, 3, 4], -// mask=False, -// fill_value=999999) -// >>> np.ma.concatenate([a, b]) -// masked_array(data=[0, --, 2, 2, 3, 4], -// mask=[False, True, False, False, False, False], -// fill_value=999999) +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. // +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor // +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. // -//go:linkname Concat py.concat -func Concat(__llgo_va_list ...interface{}) *py.Object +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) // -// Get the current way of handling floating-point errors. +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. +// +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Remainder py.remainder +func Remainder(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// +// Format a floating-point scalar as a decimal string in positional notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. +// +// Parameters +// ---------- +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed, or if `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// fractional : boolean, optional +// If `True`, the cutoffs of `precision` and `min_digits` refer to the +// total number of digits after the decimal point, including leading +// zeros. +// If `False`, `precision` and `min_digits` refer to the total number of +// significant digits, before or after the decimal point, ignoring leading +// zeros. +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// pad_right : non-negative integer, optional +// Pad the right side of the string with whitespace until at least that +// many characters are to the right of the decimal point. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. Only has an effect if `unique=True` +// in which case additional digits past those necessary to uniquely +// identify the value may be printed, rounding the last additional digit. +// +// -- versionadded:: 1.21.0 // // Returns // ------- -// res : dict -// A dictionary with keys "divide", "over", "under", and "invalid", -// whose values are from the strings "ignore", "print", "log", "warn", -// "raise", and "call". The keys represent possible floating-point -// exceptions, and the values define how these exceptions are handled. +// rep : string +// The string representation of the floating point value // // See Also // -------- -// geterrcall, seterr, seterrcall -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. +// format_float_scientific // // Examples // -------- -// >>> import numpy as np -// >>> np.geterr() -// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) # doctest: +SKIP -// array([nan, 1., 1.]) -// RuntimeWarning: invalid value encountered in divide -// -// >>> oldsettings = np.seterr(all='warn', invalid='raise') -// >>> np.geterr() -// {'divide': 'warn', 'over': 'warn', 'under': 'warn', 'invalid': 'raise'} -// >>> np.arange(3.) / np.arange(3.) -// Traceback (most recent call last): -// ... -// FloatingPointError: invalid value encountered in divide -// >>> oldsettings = np.seterr(**oldsettings) # restore original -// -// -// -//go:linkname Geterr py.geterr -func Geterr() *py.Object -//go:linkname Logaddexp py.logaddexp -func Logaddexp(__llgo_va_list ...interface{}) *py.Object +// >>> np.format_float_positional(np.float32(np.pi)) +// '3.1415927' +// >>> np.format_float_positional(np.float16(np.pi)) +// '3.14' +// >>> np.format_float_positional(np.float16(0.3)) +// '0.3' +// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) +// '0.3000488281' // -// Replaces specified elements of an array with given values. // -// The indexing works on the flattened target array. `put` is roughly -// equivalent to: +//go:linkname FormatFloatPositional py.format_float_positional +func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object // -// :: +// Return the character for the minimum-size type to which given types can +// be safely cast. // -// a.flat[ind] = v +// The returned type character must represent the smallest size dtype such +// that an array of the returned type can handle the data from an array of +// all types in `typechars` (or if `typechars` is an array, then its +// dtype.char). // // Parameters // ---------- -// a : ndarray -// Target array. -// ind : array_like -// Target indices, interpreted as integers. -// v : array_like -// Values to place in `a` at target indices. If `v` is shorter than -// `ind` it will be repeated as necessary. -// mode : {'raise', 'wrap', 'clip'}, optional -// Specifies how out-of-bounds indices will behave. -// -// * 'raise' -- raise an error (default) -// * 'wrap' -- wrap around -// * 'clip' -- clip to the range +// typechars : list of str or array_like +// If a list of strings, each string should represent a dtype. +// If array_like, the character representation of the array dtype is used. +// typeset : str or list of str, optional +// The set of characters that the returned character is chosen from. +// The default set is 'GDFgdf'. +// default : str, optional +// The default character, this is returned if none of the characters in +// `typechars` matches a character in `typeset`. // -// 'clip' mode means that all indices that are too large are replaced -// by the index that addresses the last element along that axis. Note -// that this disables indexing with negative numbers. In 'raise' mode, -// if an exception occurs the target array may still be modified. +// Returns +// ------- +// typechar : str +// The character representing the minimum-size type that was found. // // See Also // -------- -// putmask, place -// put_along_axis : Put elements by matching the array and the index arrays +// dtype, sctype2char, maximum_sctype // // Examples // -------- -// >>> import numpy as np -// >>> a = np.arange(5) -// >>> np.put(a, [0, 2], [-44, -55]) -// >>> a -// array([-44, 1, -55, 3, 4]) -// -// >>> a = np.arange(5) -// >>> np.put(a, 22, -5, mode='clip') -// >>> a -// array([ 0, 1, 2, 3, -5]) -// +// >>> np.mintypecode(['d', 'f', 'S']) +// 'd' +// >>> x = np.array([1.1, 2-3.j]) +// >>> np.mintypecode(x) +// 'D' // +// >>> np.mintypecode('abceh', default='G') +// 'G' // -//go:linkname Put py.put -func Put(a *py.Object, ind *py.Object, v *py.Object, mode *py.Object) *py.Object // -// Return a sorted copy of an array. // -// Parameters -// ---------- -// a : array_like -// Array to be sorted. -// axis : int or None, optional -// Axis along which to sort. If None, the array is flattened before -// sorting. The default is -1, which sorts along the last axis. -// kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional -// Sorting algorithm. The default is 'quicksort'. Note that both 'stable' -// and 'mergesort' use timsort or radix sort under the covers and, -// in general, the actual implementation will vary with data type. -// The 'mergesort' option is retained for backwards compatibility. -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument specifies -// which fields to compare first, second, etc. A single field can -// be specified as a string, and not all fields need be specified, -// but unspecified fields will still be used, in the order in which -// they come up in the dtype, to break ties. -// stable : bool, optional -// Sort stability. If ``True``, the returned array will maintain -// the relative order of ``a`` values which compare as equal. -// If ``False`` or ``None``, this is not guaranteed. Internally, -// this option selects ``kind='stable'``. Default: ``None``. +//go:linkname Mintypecode py.mintypecode +func Mintypecode(typechars *py.Object, typeset *py.Object, Default *py.Object) *py.Object // -// .. versionadded:: 2.0.0 +// Test whether each element of a 1-D array is also present in a second array. // -// Returns -// ------- -// sorted_array : ndarray -// Array of the same type and shape as `a`. +// Returns a boolean array the same length as `ar1` that is True +// where an element of `ar1` is in `ar2` and False otherwise. // -// See Also -// -------- -// ndarray.sort : Method to sort an array in-place. -// argsort : Indirect sort. -// lexsort : Indirect stable sort on multiple keys. -// searchsorted : Find elements in a sorted array. -// partition : Partial sort. +// We recommend using :func:`isin` instead of `in1d` for new code. // -// Notes -// ----- -// The various sorting algorithms are characterized by their average speed, -// worst case performance, work space size, and whether they are stable. A -// stable sort keeps items with the same key in the same relative -// order. The four algorithms implemented in NumPy have the following -// properties: -// -// =========== ======= ============= ============ ======== -// kind speed worst case work space stable -// =========== ======= ============= ============ ======== -// 'quicksort' 1 O(n^2) 0 no -// 'heapsort' 3 O(n*log(n)) 0 no -// 'mergesort' 2 O(n*log(n)) ~n/2 yes -// 'timsort' 2 O(n*log(n)) ~n/2 yes -// =========== ======= ============= ============ ======== -// -// .. note:: The datatype determines which of 'mergesort' or 'timsort' -// is actually used, even if 'mergesort' is specified. User selection -// at a finer scale is not currently available. -// -// For performance, ``sort`` makes a temporary copy if needed to make the data -// `contiguous `_ -// in memory along the sort axis. For even better performance and reduced -// memory consumption, ensure that the array is already contiguous along the -// sort axis. -// -// The sort order for complex numbers is lexicographic. If both the real -// and imaginary parts are non-nan then the order is determined by the -// real parts except when they are equal, in which case the order is -// determined by the imaginary parts. +// Parameters +// ---------- +// ar1 : (M,) array_like +// Input array. +// ar2 : array_like +// The values against which to test each value of `ar1`. +// assume_unique : bool, optional +// If True, the input arrays are both assumed to be unique, which +// can speed up the calculation. Default is False. +// invert : bool, optional +// If True, the values in the returned array are inverted (that is, +// 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. // -// Previous to numpy 1.4.0 sorting real and complex arrays containing nan -// values led to undefined behaviour. In numpy versions >= 1.4.0 nan -// values are sorted to the end. The extended sort order is: +// * 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. // -// * Real: [R, nan] -// * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj] +// .. versionadded:: 1.8.0 // -// where R is a non-nan real value. Complex values with the same nan -// placements are sorted according to the non-nan part if it exists. -// Non-nan values are sorted as before. +// Returns +// ------- +// in1d : (M,) ndarray, bool +// The values `ar1[in1d]` are in `ar2`. // -// quicksort has been changed to: -// `introsort `_. -// When sorting does not make enough progress it switches to -// `heapsort `_. -// This implementation makes quicksort O(n*log(n)) in the worst case. +// See Also +// -------- +// isin : Version of this function that preserves the +// shape of ar1. +// numpy.lib.arraysetops : Module with a number of other functions for +// performing set operations on arrays. // -// 'stable' automatically chooses the best stable sorting algorithm -// for the data type being sorted. -// It, along with 'mergesort' is currently mapped to -// `timsort `_ -// or `radix sort `_ -// depending on the data type. -// API forward compatibility currently limits the -// ability to select the implementation and it is hardwired for the different -// data types. +// Notes +// ----- +// `in1d` can be considered as an element-wise function version of the +// python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly +// equivalent to ``np.array([item in b for item in a])``. +// However, this idea fails if `ar2` is a set, or similar (non-sequence) +// container: As ``ar2`` is converted to an array, in those cases +// ``asarray(ar2)`` is an object array rather than the expected array of +// contained values. // -// Timsort is added for better performance on already or nearly -// sorted data. On random data timsort is almost identical to -// mergesort. It is now used for stable sort while quicksort is still the -// default sort if none is chosen. For timsort details, refer to -// `CPython listsort.txt -// `_ -// 'mergesort' and 'stable' are mapped to radix sort for integer data types. -// Radix sort is an O(n) sort instead of O(n log n). +// 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. // -// NaT now sorts to the end of arrays for consistency with NaN. +// .. versionadded:: 1.4.0 // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1,4],[3,1]]) -// >>> np.sort(a) # sort along the last axis -// array([[1, 4], -// [1, 3]]) -// >>> np.sort(a, axis=None) # sort the flattened array -// array([1, 1, 3, 4]) -// >>> np.sort(a, axis=0) # sort along the first axis -// array([[1, 1], -// [3, 4]]) -// -// Use the `order` keyword to specify a field to use when sorting a -// structured array: -// -// >>> dtype = [('name', 'S10'), ('height', float), ('age', int)] -// >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38), -// ... ('Galahad', 1.7, 38)] -// >>> a = np.array(values, dtype=dtype) # create a structured array -// >>> np.sort(a, order='height') # doctest: +SKIP -// array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41), -// ('Lancelot', 1.8999999999999999, 38)], -// dtype=[('name', '|S10'), ('height', '>> np.sort(a, order=['age', 'height']) # doctest: +SKIP -// array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38), -// ('Arthur', 1.8, 41)], -// dtype=[('name', '|S10'), ('height', '>> test = np.array([0, 1, 2, 5, 0]) +// >>> states = [0, 2] +// >>> mask = np.in1d(test, states) +// >>> mask +// array([ True, False, True, False, True]) +// >>> test[mask] +// array([0, 2, 0]) +// >>> mask = np.in1d(test, states, invert=True) +// >>> mask +// array([False, True, False, True, False]) +// >>> test[mask] +// array([1, 5]) // -// Parameters -// ---------- -// x : array_like -// `x`-coordinate on the unit circle. -// For real arguments, the domain is [-1, 1]. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. // -// Returns -// ------- -// angle : ndarray -// The angle of the ray intersecting the unit circle at the given -// `x`-coordinate in radians [0, pi]. -// This is a scalar if `x` is a scalar. +//go:linkname In1d py.in1d +func In1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object // -// See Also -// -------- -// cos, arctan, arcsin, emath.arccos +// packbits(a, /, axis=None, bitorder='big') // -// Notes -// ----- -// `arccos` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``cos(z) = x``. The convention is to return -// the angle `z` whose real part lies in `[0, pi]`. +// Packs the elements of a binary-valued array into bits in a uint8 array. // -// For real-valued input data types, `arccos` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. +// The result is padded to full bytes by inserting zero bits at the end. // -// For complex-valued input, `arccos` is a complex analytic function that -// has branch cuts ``[-inf, -1]`` and `[1, inf]` and is continuous from -// above on the former and from below on the latter. +// Parameters +// ---------- +// a : array_like +// An array of integers or booleans whose elements should be packed to +// bits. +// axis : int, optional +// The dimension over which bit-packing is done. +// ``None`` implies packing the flattened array. +// bitorder : {'big', 'little'}, optional +// The order of the input bits. 'big' will mimic bin(val), +// ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will +// reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``. +// Defaults to 'big'. // -// The inverse `cos` is also known as `acos` or cos^-1. +// .. versionadded:: 1.17.0 // -// References -// ---------- -// M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm +// Returns +// ------- +// packed : ndarray +// Array of type uint8 whose elements represent bits corresponding to the +// logical (0 or nonzero) value of the input elements. The shape of +// `packed` has the same number of dimensions as the input (unless `axis` +// is None, in which case the output is 1-D). // -// Examples -// -------- -// >>> import numpy as np +// See Also +// -------- +// unpackbits: Unpacks elements of a uint8 array into a binary-valued output +// array. // -// We expect the arccos of 1 to be 0, and of -1 to be pi: +// Examples +// -------- +// >>> a = np.array([[[1,0,1], +// ... [0,1,0]], +// ... [[1,1,0], +// ... [0,0,1]]]) +// >>> b = np.packbits(a, axis=-1) +// >>> b +// array([[[160], +// [ 64]], +// [[192], +// [ 32]]], dtype=uint8) // -// >>> np.arccos([1, -1]) -// array([ 0. , 3.14159265]) +// Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, +// and 32 = 0010 0000. // -// Plot arccos: // -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-1, 1, num=100) -// >>> plt.plot(x, np.arccos(x)) -// >>> plt.axis('tight') -// >>> plt.show() // -//go:linkname Acos py.acos -func Acos(__llgo_va_list ...interface{}) *py.Object -// asfortranarray(a, dtype=None, *, like=None) +//go:linkname Packbits py.packbits +func Packbits(a *py.Object, axis *py.Object, bitorder *py.Object) *py.Object +// asarray(a, dtype=None, order=None, *, like=None) // -// Return an array (ndim >= 1) laid out in Fortran order in memory. +// Convert the input to an array. // // Parameters // ---------- // a : array_like -// Input array. -// dtype : str or dtype object, optional +// Input data, in any form that can be converted to an array. This +// includes lists, lists of tuples, tuples, tuples of tuples, tuples +// of lists and ndarrays. +// dtype : data-type, optional // By default, the data-type is inferred from the input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Memory layout. 'A' and 'K' depend on the order of input array a. +// 'C' row-major (C-style), +// 'F' column-major (Fortran-style) memory representation. +// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise +// 'K' (keep) preserve input order +// Defaults to 'K'. // 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 @@ -16594,62 +14925,75 @@ func Acos(__llgo_va_list ...interface{}) *py.Object // Returns // ------- // out : ndarray -// The input `a` in Fortran, or column-major, order. +// Array interpretation of `a`. No copy is performed if the input +// is already an ndarray with matching dtype and order. If `a` is a +// subclass of ndarray, a base class ndarray is returned. // // See Also // -------- -// ascontiguousarray : Convert input to a contiguous (C order) array. -// asanyarray : Convert input to an ndarray with either row or -// column-major memory order. -// require : Return an ndarray that satisfies requirements. -// ndarray.flags : Information about the memory layout of the array. +// asanyarray : Similar function which passes through subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfarray : Convert input to a floating point ndarray. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// asarray_chkfinite : Similar function which checks input for NaNs and Infs. +// fromiter : Create an array from an iterator. +// fromfunction : Construct an array by executing a function on grid +// positions. // // Examples // -------- -// Starting with a C-contiguous array: +// Convert a list into an array: // -// >>> import numpy as np -// >>> x = np.ones((2, 3), order='C') -// >>> x.flags['C_CONTIGUOUS'] -// True +// >>> a = [1, 2] +// >>> np.asarray(a) +// array([1, 2]) // -// Calling ``asfortranarray`` makes a Fortran-contiguous copy: +// Existing arrays are not copied: // -// >>> y = np.asfortranarray(x) -// >>> y.flags['F_CONTIGUOUS'] +// >>> a = np.array([1, 2]) +// >>> np.asarray(a) is a // True -// >>> np.may_share_memory(x, y) -// False // -// Now, starting with a Fortran-contiguous array: +// If `dtype` is set, array is copied only if dtype does not match: // -// >>> x = np.ones((2, 3), order='F') -// >>> x.flags['F_CONTIGUOUS'] +// >>> a = np.array([1, 2], dtype=np.float32) +// >>> np.asarray(a, dtype=np.float32) is a // True +// >>> np.asarray(a, dtype=np.float64) is a +// False // -// Then, calling ``asfortranarray`` returns the same object: +// Contrary to `asanyarray`, ndarray subclasses are not passed through: // -// >>> y = np.asfortranarray(x) -// >>> x is y +// >>> issubclass(np.recarray, np.ndarray) +// True +// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray) +// >>> np.asarray(a) is a +// False +// >>> np.asanyarray(a) is a // True // -// Note: This function returns an array with at least one-dimension (1-d) -// so it will not preserve 0-d arrays. +//go:linkname Asarray py.asarray +func Asarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname Asfortranarray py.asfortranarray -func Asfortranarray(a *py.Object, dtype *py.Object) *py.Object -// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Compute bit-wise inversion, or bit-wise NOT, element-wise. // -// Return the truncated value of the input, element-wise. +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. // -// The truncated value of the scalar `x` is the nearest integer `i` which -// is closer to zero than `x` is. In short, the fractional part of the -// signed number `x` is discarded. +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. // // Parameters // ---------- // x : array_like -// Input data. +// Only integer and boolean types are handled. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -16668,394 +15012,407 @@ func Asfortranarray(a *py.Object, dtype *py.Object) *py.Object // // Returns // ------- -// y : ndarray or scalar -// The truncated value of each element in `x`. +// out : ndarray or scalar +// Result. // This is a scalar if `x` is a scalar. // // See Also // -------- -// ceil, floor, rint, fix +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: +// +// >>> np.bitwise_not is np.invert +// True +// +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.trunc(a) -// array([-1., -1., -0., 0., 1., 1., 2.]) +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: // -//go:linkname Trunc py.trunc -func Trunc(x *py.Object, out *py.Object) *py.Object -// vecdot(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, axes, axis]) +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' +// +// The result depends on the bit-width: +// +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' +// +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: +// +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' // -// Vector dot product of two arrays. +// Booleans are accepted as well: +// +// >>> np.invert(np.array([True, False])) +// array([False, True]) // -// Let :math:`\mathbf{a}` be a vector in `x1` and :math:`\mathbf{b}` be -// a corresponding vector in `x2`. The dot product is defined as: +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. +// +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) // -// .. math:: -// \mathbf{a} \cdot \mathbf{b} = \sum_{i=0}^{n-1} \overline{a_i}b_i +//go:linkname BitwiseNot py.bitwise_not +func BitwiseNot(__llgo_va_list ...interface{}) *py.Object +// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// where the sum is over the last dimension (unless `axis` is specified) and -// where :math:`\overline{a_i}` denotes the complex conjugate if :math:`a_i` -// is complex and the identity otherwise. +// Element-wise maximum of array elements. // -// .. versionadded:: 2.0.0 +// Compare two arrays and return a new array containing the element-wise +// maxima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. // // Parameters // ---------- // x1, x2 : array_like -// Input arrays, scalars not allowed. -// out : ndarray, optional +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have -// the broadcasted shape of `x1` and `x2` with the last axis removed. -// If not provided or None, a freshly-allocated array is used. +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. // **kwargs // For other keyword-only arguments, see the // :ref:`ufunc docs `. // // Returns // ------- -// y : ndarray -// The vector dot product of the inputs. -// This is a scalar only when both x1, x2 are 1-d vectors. -// -// Raises -// ------ -// ValueError -// If the last dimension of `x1` is not the same size as -// the last dimension of `x2`. -// -// If a scalar value is passed in. +// y : ndarray or scalar +// The maximum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// vdot : same but flattens arguments first -// matmul : Matrix-matrix product. -// vecmat : Vector-matrix product. -// matvec : Matrix-vector product. -// einsum : Einstein summation convention. +// fmin : +// Element-wise minimum of two arrays, ignores NaNs. +// maximum : +// Element-wise maximum of two arrays, propagates NaNs. +// amax : +// The maximum value of an array along a given axis, propagates NaNs. +// nanmax : +// The maximum value of an array along a given axis, ignores NaNs. +// +// minimum, amin, nanmin +// +// Notes +// ----- +// .. versionadded:: 1.3.0 +// +// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. // // Examples // -------- -// >>> import numpy as np +// >>> np.fmax([2, 3, 4], [1, 5, 2]) +// array([ 2., 5., 4.]) // -// Get the projected size along a given normal for an array of vectors. +// >>> np.fmax(np.eye(2), [0.5, 2]) +// array([[ 1. , 2. ], +// [ 0.5, 2. ]]) // -// >>> v = np.array([[0., 5., 0.], [0., 0., 10.], [0., 6., 8.]]) -// >>> n = np.array([0., 0.6, 0.8]) -// >>> np.vecdot(v, n) -// array([ 3., 8., 10.]) +// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) // -//go:linkname Vecdot py.vecdot -func Vecdot(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +//go:linkname Fmax py.fmax +func Fmax(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Pad an array. +// Return the real part of the complex argument. // // Parameters // ---------- -// array : array_like of rank N -// 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 -// for each axis. -// ``(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. +// val : array_like +// Input array. // -// 'constant' (default) -// Pads with a constant value. -// 'edge' -// Pads with the edge values of array. -// 'linear_ramp' -// Pads with the linear ramp between end_value and the -// array edge value. -// 'maximum' -// Pads with the maximum value of all or part of the -// vector along each axis. -// 'mean' -// Pads with the mean value of all or part of the -// vector along each axis. -// 'median' -// Pads with the median value of all or part of the -// vector along each axis. -// 'minimum' -// Pads with the minimum value of all or part of the -// vector along each axis. -// 'reflect' -// Pads with the reflection of the vector mirrored on -// the first and last values of the vector along each -// axis. -// 'symmetric' -// Pads with the reflection of the vector mirrored -// along the edge of the array. -// 'wrap' -// Pads with the wrap of the vector along the axis. -// The first values are used to pad the end and the -// end values are used to pad the beginning. -// 'empty' -// Pads with undefined values. +// Returns +// ------- +// out : ndarray or scalar +// The real component of the complex argument. If `val` is real, the type +// of `val` is used for the output. If `val` has complex elements, the +// returned type is float. // -// -// Padding function, see Notes. -// stat_length : sequence or int, optional -// Used in 'maximum', 'mean', 'median', and 'minimum'. Number of -// values at edge of each axis used to calculate the statistic value. +// See Also +// -------- +// real_if_close, imag, angle // -// ``((before_1, after_1), ... (before_N, after_N))`` unique statistic -// lengths for each axis. +// Examples +// -------- +// >>> a = np.array([1+2j, 3+4j, 5+6j]) +// >>> a.real +// array([1., 3., 5.]) +// >>> a.real = 9 +// >>> a +// array([9.+2.j, 9.+4.j, 9.+6.j]) +// >>> a.real = np.array([9, 8, 7]) +// >>> a +// array([9.+2.j, 8.+4.j, 7.+6.j]) +// >>> np.real(1 + 1j) +// 1.0 // -// ``(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. // -// Default is ``None``, to use the entire axis. -// constant_values : sequence or scalar, optional -// Used in 'constant'. The values to set the padded values for each -// axis. +//go:linkname Real py.real +func Real(val *py.Object) *py.Object // -// ``((before_1, after_1), ... (before_N, after_N))`` unique pad constants -// for each axis. +// Apply a function repeatedly over multiple axes. // -// ``(before, after)`` or ``((before, after),)`` yields same before -// and after constants for each axis. +// `func` is called as `res = func(a, axis)`, where `axis` is the first +// element of `axes`. The result `res` of the function call must have +// either the same dimensions as `a` or one less dimension. If `res` +// has one less dimension than `a`, a dimension is inserted before +// `axis`. The call to `func` is then repeated for each axis in `axes`, +// with `res` as the first argument. // -// ``(constant,)`` or ``constant`` is a shortcut for -// ``before = after = constant`` for all axes. +// Parameters +// ---------- +// func : function +// This function must take two arguments, `func(a, axis)`. +// a : array_like +// Input array. +// axes : array_like +// Axes over which `func` is applied; the elements must be integers. // -// Default is 0. -// end_values : sequence or scalar, optional -// Used in 'linear_ramp'. The values used for the ending value of the -// linear_ramp and that will form the edge of the padded array. +// Returns +// ------- +// apply_over_axis : ndarray +// The output array. The number of dimensions is the same as `a`, +// but the shape can be different. This depends on whether `func` +// changes the shape of its output with respect to its input. // -// ``((before_1, after_1), ... (before_N, after_N))`` unique end values -// for each axis. +// See Also +// -------- +// apply_along_axis : +// Apply a function to 1-D slices of an array along the given axis. // -// ``(before, after)`` or ``((before, after),)`` yields same before -// and after end values for each axis. +// Notes +// ----- +// This function is equivalent to tuple axis arguments to reorderable ufuncs +// with keepdims=True. Tuple axis arguments to ufuncs have been available since +// version 1.7.0. // -// ``(constant,)`` or ``constant`` is a shortcut for -// ``before = after = constant`` for all axes. +// Examples +// -------- +// >>> 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]]]) // -// Default is 0. -// reflect_type : {'even', 'odd'}, optional -// Used in 'reflect', and 'symmetric'. The 'even' style is the -// default with an unaltered reflection around the edge value. For -// the 'odd' style, the extended part of the array is created by -// subtracting the reflected values from two times the edge value. +// Sum over axes 0 and 2. The result has same number of dimensions +// as the original array: // -// Returns -// ------- -// pad : ndarray -// Padded array of rank equal to `array` with shape increased -// according to `pad_width`. +// >>> np.apply_over_axes(np.sum, a, [0,2]) +// array([[[ 60], +// [ 92], +// [124]]]) // -// Notes -// ----- -// For an array with rank greater than 1, some of the padding of later -// axes is calculated from padding of previous axes. This is easiest to -// think about with a rank 2 array where the corners of the padded array -// are calculated by using padded values from the first axis. +// Tuple axis arguments to ufuncs are equivalent: // -// The padding function, if used, should modify a rank 1 array in-place. It -// has the following signature:: +// >>> np.sum(a, axis=(0,2), keepdims=True) +// array([[[ 60], +// [ 92], +// [124]]]) // -// padding_func(vector, iaxis_pad_width, iaxis, kwargs) // -// where // -// vector : ndarray -// A rank 1 array already padded with zeros. Padded values are -// vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:]. -// iaxis_pad_width : tuple -// A 2-tuple of ints, iaxis_pad_width[0] represents the number of -// values padded at the beginning of vector where -// iaxis_pad_width[1] represents the number of values padded at -// the end of vector. -// iaxis : int -// The axis currently being calculated. -// kwargs : dict -// Any keyword arguments the function requires. +//go:linkname ApplyOverAxes py.apply_over_axes +func ApplyOverAxes(Func *py.Object, a *py.Object, axes *py.Object) *py.Object +// +// Check if the array is Fortran contiguous but *not* C contiguous. +// +// This function is obsolete and, because of changes due to relaxed stride +// checking, its return value for the same array may differ for versions +// of NumPy >= 1.10.0 and previous versions. If you only want to check if an +// array is Fortran contiguous use ``a.flags.f_contiguous`` instead. +// +// Parameters +// ---------- +// a : ndarray +// Input array. +// +// Returns +// ------- +// isfortran : bool +// Returns True if the array is Fortran contiguous but *not* C contiguous. +// // // Examples // -------- -// >>> import numpy as np -// >>> a = [1, 2, 3, 4, 5] -// >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6)) -// array([4, 4, 1, ..., 6, 6, 6]) -// -// >>> np.pad(a, (2, 3), 'edge') -// array([1, 1, 1, ..., 5, 5, 5]) // -// >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4)) -// array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4]) +// np.array allows to specify whether the array is written in C-contiguous +// order (last index varies the fastest), or FORTRAN-contiguous order in +// memory (first index varies the fastest). // -// >>> np.pad(a, (2,), 'maximum') -// array([5, 5, 1, 2, 3, 4, 5, 5, 5]) +// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') +// >>> a +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(a) +// False // -// >>> np.pad(a, (2,), 'mean') -// array([3, 3, 1, 2, 3, 4, 5, 3, 3]) +// >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') +// >>> b +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(b) +// True // -// >>> np.pad(a, (2,), 'median') -// array([3, 3, 1, 2, 3, 4, 5, 3, 3]) // -// >>> a = [[1, 2], [3, 4]] -// >>> np.pad(a, ((3, 2), (2, 3)), 'minimum') -// array([[1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1], -// [3, 3, 3, 4, 3, 3, 3], -// [1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1]]) +// The transpose of a C-ordered array is a FORTRAN-ordered array. // -// >>> a = [1, 2, 3, 4, 5] -// >>> np.pad(a, (2, 3), 'reflect') -// array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2]) +// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') +// >>> a +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> np.isfortran(a) +// False +// >>> b = a.T +// >>> b +// array([[1, 4], +// [2, 5], +// [3, 6]]) +// >>> np.isfortran(b) +// True // -// >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd') -// array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8]) +// C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. // -// >>> np.pad(a, (2, 3), 'symmetric') -// array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3]) +// >>> np.isfortran(np.array([1, 2], order='F')) +// False // -// >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd') -// array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7]) // -// >>> np.pad(a, (2, 3), 'wrap') -// array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3]) // -// >>> def pad_with(vector, pad_width, iaxis, kwargs): -// ... pad_value = kwargs.get('padder', 10) -// ... vector[:pad_width[0]] = pad_value -// ... vector[-pad_width[1]:] = pad_value -// >>> a = np.arange(6) -// >>> a = a.reshape((2, 3)) -// >>> np.pad(a, 2, pad_with) -// array([[10, 10, 10, 10, 10, 10, 10], -// [10, 10, 10, 10, 10, 10, 10], -// [10, 10, 0, 1, 2, 10, 10], -// [10, 10, 3, 4, 5, 10, 10], -// [10, 10, 10, 10, 10, 10, 10], -// [10, 10, 10, 10, 10, 10, 10]]) -// >>> np.pad(a, 2, pad_with, padder=100) -// array([[100, 100, 100, 100, 100, 100, 100], -// [100, 100, 100, 100, 100, 100, 100], -// [100, 100, 0, 1, 2, 100, 100], -// [100, 100, 3, 4, 5, 100, 100], -// [100, 100, 100, 100, 100, 100, 100], -// [100, 100, 100, 100, 100, 100, 100]]) +//go:linkname Isfortran py.isfortran +func Isfortran(a *py.Object) *py.Object // +// Compute the outer product of two vectors. // -//go:linkname Pad py.pad -func Pad(array *py.Object, padWidth *py.Object, mode *py.Object) *py.Object -// from_dlpack(x, /, *, device=None, copy=None) +// Given two vectors `a` and `b` of length ``M`` and ``N``, repsectively, +// the outer product [1]_ is:: // -// Create a NumPy array from an object implementing the ``__dlpack__`` -// protocol. Generally, the returned NumPy array is a view of the input -// object. See [1]_ and [2]_ for more details. +// [[a_0*b_0 a_0*b_1 ... a_0*b_{N-1} ] +// [a_1*b_0 . +// [ ... . +// [a_{M-1}*b_0 a_{M-1}*b_{N-1} ]] // // Parameters // ---------- -// x : object -// A Python object that implements the ``__dlpack__`` and -// ``__dlpack_device__`` methods. -// device : device, optional -// Device on which to place the created array. Default: ``None``. -// Must be ``"cpu"`` if passed which may allow importing an array -// that is not already CPU available. -// copy : bool, optional -// Boolean indicating whether or not to copy the input. If ``True``, -// the copy will be made. If ``False``, the function will never copy, -// and will raise ``BufferError`` in case a copy is deemed necessary. -// Passing it requests a copy from the exporter who may or may not -// implement the capability. -// If ``None``, the function will reuse the existing memory buffer if -// possible and copy otherwise. Default: ``None``. +// a : (M,) array_like +// First input vector. Input is flattened if +// not already 1-dimensional. +// b : (N,) array_like +// Second input vector. Input is flattened if +// not already 1-dimensional. +// out : (M, N) ndarray, optional +// A location where the result is stored // +// .. versionadded:: 1.9.0 // // Returns // ------- -// out : ndarray +// out : (M, N) ndarray +// ``out[i, j] = a[i] * b[j]`` +// +// See also +// -------- +// inner +// einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent. +// ufunc.outer : A generalization to dimensions other than 1D and other +// operations. ``np.multiply.outer(a.ravel(), b.ravel())`` +// is the equivalent. +// tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))`` +// is the equivalent. // // 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 +// .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd +// ed., Baltimore, MD, Johns Hopkins University Press, 1996, +// pg. 8. // // Examples // -------- -// >>> import torch # doctest: +SKIP -// >>> x = torch.arange(10) # doctest: +SKIP -// >>> # create a view of the torch tensor "x" in NumPy -// >>> y = np.from_dlpack(x) # doctest: +SKIP -// -//go:linkname FromDlpack py.from_dlpack -func FromDlpack(x *py.Object) *py.Object -// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Test element-wise for NaT (not a time) and return result as a boolean array. +// Make a (*very* coarse) grid for computing a Mandelbrot set: // -// Parameters -// ---------- -// x : array_like -// Input array with datetime or timedelta data type. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)) +// >>> rl +// array([[-2., -1., 0., 1., 2.], +// [-2., -1., 0., 1., 2.], +// [-2., -1., 0., 1., 2.], +// [-2., -1., 0., 1., 2.], +// [-2., -1., 0., 1., 2.]]) +// >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,))) +// >>> im +// array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j], +// [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j], +// [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], +// [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j], +// [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]]) +// >>> grid = rl + im +// >>> grid +// array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j], +// [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j], +// [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j], +// [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], +// [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) // -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaT, false otherwise. -// This is a scalar if `x` is a scalar. +// An example using a "vector" of letters: // -// See Also -// -------- -// isnan, isinf, isneginf, isposinf, isfinite +// >>> x = np.array(['a', 'b', 'c'], dtype=object) +// >>> np.outer(x, [1, 2, 3]) +// array([['a', 'aa', 'aaa'], +// ['b', 'bb', 'bbb'], +// ['c', 'cc', 'ccc']], dtype=object) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.isnat(np.datetime64("NaT")) -// True -// >>> np.isnat(np.datetime64("2016-01-01")) -// False -// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) -// array([ True, False]) // -//go:linkname Isnat py.isnat -func Isnat(x *py.Object, out *py.Object) *py.Object -// less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Return the truth value of (x1 < x2) element-wise. +//go:linkname Outer py.outer +func Outer(__llgo_va_list ...interface{}) *py.Object +// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the ceiling of the input, element-wise. +// +// The ceil of the scalar `x` is the smallest integer `i`, such that +// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. // // Parameters // ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Input data. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -17074,76 +15431,155 @@ func Isnat(x *py.Object, out *py.Object) *py.Object // // Returns // ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray or scalar +// The ceiling of each element in `x`, with `float` dtype. +// This is a scalar if `x` is a scalar. // // See Also // -------- -// greater, less_equal, greater_equal, equal, not_equal +// floor, trunc, rint, fix // // Examples // -------- -// >>> import numpy as np -// >>> np.less([1, 2], [2, 2]) -// array([ True, False]) +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.ceil(a) +// array([-1., -1., -0., 1., 2., 2., 2.]) // -// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. +//go:linkname Ceil py.ceil +func Ceil(x *py.Object, out *py.Object) *py.Object // -// >>> a = np.array([1, 2]) -// >>> b = np.array([2, 2]) -// >>> a < b -// array([ True, False]) +// Return the angle of the complex argument. // -//go:linkname Less py.less -func Less(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// Parameters +// ---------- +// z : array_like +// A complex number or sequence of complex numbers. +// deg : bool, optional +// Return angle in degrees if True, radians if False (default). // -// Return a scalar type which is common to the input arrays. +// Returns +// ------- +// angle : ndarray or scalar +// The counterclockwise angle from the positive real axis on the complex +// plane in the range ``(-pi, pi]``, with dtype as numpy.float64. // -// The return type will always be an inexact (i.e. floating point) scalar -// type, even if all the arrays are integer arrays. If one of the inputs is -// an integer array, the minimum precision type that is returned is a -// 64-bit floating point dtype. +// .. versionchanged:: 1.16.0 +// This function works on subclasses of ndarray like `ma.array`. // -// All input arrays except int64 and uint64 can be safely cast to the -// returned dtype without loss of information. +// See Also +// -------- +// arctan2 +// absolute +// +// Notes +// ----- +// Although the angle of the complex number 0 is undefined, ``numpy.angle(0)`` +// returns the value 0. +// +// Examples +// -------- +// >>> np.angle([1.0, 1.0j, 1+1j]) # in radians +// array([ 0. , 1.57079633, 0.78539816]) # may vary +// >>> np.angle(1+1j, deg=True) # in degrees +// 45.0 +// +// +// +//go:linkname Angle py.angle +func Angle(z *py.Object, deg *py.Object) *py.Object +// +// Load ASCII data from a file and return it in a record array. +// +// If ``usemask=False`` a standard `recarray` is returned, +// if ``usemask=True`` a MaskedRecords array is returned. // // Parameters // ---------- -// array1, array2, ... : ndarrays -// Input arrays. +// fname, kwargs : For a description of input parameters, see `genfromtxt`. +// +// See Also +// -------- +// numpy.genfromtxt : generic function +// +// Notes +// ----- +// By default, `dtype` is None, which means that the data-type of the output +// array will be determined from the data. +// +// +// +//go:linkname Recfromtxt py.recfromtxt +func Recfromtxt(fname *py.Object) *py.Object +// +// Return a new array with the specified shape. +// +// If the new array is larger than the original array, then the new +// array is filled with repeated copies of `a`. Note that this behavior +// is different from a.resize(new_shape) which fills with zeros instead +// of repeated copies of `a`. +// +// Parameters +// ---------- +// a : array_like +// Array to be resized. +// +// new_shape : int or tuple of int +// Shape of resized array. // // Returns // ------- -// out : data type code -// Data type code. +// reshaped_array : ndarray +// The new array is formed from the data in the old array, repeated +// if necessary to fill out the required number of elements. The +// data are repeated iterating over the array in C-order. // // See Also // -------- -// dtype, mintypecode +// numpy.reshape : Reshape an array without changing the total size. +// numpy.pad : Enlarge and pad an array. +// numpy.repeat : Repeat elements of an array. +// ndarray.resize : resize an array in-place. +// +// Notes +// ----- +// When the total size of the array does not change `~numpy.reshape` should +// be used. In most other cases either indexing (to reduce the size) +// or padding (to increase the size) may be a more appropriate solution. +// +// Warning: This functionality does **not** consider axes separately, +// i.e. it does not apply interpolation/extrapolation. +// It fills the return array with the required number of elements, iterating +// over `a` in C-order, disregarding axes (and cycling back from the start if +// the new shape is larger). This functionality is therefore not suitable to +// resize images, or data where each axis represents a separate and distinct +// entity. // // Examples // -------- -// >>> np.common_type(np.arange(2, dtype=np.float32)) -// -// >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2)) -// -// >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0])) -// +// >>> a=np.array([[0,1],[2,3]]) +// >>> np.resize(a,(2,3)) +// array([[0, 1, 2], +// [3, 0, 1]]) +// >>> np.resize(a,(1,4)) +// array([[0, 1, 2, 3]]) +// >>> np.resize(a,(2,4)) +// array([[0, 1, 2, 3], +// [0, 1, 2, 3]]) // // // -//go:linkname CommonType py.common_type -func CommonType(__llgo_va_list ...interface{}) *py.Object -// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Resize py.resize +func Resize(a *py.Object, newShape *py.Object) *py.Object +// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Convert angles from degrees to radians. +// Test element-wise for NaT (not a time) and return result as a boolean array. +// +// .. versionadded:: 1.13.0 // // Parameters // ---------- // x : array_like -// Angles in degrees. +// Input array with datetime or timedelta data type. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -17162,35 +15598,33 @@ func CommonType(__llgo_va_list ...interface{}) *py.Object // // Returns // ------- -// y : ndarray -// The corresponding angle in radians. +// y : ndarray or bool +// True where ``x`` is NaT, false otherwise. // This is a scalar if `x` is a scalar. // // See Also // -------- -// rad2deg : Convert angles from radians to degrees. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// ``deg2rad(x)`` is ``x * pi / 180``. +// isnan, isinf, isneginf, isposinf, isfinite // // Examples // -------- -// >>> import numpy as np -// >>> np.deg2rad(180) -// 3.1415926535897931 +// >>> np.isnat(np.datetime64("NaT")) +// True +// >>> np.isnat(np.datetime64("2016-01-01")) +// False +// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) +// array([ True, False]) // -//go:linkname Deg2rad py.deg2rad -func Deg2rad(x *py.Object, out *py.Object) *py.Object -// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Isnat py.isnat +func Isnat(x *py.Object, out *py.Object) *py.Object +// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Return (x1 != x2) element-wise. +// Compute the truth value of x1 OR x2 element-wise. // // Parameters // ---------- // x1, x2 : array_like -// Input arrays. +// Logical OR is applied to the elements of `x1` and `x2`. // If ``x1.shape != x2.shape``, they must be broadcastable to a common // shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional @@ -17211,161 +15645,45 @@ func Deg2rad(x *py.Object, out *py.Object) *py.Object // // Returns // ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. +// y : ndarray or bool +// Boolean result of the logical OR operation applied to the elements +// of `x1` and `x2`; the shape is determined by broadcasting. // This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// equal, greater, greater_equal, less, less_equal +// logical_and, logical_not, logical_xor +// bitwise_or // // Examples // -------- -// >>> import numpy as np -// >>> np.not_equal([1.,2.], [1., 3.]) -// array([False, True]) -// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) -// array([[False, True], -// [False, True]]) -// -// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on -// ndarrays. -// -// >>> a = np.array([1., 2.]) -// >>> b = np.array([1., 3.]) -// >>> a != b -// array([False, True]) -// -//go:linkname NotEqual py.not_equal -func NotEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return the sum along diagonals of the array. -// -// If `a` is 2-D, the sum along its diagonal with the given offset -// is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i. -// -// If `a` has more than two dimensions, then the axes specified by axis1 and -// axis2 are used to determine the 2-D sub-arrays whose traces are returned. -// The shape of the resulting array is the same as that of `a` with `axis1` -// and `axis2` removed. -// -// Parameters -// ---------- -// a : array_like -// Input array, from which the diagonals are taken. -// offset : int, optional -// Offset of the diagonal from the main diagonal. Can be both positive -// and negative. Defaults to 0. -// axis1, axis2 : int, optional -// Axes to be used as the first and second axis of the 2-D sub-arrays -// from which the diagonals should be taken. Defaults are the first two -// axes of `a`. -// dtype : dtype, optional -// Determines the data-type of the returned array and of the accumulator -// where the elements are summed. If dtype has the value None and `a` is -// of integer type of precision less than the default integer -// precision, then the default integer precision is used. Otherwise, -// the precision is the same as that of `a`. -// out : ndarray, optional -// Array into which the output is placed. Its type is preserved and -// it must be of the right shape to hold the output. -// -// Returns -// ------- -// sum_along_diagonals : ndarray -// If `a` is 2-D, the sum along the diagonal is returned. If `a` has -// larger dimensions, then an array of sums along diagonals is returned. -// -// See Also -// -------- -// diag, diagonal, diagflat -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.trace(np.eye(3)) -// 3.0 -// >>> a = np.arange(8).reshape((2,2,2)) -// >>> np.trace(a) -// array([6, 8]) -// -// >>> a = np.arange(24).reshape((2,2,2,3)) -// >>> np.trace(a).shape -// (2, 3) -// -// -// -//go:linkname Trace py.trace -func Trace(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Object, dtype *py.Object, out *py.Object) *py.Object -// -// Return the elements of an array that satisfy some condition. -// -// This is equivalent to ``np.compress(ravel(condition), ravel(arr))``. If -// `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``. -// -// Note that `place` does the exact opposite of `extract`. -// -// Parameters -// ---------- -// condition : array_like -// An array whose nonzero or True entries indicate the elements of `arr` -// to extract. -// arr : array_like -// Input array of the same size as `condition`. -// -// Returns -// ------- -// extract : ndarray -// Rank 1 array of values from `arr` where `condition` is True. -// -// See Also -// -------- -// take, put, copyto, compress, place -// -// Examples -// -------- -// >>> import numpy as np -// >>> arr = np.arange(12).reshape((3, 4)) -// >>> arr -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11]]) -// >>> condition = np.mod(arr, 3)==0 -// >>> condition -// array([[ True, False, False, True], -// [False, False, True, False], -// [False, True, False, False]]) -// >>> np.extract(condition, arr) -// array([0, 3, 6, 9]) -// -// -// If `condition` is boolean: -// -// >>> arr[condition] -// array([0, 3, 6, 9]) +// >>> np.logical_or(True, False) +// True +// >>> np.logical_or([True, False], [False, False]) +// array([ True, False]) // +// >>> x = np.arange(5) +// >>> np.logical_or(x < 1, x > 3) +// array([ True, False, False, False, True]) // +// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on +// boolean ndarrays. // -//go:linkname Extract py.extract -func Extract(condition *py.Object, arr *py.Object) *py.Object -// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> a = np.array([True, False]) +// >>> b = np.array([False, False]) +// >>> a | b +// array([ True, False]) // -// Element-wise maximum of array elements. +//go:linkname LogicalOr py.logical_or +func LogicalOr(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. +// Trigonometric sine, element-wise. // // Parameters // ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -17384,1376 +15702,1326 @@ func Extract(condition *py.Object, arr *py.Object) *py.Object // // Returns // ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. +// y : array_like +// The sine of each element of x. +// This is a scalar if `x` is a scalar. // // See Also // -------- -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// minimum, amin, nanmin +// arcsin, sinh, cos // // Notes // ----- -// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. +// The sine is one of the fundamental functions of trigonometry (the +// mathematical study of triangles). Consider a circle of radius 1 +// centered on the origin. A ray comes in from the :math:`+x` axis, makes +// an angle at the origin (measured counter-clockwise from that axis), and +// departs from the origin. The :math:`y` coordinate of the outgoing +// ray's intersection with the unit circle is the sine of that angle. It +// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The +// function has zeroes where the angle is a multiple of :math:`\pi`. +// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. +// The numerous properties of the sine and related functions are included +// in any standard trigonometry text. // // Examples // -------- -// >>> import numpy as np -// >>> np.fmax([2, 3, 4], [1, 5, 2]) -// array([ 2, 5, 4]) +// Print sine of one angle: // -// >>> np.fmax(np.eye(2), [0.5, 2]) -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) +// >>> np.sin(np.pi/2.) +// 1.0 // -// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) +// Print sines of an array of angles given in degrees: // -//go:linkname Fmax py.fmax -func Fmax(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) +// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) // -// Returns True if first argument is a typecode lower/equal in type hierarchy. +// Plot the sine function: // -// This is like the builtin :func:`issubclass`, but for `dtype`\ s. +// >>> import matplotlib.pylab as plt +// >>> x = np.linspace(-np.pi, np.pi, 201) +// >>> plt.plot(x, np.sin(x)) +// >>> plt.xlabel('Angle [rad]') +// >>> plt.ylabel('sin(x)') +// >>> plt.axis('tight') +// >>> plt.show() +// +//go:linkname Sin py.sin +func Sin(x *py.Object, out *py.Object) *py.Object +// +// Return the indices of the bins to which each value in input array belongs. +// +// ========= ============= ============================ +// `right` order of bins returned index `i` satisfies +// ========= ============= ============================ +// ``False`` increasing ``bins[i-1] <= x < bins[i]`` +// ``True`` increasing ``bins[i-1] < x <= bins[i]`` +// ``False`` decreasing ``bins[i-1] > x >= bins[i]`` +// ``True`` decreasing ``bins[i-1] >= x > bins[i]`` +// ========= ============= ============================ +// +// If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is +// returned as appropriate. // // Parameters // ---------- -// arg1, arg2 : dtype_like -// `dtype` or object coercible to one +// x : array_like +// Input array to be binned. Prior to NumPy 1.10.0, this array had to +// be 1-dimensional, but can now have any shape. +// bins : array_like +// Array of bins. It has to be 1-dimensional and monotonic. +// right : bool, optional +// Indicating whether the intervals include the right or the left bin +// edge. Default behavior is (right==False) indicating that the interval +// does not include the right edge. The left bin end is open in this +// case, i.e., bins[i-1] <= x < bins[i] is the default behavior for +// monotonically increasing bins. // // Returns // ------- -// out : bool +// indices : ndarray of ints +// Output array of indices, of same shape as `x`. +// +// Raises +// ------ +// ValueError +// If `bins` is not monotonic. +// TypeError +// If the type of the input is complex. // // See Also // -------- -// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. +// bincount, histogram, unique, searchsorted // -// Examples -// -------- -// `issubdtype` can be used to check the type of arrays: +// Notes +// ----- +// If values in `x` are such that they fall outside the bin range, +// attempting to index `bins` with the indices that `digitize` returns +// will result in an IndexError. // -// >>> ints = np.array([1, 2, 3], dtype=np.int32) -// >>> np.issubdtype(ints.dtype, np.integer) -// True -// >>> np.issubdtype(ints.dtype, np.floating) -// False +// .. versionadded:: 1.10.0 // -// >>> floats = np.array([1, 2, 3], dtype=np.float32) -// >>> np.issubdtype(floats.dtype, np.integer) -// False -// >>> np.issubdtype(floats.dtype, np.floating) -// True +// `np.digitize` is implemented in terms of `np.searchsorted`. This means +// that a binary search is used to bin the values, which scales much better +// for larger number of bins than the previous linear search. It also removes +// the requirement for the input array to be 1-dimensional. // -// Similar types of different sizes are not subdtypes of each other: +// For monotonically _increasing_ `bins`, the following are equivalent:: // -// >>> np.issubdtype(np.float64, np.float32) -// False -// >>> np.issubdtype(np.float32, np.float64) -// False +// np.digitize(x, bins, right=True) +// np.searchsorted(bins, x, side='left') // -// but both are subtypes of `floating`: +// Note that as the order of the arguments are reversed, the side must be too. +// The `searchsorted` call is marginally faster, as it does not do any +// monotonicity checks. Perhaps more importantly, it supports all dtypes. // -// >>> np.issubdtype(np.float64, np.floating) -// True -// >>> np.issubdtype(np.float32, np.floating) -// True +// Examples +// -------- +// >>> x = np.array([0.2, 6.4, 3.0, 1.6]) +// >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0]) +// >>> inds = np.digitize(x, bins) +// >>> inds +// array([1, 4, 3, 2]) +// >>> for n in range(x.size): +// ... print(bins[inds[n]-1], "<=", x[n], "<", bins[inds[n]]) +// ... +// 0.0 <= 0.2 < 1.0 +// 4.0 <= 6.4 < 10.0 +// 2.5 <= 3.0 < 4.0 +// 1.0 <= 1.6 < 2.5 // -// For convenience, dtype-like objects are allowed too: +// >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.]) +// >>> bins = np.array([0, 5, 10, 15, 20]) +// >>> np.digitize(x,bins,right=True) +// array([1, 2, 3, 4, 4]) +// >>> np.digitize(x,bins,right=False) +// array([1, 3, 3, 4, 5]) // -// >>> np.issubdtype('S1', np.bytes_) -// True -// >>> np.issubdtype('i4', np.signedinteger) -// True // +//go:linkname Digitize py.digitize +func Digitize(x *py.Object, bins *py.Object, right *py.Object) *py.Object // +// Construct an array by repeating A the number of times given by reps. // -//go:linkname Issubdtype py.issubdtype -func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object +// If `reps` has length ``d``, the result will have dimension of +// ``max(d, A.ndim)``. // -// Compute the histogram of a dataset. +// If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new +// axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, +// or shape (1, 1, 3) for 3-D replication. If this is not the desired +// behavior, promote `A` to d-dimensions manually before calling this +// function. // -// Parameters -// ---------- -// a : array_like -// Input data. The histogram is computed over the flattened array. -// bins : int or sequence of scalars or str, optional -// If `bins` is an int, it defines the number of equal-width -// bins in the given range (10, by default). If `bins` is a -// sequence, it defines a monotonically increasing array of bin edges, -// including the rightmost edge, allowing for non-uniform bin widths. +// If ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it. +// Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as +// (1, 1, 2, 2). // -// If `bins` is a string, it defines the method used to calculate the -// optimal bin width, as defined by `histogram_bin_edges`. +// Note : Although tile may be used for broadcasting, it is strongly +// recommended to use numpy's broadcasting operations and functions. // -// range : (float, float), optional -// The lower and upper range of the bins. If not provided, range -// is simply ``(a.min(), a.max())``. Values outside the range are -// ignored. The first element of the range must be less than or -// equal to the second. `range` affects the automatic bin -// 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. -// 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 -// (instead of 1). If `density` is True, the weights are -// normalized, so that the integral of the density over the range -// remains 1. -// Please note that the ``dtype`` of `weights` will also become the -// ``dtype`` of the returned accumulator (`hist`), so it must be -// large enough to hold accumulated values as well. -// density : bool, optional -// If ``False``, the result will contain the number of samples in -// each bin. If ``True``, the result is the value of the -// probability *density* function at the bin, normalized such that -// the *integral* over the range is 1. Note that the sum of the -// histogram values will not be equal to 1 unless bins of unity -// width are chosen; it is not a probability *mass* function. +// Parameters +// ---------- +// A : array_like +// The input array. +// reps : array_like +// The number of repetitions of `A` along each axis. // // Returns // ------- -// hist : array -// The values of the histogram. See `density` and `weights` for a -// description of the possible semantics. If `weights` are given, -// ``hist.dtype`` will be taken from `weights`. -// bin_edges : array of dtype float -// Return the bin edges ``(length(hist)+1)``. -// +// c : ndarray +// The tiled output array. // // See Also // -------- -// histogramdd, bincount, searchsorted, digitize, histogram_bin_edges +// repeat : Repeat elements of an array. +// broadcast_to : Broadcast an array to a new shape // -// Notes -// ----- -// All but the last (righthand-most) bin is half-open. In other words, -// if `bins` is:: +// Examples +// -------- +// >>> a = np.array([0, 1, 2]) +// >>> np.tile(a, 2) +// array([0, 1, 2, 0, 1, 2]) +// >>> np.tile(a, (2, 2)) +// array([[0, 1, 2, 0, 1, 2], +// [0, 1, 2, 0, 1, 2]]) +// >>> np.tile(a, (2, 1, 2)) +// array([[[0, 1, 2, 0, 1, 2]], +// [[0, 1, 2, 0, 1, 2]]]) // -// [1, 2, 3, 4] +// >>> b = np.array([[1, 2], [3, 4]]) +// >>> np.tile(b, 2) +// array([[1, 2, 1, 2], +// [3, 4, 3, 4]]) +// >>> np.tile(b, (2, 1)) +// array([[1, 2], +// [3, 4], +// [1, 2], +// [3, 4]]) // -// then the first bin is ``[1, 2)`` (including 1, but excluding 2) and -// the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which -// *includes* 4. +// >>> c = np.array([1,2,3,4]) +// >>> np.tile(c,(4,1)) +// array([[1, 2, 3, 4], +// [1, 2, 3, 4], +// [1, 2, 3, 4], +// [1, 2, 3, 4]]) // // -// Examples -// -------- -// >>> import numpy as np -// >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3]) -// (array([0, 2, 1]), array([0, 1, 2, 3])) -// >>> np.histogram(np.arange(4), bins=np.arange(5), density=True) -// (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4])) -// >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3]) -// (array([1, 4, 1]), array([0, 1, 2, 3])) +//go:linkname Tile py.tile +func Tile(A *py.Object, reps *py.Object) *py.Object // -// >>> a = np.arange(5) -// >>> hist, bin_edges = np.histogram(a, density=True) -// >>> hist -// array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5]) -// >>> hist.sum() -// 2.4999999999999996 -// >>> np.sum(hist * np.diff(bin_edges)) -// 1.0 +// Returns pointers to the end-points of an array. // -// Automated Bin Selection Methods example, using 2 peak random data -// with 2000 points. +// Parameters +// ---------- +// a : ndarray +// Input array. It must conform to the Python-side of the array +// interface. // -// .. plot:: -// :include-source: +// Returns +// ------- +// (low, high) : tuple of 2 integers +// The first integer is the first byte of the array, the second +// integer is just past the last byte of the array. If `a` is not +// contiguous it will not use every byte between the (`low`, `high`) +// values. // -// import matplotlib.pyplot as plt -// import numpy as np +// Examples +// -------- +// >>> I = np.eye(2, dtype='f'); I.dtype +// dtype('float32') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True +// >>> I = np.eye(2); I.dtype +// dtype('float64') +// >>> low, high = np.byte_bounds(I) +// >>> high - low == I.size*I.itemsize +// True // -// rng = np.random.RandomState(10) # deterministic random data -// a = np.hstack((rng.normal(size=1000), -// rng.normal(loc=5, scale=2, size=1000))) -// plt.hist(a, bins='auto') # arguments are passed to np.histogram -// plt.title("Histogram with 'auto' bins") -// plt.show() // // +//go:linkname ByteBounds py.byte_bounds +func ByteBounds(a *py.Object) *py.Object // -//go:linkname Histogram py.histogram -func Histogram(a *py.Object, bins *py.Object, range_ *py.Object, density *py.Object, weights *py.Object) *py.Object +// Return a partitioned copy of an array. // -// Save an array to a text file. +// 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 +// 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 // // Parameters // ---------- -// fname : filename, file handle or pathlib.Path -// If the filename ends in ``.gz``, the file is automatically saved in -// compressed gzip format. `loadtxt` understands gzipped files -// transparently. -// X : 1D or 2D array_like -// Data to be saved to a text file. -// fmt : str or sequence of strs, optional -// A single format (%10.5f), a sequence of formats, or a -// multi-format string, e.g. 'Iteration %d -- %10.5f', in which -// case `delimiter` is ignored. For complex `X`, the legal options -// for `fmt` are: +// a : array_like +// Array to be sorted. +// kth : int or sequence of ints +// Element index to partition by. The k-th value of the element +// will be in its final sorted position and all smaller elements +// will be moved before it and all equal or greater 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 elements +// indexed by k-th of them into their sorted position at once. // -// * a single specifier, ``fmt='%.4e'``, resulting in numbers formatted -// like ``' (%s+%sj)' % (fmt, fmt)`` -// * a full string specifying every real and imaginary part, e.g. -// ``' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'`` for 3 columns -// * a list of specifiers, one per column - in this case, the real -// and imaginary part must have separate specifiers, -// e.g. ``['%.3e + %.3ej', '(%.15e%+.15ej)']`` for 2 columns -// delimiter : str, optional -// String or character separating columns. -// newline : str, optional -// String or character separating lines. -// header : str, optional -// String that will be written at the beginning of the file. -// footer : str, optional -// String that will be written at the end of the file. -// comments : str, optional -// String that will be prepended to the ``header`` and ``footer`` strings, -// to mark them as comments. Default: '# ', as expected by e.g. -// ``numpy.loadtxt``. -// encoding : {None, str}, optional -// Encoding used to encode the outputfile. Does not apply to output -// streams. If the encoding is something other than 'bytes' or 'latin1' -// you will not be able to load the file in NumPy versions < 1.14. Default -// is 'latin1'. +// .. deprecated:: 1.22.0 +// Passing booleans as index is deprecated. +// axis : int or None, optional +// Axis along which to sort. If None, the array is flattened before +// sorting. The default is -1, which sorts along the last axis. +// kind : {'introselect'}, optional +// Selection algorithm. Default is 'introselect'. +// order : str or list of str, optional +// When `a` is an array with fields defined, this argument +// specifies which fields to compare first, second, etc. A single +// field can be specified as a string. Not all fields need be +// specified, but unspecified fields will still be used, in the +// order in which they come up in the dtype, to break ties. +// +// Returns +// ------- +// partitioned_array : ndarray +// Array of the same type and shape as `a`. // // See Also // -------- -// save : Save an array to a binary file in NumPy ``.npy`` format -// savez : Save several arrays into an uncompressed ``.npz`` archive -// savez_compressed : Save several arrays into a compressed ``.npz`` archive +// ndarray.partition : Method to sort an array in-place. +// argpartition : Indirect partition. +// sort : Full sorting // // Notes // ----- -// Further explanation of the `fmt` parameter -// (``%[flag]width[.precision]specifier``): -// -// flags: -// ``-`` : left justify +// The various selection algorithms are characterized by their average +// speed, worst case performance, work space size, and whether they are +// stable. A stable sort keeps items with the same key in the same +// relative order. The available algorithms have the following +// properties: // -// ``+`` : Forces to precede result with + or -. +// ================= ======= ============= ============ ======= +// kind speed worst case work space stable +// ================= ======= ============= ============ ======= +// 'introselect' 1 O(n) 0 no +// ================= ======= ============= ============ ======= // -// ``0`` : Left pad the number with zeros instead of space (see width). +// All the partition algorithms make temporary copies of the data when +// partitioning along any but the last axis. Consequently, +// partitioning along the last axis is faster and uses less space than +// partitioning along any other axis. // -// width: -// Minimum number of characters to be printed. The value is not truncated -// if it has more characters. -// -// precision: -// - For integer specifiers (eg. ``d,i,o,x``), the minimum number of -// digits. -// - For ``e, E`` and ``f`` specifiers, the number of digits to print -// after the decimal point. -// - For ``g`` and ``G``, the maximum number of significant digits. -// - For ``s``, the maximum number of characters. -// -// specifiers: -// ``c`` : character +// The sort order for complex numbers is lexicographic. If both the +// real and imaginary parts are non-nan then the order is determined by +// the real parts except when they are equal, in which case the order +// is determined by the imaginary parts. // -// ``d`` or ``i`` : signed decimal integer +// Examples +// -------- +// >>> 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]) // -// ``e`` or ``E`` : scientific notation with ``e`` or ``E``. +// ``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:: // -// ``f`` : decimal floating point +// [0, 1, 2, 1], [2], [5, 2, 3, 3, 6, 7, 7, 7, 7] // -// ``g,G`` : use the shorter of ``e,E`` or ``f`` +// The next example shows the use of multiple values passed to `kth`. // -// ``o`` : signed octal +// >>> p2 = np.partition(a, (4, 8)) +// >>> p2 +// array([0, 1, 2, 1, 2, 3, 3, 2, 5, 6, 7, 7, 7, 7]) // -// ``s`` : string of characters +// ``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:: // -// ``u`` : unsigned decimal integer +// [0, 1, 2, 1], [2], [3, 3, 2], [5], [6, 7, 7, 7, 7] // -// ``x,X`` : unsigned hexadecimal integer // -// This explanation of ``fmt`` is not complete, for an exhaustive -// specification see [1]_. +//go:linkname Partition py.partition +func Partition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object +// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// References -// ---------- -// .. [1] `Format Specification Mini-Language -// `_, -// Python Documentation. +// Return the complex conjugate, element-wise. // -// Examples -// -------- -// >>> import numpy as np -// >>> x = y = z = np.arange(0.0,5.0,1.0) -// >>> np.savetxt('test.out', x, delimiter=',') # X is an array -// >>> np.savetxt('test.out', (x,y,z)) # x,y,z equal sized 1D arrays -// >>> np.savetxt('test.out', x, fmt='%1.4e') # use exponential notation +// The complex conjugate of a complex number is obtained by changing the +// sign of its imaginary part. // +// Parameters +// ---------- +// x : array_like +// Input value. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // +// Returns +// ------- +// y : ndarray +// The complex conjugate of `x`, with same dtype as `y`. +// This is a scalar if `x` is a scalar. // -//go:linkname Savetxt py.savetxt -func Savetxt(__llgo_va_list ...interface{}) *py.Object +// Notes +// ----- +// `conj` is an alias for `conjugate`: // -// Kronecker product of two arrays. +// >>> np.conj is np.conjugate +// True // -// Computes the Kronecker product, a composite array made of blocks of the -// second array scaled by the first. +// Examples +// -------- +// >>> np.conjugate(1+2j) +// (1-2j) // -// Parameters -// ---------- -// a, b : array_like +// >>> x = np.eye(2) + 1j * np.eye(2) +// >>> np.conjugate(x) +// array([[ 1.-1.j, 0.-0.j], +// [ 0.-0.j, 1.-1.j]]) // -// Returns -// ------- -// out : ndarray +//go:linkname Conj py.conj +func Conj(__llgo_va_list ...interface{}) *py.Object +// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// See Also -// -------- -// outer : The outer product +// Calculate the exponential of all elements in the input array. // -// Notes -// ----- -// The function assumes that the number of dimensions of `a` and `b` -// are the same, if necessary prepending the smallest with ones. -// If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``, -// the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``. -// The elements are products of elements from `a` and `b`, organized -// explicitly by:: +// Parameters +// ---------- +// x : array_like +// Input values. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN] +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise exponential of `x`. +// This is a scalar if `x` is a scalar. // -// where:: +// See Also +// -------- +// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. +// exp2 : Calculate ``2**x`` for all elements in the array. // -// kt = it * st + jt, t = 0,...,N +// Notes +// ----- +// The irrational number ``e`` is also known as Euler's number. It is +// approximately 2.718281, and is the base of the natural logarithm, +// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, +// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. // -// In the common 2-D case (N=1), the block structure can be visualized:: +// For complex arguments, ``x = a + ib``, we can write +// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already +// known (it is the real argument, described above). The second term, +// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with +// magnitude 1 and a periodic phase. // -// [[ a[0,0]*b, a[0,1]*b, ... , a[0,-1]*b ], -// [ ... ... ], -// [ a[-1,0]*b, a[-1,1]*b, ... , a[-1,-1]*b ]] +// References +// ---------- +// .. [1] Wikipedia, "Exponential function", +// https://en.wikipedia.org/wiki/Exponential_function +// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions +// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, +// https://personal.math.ubc.ca/~cbm/aands/page_69.htm // +// Examples +// -------- +// Plot the magnitude and phase of ``exp(x)`` in the complex plane: // -// Examples -// -------- -// >>> import numpy as np -// >>> np.kron([1,10,100], [5,6,7]) -// array([ 5, 6, 7, ..., 500, 600, 700]) -// >>> np.kron([5,6,7], [1,10,100]) -// array([ 5, 50, 500, ..., 7, 70, 700]) +// >>> import matplotlib.pyplot as plt // -// >>> np.kron(np.eye(2), np.ones((2,2))) -// array([[1., 1., 0., 0.], -// [1., 1., 0., 0.], -// [0., 0., 1., 1.], -// [0., 0., 1., 1.]]) +// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) +// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane +// >>> out = np.exp(xx) // -// >>> a = np.arange(100).reshape((2,5,2,5)) -// >>> b = np.arange(24).reshape((2,3,4)) -// >>> c = np.kron(a,b) -// >>> c.shape -// (2, 10, 6, 20) -// >>> I = (1,3,0,2) -// >>> J = (0,2,1) -// >>> J1 = (0,) + J # extend to ndim=4 -// >>> S1 = (1,) + b.shape -// >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1)) -// >>> c[K] == a[I]*b[J] -// True +// >>> plt.subplot(121) +// >>> plt.imshow(np.abs(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') +// >>> plt.title('Magnitude of exp(x)') // +// >>> plt.subplot(122) +// >>> plt.imshow(np.angle(out), +// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') +// >>> plt.title('Phase (angle) of exp(x)') +// >>> plt.show() // +//go:linkname Exp py.exp +func Exp(x *py.Object, out *py.Object) *py.Object +// frompyfunc(func, /, nin, nout, *[, identity]) // -//go:linkname Kron py.kron -func Kron(a *py.Object, b *py.Object) *py.Object +// Takes an arbitrary Python function and returns a NumPy ufunc. // -// Upper triangle of an array. +// Can be used, for example, to add broadcasting to a built-in Python +// function (see Examples section). // -// 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. +// Parameters +// ---------- +// func : Python function object +// An arbitrary Python function. +// nin : int +// The number of input arguments. +// nout : int +// The number of objects returned by `func`. +// identity : object, optional +// The value to use for the `~numpy.ufunc.identity` attribute of the resulting +// object. If specified, this is equivalent to setting the underlying +// C ``identity`` field to ``PyUFunc_IdentityValue``. +// If omitted, the identity is set to ``PyUFunc_None``. Note that this is +// _not_ equivalent to setting the identity to ``None``, which implies the +// operation is reorderable. // -// Please refer to the documentation for `tril` for further details. +// Returns +// ------- +// out : ufunc +// Returns a NumPy universal function (``ufunc``) object. // // See Also // -------- -// tril : lower triangle of an array +// vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy. +// +// Notes +// ----- +// The returned ufunc always returns PyObject arrays. // // Examples // -------- -// >>> import numpy as np -// >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1) -// array([[ 1, 2, 3], -// [ 4, 5, 6], -// [ 0, 8, 9], -// [ 0, 0, 12]]) +// Use frompyfunc to add broadcasting to the Python function ``oct``: // -// >>> np.triu(np.arange(3*4*5).reshape(3, 4, 5)) -// array([[[ 0, 1, 2, 3, 4], -// [ 0, 6, 7, 8, 9], -// [ 0, 0, 12, 13, 14], -// [ 0, 0, 0, 18, 19]], -// [[20, 21, 22, 23, 24], -// [ 0, 26, 27, 28, 29], -// [ 0, 0, 32, 33, 34], -// [ 0, 0, 0, 38, 39]], -// [[40, 41, 42, 43, 44], -// [ 0, 46, 47, 48, 49], -// [ 0, 0, 52, 53, 54], -// [ 0, 0, 0, 58, 59]]]) +// >>> oct_array = np.frompyfunc(oct, 1, 1) +// >>> oct_array(np.array((10, 30, 100))) +// array(['0o12', '0o36', '0o144'], dtype=object) +// >>> np.array((oct(10), oct(30), oct(100))) # for comparison +// array(['0o12', '0o36', '0o144'], dtype='`. // -// Numerical positive, element-wise. +// Returns +// ------- +// out : ndarray or scalar +// Output array, element-wise comparison of `x1` and `x2`. +// Typically of type bool, unless ``dtype=object`` is passed. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// greater, less_equal, greater_equal, equal, not_equal +// +// Examples +// -------- +// >>> np.less([1, 2], [2, 2]) +// array([ True, False]) +// +// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. +// +// >>> a = np.array([1, 2]) +// >>> b = np.array([2, 2]) +// >>> a < b +// array([ True, False]) +// +//go:linkname Less py.less +func Less(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute tangent element-wise. +// +// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. // // Parameters // ---------- -// x : array_like or scalar +// x : array_like // Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // // Returns // ------- -// y : ndarray or scalar -// Returned array or scalar: `y = +x`. +// y : ndarray +// The corresponding tangent values. // This is a scalar if `x` is a scalar. // // Notes // ----- -// Equivalent to `x.copy()`, but only defined for types that support -// arithmetic. +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972. // // Examples // -------- -// >>> import numpy as np -// -// >>> x1 = np.array(([1., -1.])) -// >>> np.positive(x1) -// array([ 1., -1.]) -// -// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> +x1 -// array([ 1., -1.]) -// -//go:linkname Positive py.positive -func Positive(x *py.Object, out *py.Object) *py.Object -// -// Split an array into a sequence of arrays along the given axis. +// >>> from math import pi +// >>> np.tan(np.array([-pi,pi/2,pi])) +// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) +// >>> +// >>> # Example of providing the optional output parameter illustrating +// >>> # that what is returned is a reference to said parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.cos([0.1], out1) +// >>> out2 is out1 +// True +// >>> +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) // -// The ``axis`` parameter specifies the dimension along which the array will -// be split. For example, if ``axis=0`` (the default) it will be the first -// dimension and if ``axis=-1`` it will be the last dimension. +//go:linkname Tan py.tan +func Tan(x *py.Object, out *py.Object) *py.Object // -// The result is a tuple of arrays split along ``axis``. +// Evaluate a piecewise-defined function. // -// .. versionadded:: 2.1.0 +// Given a set of conditions and corresponding functions, evaluate each +// function on the input data wherever its condition is true. // // Parameters // ---------- -// x : ndarray -// The array to be unstacked. -// axis : int, optional -// Axis along which the array will be split. Default: ``0``. +// x : ndarray or scalar +// The input domain. +// condlist : list of bool arrays or bool scalars +// Each boolean array corresponds to a function in `funclist`. Wherever +// `condlist[i]` is True, `funclist[i](x)` is used as the output value. +// +// Each boolean array in `condlist` selects a piece of `x`, +// and should therefore be of the same shape as `x`. +// +// The length of `condlist` must correspond to that of `funclist`. +// If one extra function is given, i.e. if +// ``len(funclist) == len(condlist) + 1``, then that extra function +// is the default value, used wherever all conditions are false. +// funclist : list of callables, f(x,*args,**kw), or scalars +// Each function is evaluated over `x` wherever its corresponding +// condition is True. It should take a 1d array as input and give an 1d +// array or a scalar value as output. If, instead of a callable, +// a scalar is provided then a constant function (``lambda x: scalar``) is +// assumed. +// args : tuple, optional +// Any further arguments given to `piecewise` are passed to the functions +// upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then +// each function is called as ``f(x, 1, 'a')``. +// kw : dict, optional +// Keyword arguments used in calling `piecewise` are passed to the +// functions upon execution, i.e., if called +// ``piecewise(..., ..., alpha=1)``, then each function is called as +// ``f(x, alpha=1)``. // // Returns // ------- -// unstacked : tuple of ndarrays -// The unstacked arrays. +// out : ndarray +// The output is the same shape and type as x and is found by +// calling the functions in `funclist` on the appropriate portions of `x`, +// as defined by the boolean arrays in `condlist`. Portions not covered +// by any condition have a default value of 0. +// // // See Also // -------- -// stack : Join a sequence of arrays along a new axis. -// concatenate : Join a sequence of arrays along an existing axis. -// block : Assemble an nd-array from nested lists of blocks. -// split : Split array into a list of multiple sub-arrays of equal size. +// choose, select, where // // Notes // ----- -// ``unstack`` serves as the reverse operation of :py:func:`stack`, i.e., -// ``stack(unstack(x, axis=axis), axis=axis) == x``. +// This is similar to choose or select, except that functions are +// evaluated on elements of `x` that satisfy the corresponding condition from +// `condlist`. // -// This function is equivalent to ``tuple(np.moveaxis(x, axis, 0))``, since -// iterating on an array iterates along the first axis. +// The result is:: +// +// |-- +// |funclist[0](x[condlist[0]]) +// out = |funclist[1](x[condlist[1]]) +// |... +// |funclist[n2](x[condlist[n2]]) +// |-- // // Examples // -------- -// >>> arr = np.arange(24).reshape((2, 3, 4)) -// >>> np.unstack(arr) -// (array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11]]), -// array([[12, 13, 14, 15], -// [16, 17, 18, 19], -// [20, 21, 22, 23]])) -// >>> np.unstack(arr, axis=1) -// (array([[ 0, 1, 2, 3], -// [12, 13, 14, 15]]), -// array([[ 4, 5, 6, 7], -// [16, 17, 18, 19]]), -// array([[ 8, 9, 10, 11], -// [20, 21, 22, 23]])) -// >>> arr2 = np.stack(np.unstack(arr, axis=1), axis=1) -// >>> arr2.shape -// (2, 3, 4) -// >>> np.all(arr == arr2) -// np.True_ -// -// +// Define the sigma function, which is -1 for ``x < 0`` and +1 for ``x >= 0``. // -//go:linkname Unstack py.unstack -func Unstack(x *py.Object) *py.Object -// -// Find the union of two arrays. +// >>> x = np.linspace(-2.5, 2.5, 6) +// >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1]) +// array([-1., -1., -1., 1., 1., 1.]) // -// Return the unique, sorted array of values that are in either of the two -// input arrays. +// Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for +// ``x >= 0``. // -// Parameters -// ---------- -// ar1, ar2 : array_like -// Input arrays. They are flattened if they are not already 1D. +// >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x]) +// array([2.5, 1.5, 0.5, 0.5, 1.5, 2.5]) // -// Returns -// ------- -// union1d : ndarray -// Unique, sorted union of the input arrays. +// Apply the same function to a scalar value. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.union1d([-1, 0, 1], [-2, 0, 2]) -// array([-2, -1, 0, 1, 2]) +// >>> y = -2 +// >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x]) +// array(2) // -// To find the union of more than two arrays, use functools.reduce: // -// >>> from functools import reduce -// >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) -// array([1, 2, 3, 4, 6]) // +//go:linkname Piecewise py.piecewise +func Piecewise(x *py.Object, condlist *py.Object, funclist *py.Object, __llgo_va_list ...interface{}) *py.Object +// fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None) // -//go:linkname Union1d py.union1d -func Union1d(ar1 *py.Object, ar2 *py.Object) *py.Object +// Construct an array from data in a text or binary file. // -// Create a two-dimensional array with the flattened input as a diagonal. +// A highly efficient way of reading binary data with a known data-type, +// as well as parsing simply formatted text files. Data written using the +// `tofile` method can be read using this function. // // Parameters // ---------- -// v : array_like -// Input data, which is flattened and set as the `k`-th -// diagonal of the output. -// k : int, optional -// Diagonal to set; 0, the default, corresponds to the "main" diagonal, -// a positive (negative) `k` giving the number of the diagonal above -// (below) the main. +// file : file or str or Path +// Open file object or filename. // -// Returns -// ------- -// out : ndarray -// The 2-D output array. -// -// See Also -// -------- -// diag : MATLAB work-alike for 1-D and 2-D arrays. -// diagonal : Return specified diagonals. -// trace : Sum along diagonals. -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.diagflat([[1,2], [3,4]]) -// array([[1, 0, 0, 0], -// [0, 2, 0, 0], -// [0, 0, 3, 0], -// [0, 0, 0, 4]]) -// -// >>> np.diagflat([1,2], 1) -// array([[0, 1, 0], -// [0, 0, 2], -// [0, 0, 0]]) -// -// -// -//go:linkname Diagflat py.diagflat -func Diagflat(v *py.Object, k *py.Object) *py.Object -// -// Return a string representation of an array. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// max_line_width : int, optional -// Inserts newlines if text is longer than `max_line_width`. -// Defaults to ``numpy.get_printoptions()['linewidth']``. -// precision : int or None, optional -// Floating point precision. -// Defaults to ``numpy.get_printoptions()['precision']``. -// suppress_small : bool, optional -// Represent numbers "very close" to zero as zero; default is False. -// Very close is defined by precision: if the precision is 8, e.g., -// numbers smaller (in absolute value) than 5e-9 are represented as -// zero. -// Defaults to ``numpy.get_printoptions()['suppress']``. -// separator : str, optional -// Inserted between elements. -// prefix : str, optional -// suffix : str, optional -// The length of the prefix and suffix strings are used to respectively -// align and wrap the output. An array is typically printed as:: -// -// prefix + array2string(a) + suffix -// -// The output is left-padded by the length of the prefix string, and -// wrapping is forced at the column ``max_line_width - len(suffix)``. -// It should be noted that the content of prefix and suffix strings are -// not included in the output. -// style : _NoValue, optional -// Has no effect, do not use. -// -// .. deprecated:: 1.14.0 -// formatter : dict of callables, optional -// If not None, the keys should indicate the type(s) that the respective -// formatting function applies to. Callables should return a string. -// Types that are not specified (by their corresponding keys) are handled -// by the default formatters. Individual types for which a formatter -// can be set are: -// -// - 'bool' -// - 'int' -// - 'timedelta' : a `numpy.timedelta64` -// - 'datetime' : a `numpy.datetime64` -// - 'float' -// - 'longfloat' : 128-bit floats -// - 'complexfloat' -// - 'longcomplexfloat' : composed of two 128-bit floats -// - 'void' : type `numpy.void` -// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` -// -// Other keys that can be used to set a group of types at once are: -// -// - 'all' : sets all types -// - 'int_kind' : sets 'int' -// - 'float_kind' : sets 'float' and 'longfloat' -// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' -// - 'str_kind' : sets 'numpystr' -// threshold : int, optional -// Total number of array elements which trigger summarization -// rather than full repr. -// Defaults to ``numpy.get_printoptions()['threshold']``. -// edgeitems : int, optional -// Number of array items in summary at beginning and end of -// each dimension. -// Defaults to ``numpy.get_printoptions()['edgeitems']``. -// sign : string, either '-', '+', or ' ', optional -// Controls printing of the sign of floating-point types. If '+', always -// print the sign of positive values. If ' ', always prints a space -// (whitespace character) in the sign position of positive values. If -// '-', omit the sign character of positive values. -// Defaults to ``numpy.get_printoptions()['sign']``. +// .. versionchanged:: 1.17.0 +// `pathlib.Path` objects are now accepted. // -// .. versionchanged:: 2.0 -// The sign parameter can now be an integer type, previously -// types were floating-point types. +// dtype : data-type +// Data type of the returned array. +// For binary files, it is used to determine the size and byte-order +// of the items in the file. +// Most builtin numeric types are supported and extension types may be supported. // -// floatmode : str, optional -// Controls the interpretation of the `precision` option for -// floating-point types. -// Defaults to ``numpy.get_printoptions()['floatmode']``. -// Can take the following values: +// .. versionadded:: 1.18.0 +// Complex dtypes. // -// - 'fixed': Always print exactly `precision` fractional digits, -// even if this would print more or fewer digits than -// necessary to specify the value uniquely. -// - 'unique': Print the minimum number of fractional digits necessary -// to represent each value uniquely. Different elements may -// have a different number of digits. The value of the -// `precision` option is ignored. -// - 'maxprec': Print at most `precision` fractional digits, but if -// an element can be uniquely represented with fewer digits -// only print it with that many. -// - 'maxprec_equal': Print at most `precision` fractional digits, -// but if every element in the array can be uniquely -// represented with an equal number of fewer digits, use that -// many digits for all elements. -// legacy : string or `False`, optional -// If set to the string ``'1.13'`` enables 1.13 legacy printing mode. This -// approximates numpy 1.13 print output by including a space in the sign -// position of floats and different behavior for 0d arrays. If set to -// `False`, disables legacy mode. Unrecognized strings will be ignored -// with a warning for forward compatibility. +// count : int +// Number of items to read. ``-1`` means all items (i.e., the complete +// file). +// sep : str +// Separator between items if file is a text file. +// Empty ("") separator means the file should be treated as binary. +// Spaces (" ") in the separator match zero or more whitespace characters. +// A separator consisting only of spaces must match at least one +// whitespace. +// offset : int +// The offset (in bytes) from the file's current position. Defaults to 0. +// Only permitted for binary files. // -// Returns -// ------- -// array_str : str -// String representation of the array. +// .. versionadded:: 1.17.0 +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. // -// Raises -// ------ -// TypeError -// if a callable in `formatter` does not return a string. +// .. versionadded:: 1.20.0 // -// See Also +// See also // -------- -// array_str, array_repr, set_printoptions, get_printoptions +// load, save +// ndarray.tofile +// loadtxt : More flexible way of loading data from a text file. // // Notes // ----- -// If a formatter is specified for a certain type, the `precision` keyword is -// ignored for that type. -// -// This is a very flexible function; `array_repr` and `array_str` are using -// `array2string` internally so keywords with the same name should work -// identically in all three functions. +// Do not rely on the combination of `tofile` and `fromfile` for +// data storage, as the binary files generated are not platform +// independent. In particular, no byte-order or data-type information is +// saved. Data can be stored in the platform independent ``.npy`` format +// using `save` and `load` instead. // // Examples // -------- -// >>> import numpy as np -// >>> x = np.array([1e-16,1,2,3]) -// >>> np.array2string(x, precision=2, separator=',', -// ... suppress_small=True) -// '[0.,1.,2.,3.]' +// Construct an ndarray: // -// >>> x = np.arange(3.) -// >>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x}) -// '[0.00 1.00 2.00]' +// >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]), +// ... ('temp', float)]) +// >>> x = np.zeros((1,), dtype=dt) +// >>> x['time']['min'] = 10; x['temp'] = 98.25 +// >>> x +// array([((10, 0), 98.25)], +// dtype=[('time', [('min', '>> x = np.arange(3) -// >>> np.array2string(x, formatter={'int':lambda x: hex(x)}) -// '[0x0 0x1 0x2]' +// Save the raw data to disk: +// +// >>> import tempfile +// >>> fname = tempfile.mkstemp()[1] +// >>> x.tofile(fname) // +// Read the raw data from disk: // +// >>> np.fromfile(fname, dtype=dt) +// array([((10, 0), 98.25)], +// dtype=[('time', [('min', '>> np.save(fname, x) +// >>> np.load(fname + '.npy') +// array([((10, 0), 98.25)], +// dtype=[('time', [('min', '>> a = np.array([1, 2, 3, 4, 5, 6]) -// >>> a -// array([1, 2, 3, 4, 5, 6]) -// >>> np.cumulative_sum(a) -// array([ 1, 3, 6, 10, 15, 21]) -// >>> np.cumulative_sum(a, dtype=float) # specifies type of output value(s) -// array([ 1., 3., 6., 10., 15., 21.]) -// -// >>> b = np.array([[1, 2, 3], [4, 5, 6]]) -// >>> np.cumulative_sum(b,axis=0) # sum over rows for each of the 3 columns -// array([[1, 2, 3], -// [5, 7, 9]]) -// >>> np.cumulative_sum(b,axis=1) # sum over columns for each of the 2 rows -// array([[ 1, 3, 6], -// [ 4, 9, 15]]) -// -// ``cumulative_sum(c)[-1]`` may not be equal to ``sum(c)`` -// -// >>> c = np.array([1, 2e-9, 3e-9] * 1000000) -// >>> np.cumulative_sum(c)[-1] -// 1000000.0050045159 -// >>> c.sum() -// 1000000.0050000029 -// -// -// -//go:linkname CumulativeSum py.cumulative_sum -func CumulativeSum(x *py.Object) *py.Object -// -// Format a floating-point scalar as a decimal string in positional notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed, or if `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// fractional : boolean, optional -// If `True`, the cutoffs of `precision` and `min_digits` refer to the -// total number of digits after the decimal point, including leading -// zeros. -// If `False`, `precision` and `min_digits` refer to the total number of -// significant digits, before or after the decimal point, ignoring leading -// zeros. -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// pad_right : non-negative integer, optional -// Pad the right side of the string with whitespace until at least that -// many characters are to the right of the decimal point. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. Only has an effect if `unique=True` -// in which case additional digits past those necessary to uniquely -// identify the value may be printed, rounding the last additional digit. -// -// .. versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value +// When there is more than one axis to sum over - and they are not the last +// (first) axes of `a` (`b`) - the argument `axes` should consist of +// two sequences of the same length, with the first axis to sum over given +// first in both sequences, the second axis second, and so forth. // -// See Also -// -------- -// format_float_scientific +// The shape of the result consists of the non-contracted axes of the +// first tensor, followed by the non-contracted axes of the second. // // Examples // -------- -// >>> import numpy as np -// >>> np.format_float_positional(np.float32(np.pi)) -// '3.1415927' -// >>> np.format_float_positional(np.float16(np.pi)) -// '3.14' -// >>> np.format_float_positional(np.float16(0.3)) -// '0.3' -// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) -// '0.3000488281' -// -// -//go:linkname FormatFloatPositional py.format_float_positional -func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object -// -// Return the indices to access the main diagonal of an n-dimensional array. +// A "traditional" example: // -// See `diag_indices` for full details. -// -// Parameters -// ---------- -// arr : array, at least 2-D +// >>> a = np.arange(60.).reshape(3,4,5) +// >>> b = np.arange(24.).reshape(4,3,2) +// >>> c = np.tensordot(a,b, axes=([1,0],[0,1])) +// >>> c.shape +// (5, 2) +// >>> c +// array([[4400., 4730.], +// [4532., 4874.], +// [4664., 5018.], +// [4796., 5162.], +// [4928., 5306.]]) +// >>> # A slower but equivalent way of computing the same... +// >>> d = np.zeros((5,2)) +// >>> for i in range(5): +// ... for j in range(2): +// ... for k in range(3): +// ... for n in range(4): +// ... d[i,j] += a[k,n,i] * b[n,k,j] +// >>> c == d +// array([[ True, True], +// [ True, True], +// [ True, True], +// [ True, True], +// [ True, True]]) // -// See Also -// -------- -// diag_indices +// An extended example taking advantage of the overloading of + and \*: // -// Examples -// -------- -// >>> import numpy as np +// >>> a = np.array(range(1, 9)) +// >>> a.shape = (2, 2, 2) +// >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object) +// >>> A.shape = (2, 2) +// >>> a; A +// array([[[1, 2], +// [3, 4]], +// [[5, 6], +// [7, 8]]]) +// array([['a', 'b'], +// ['c', 'd']], dtype=object) // -// Create a 4 by 4 array. +// >>> np.tensordot(a, A) # third argument default is 2 for double-contraction +// array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object) // -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) +// >>> np.tensordot(a, A, 1) +// array([[['acc', 'bdd'], +// ['aaacccc', 'bbbdddd']], +// [['aaaaacccccc', 'bbbbbdddddd'], +// ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object) // -// Get the indices of the diagonal elements. +// >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.) +// array([[[[['a', 'b'], +// ['c', 'd']], +// ... // -// >>> di = np.diag_indices_from(a) -// >>> di -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// >>> np.tensordot(a, A, (0, 1)) +// array([[['abbbbb', 'cddddd'], +// ['aabbbbbb', 'ccdddddd']], +// [['aaabbbbbbb', 'cccddddddd'], +// ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object) // -// >>> a[di] -// array([ 0, 5, 10, 15]) +// >>> np.tensordot(a, A, (2, 1)) +// array([[['abb', 'cdd'], +// ['aaabbbb', 'cccdddd']], +// [['aaaaabbbbbb', 'cccccdddddd'], +// ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object) // -// This is simply syntactic sugar for diag_indices. +// >>> np.tensordot(a, A, ((0, 1), (0, 1))) +// array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object) // -// >>> np.diag_indices(a.shape[0]) -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// >>> np.tensordot(a, A, ((2, 1), (1, 0))) +// array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object) // // // -//go:linkname DiagIndicesFrom py.diag_indices_from -func DiagIndicesFrom(arr *py.Object) *py.Object +//go:linkname Tensordot py.tensordot +func Tensordot(a *py.Object, b *py.Object, axes *py.Object) *py.Object // -// Apply a function repeatedly over multiple axes. +// Perform an indirect partition along the given axis using the +// algorithm specified by the `kind` keyword. It returns an array of +// indices of the same shape as `a` that index data along the given +// axis in partitioned order. // -// `func` is called as `res = func(a, axis)`, where `axis` is the first -// element of `axes`. The result `res` of the function call must have -// either the same dimensions as `a` or one less dimension. If `res` -// has one less dimension than `a`, a dimension is inserted before -// `axis`. The call to `func` is then repeated for each axis in `axes`, -// with `res` as the first argument. +// .. versionadded:: 1.8.0 // // Parameters // ---------- -// func : function -// This function must take two arguments, `func(a, axis)`. // a : array_like -// Input array. -// axes : array_like -// Axes over which `func` is applied; the elements must be integers. +// Array to sort. +// 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 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. +// +// .. deprecated:: 1.22.0 +// Passing booleans as index is deprecated. +// axis : int or None, optional +// Axis along which to sort. The default is -1 (the last axis). If +// None, the flattened array is used. +// kind : {'introselect'}, optional +// Selection algorithm. Default is 'introselect' +// order : str or list of str, optional +// When `a` is an array with fields defined, this argument +// specifies which fields to compare first, second, etc. A single +// field can be specified as a string, and not all fields need be +// specified, but unspecified fields will still be used, in the +// order in which they come up in the dtype, to break ties. // // Returns // ------- -// apply_over_axis : ndarray -// The output array. The number of dimensions is the same as `a`, -// but the shape can be different. This depends on whether `func` -// changes the shape of its output with respect to its input. +// 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=axis)`` +// always yields the partitioned `a`, irrespective of dimensionality. // // See Also // -------- -// apply_along_axis : -// Apply a function to 1-D slices of an array along the given axis. +// partition : Describes partition algorithms used. +// ndarray.partition : Inplace partition. +// argsort : Full indirect sort. +// take_along_axis : Apply ``index_array`` from argpartition +// to an array as if by calling partition. // // Notes // ----- -// This function is equivalent to tuple axis arguments to reorderable ufuncs -// with keepdims=True. Tuple axis arguments to ufuncs have been available since -// version 1.7.0. +// See `partition` for notes on the different selection algorithms. // // Examples // -------- -// >>> import numpy as np -// >>> 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]]]) +// One dimensional array: // -// Sum over axes 0 and 2. The result has same number of dimensions -// as the original array: +// >>> x = np.array([3, 4, 2, 1]) +// >>> x[np.argpartition(x, 3)] +// array([2, 1, 3, 4]) +// >>> x[np.argpartition(x, (1, 3))] +// array([1, 2, 3, 4]) // -// >>> np.apply_over_axes(np.sum, a, [0,2]) -// array([[[ 60], -// [ 92], -// [124]]]) +// >>> x = [3, 4, 2, 1] +// >>> np.array(x)[np.argpartition(x, 3)] +// array([2, 1, 3, 4]) // -// Tuple axis arguments to ufuncs are equivalent: +// Multi-dimensional array: // -// >>> np.sum(a, axis=(0,2), keepdims=True) -// array([[[ 60], -// [ 92], -// [124]]]) +// >>> x = np.array([[3, 4, 2], [1, 3, 1]]) +// >>> index_array = np.argpartition(x, kth=1, axis=-1) +// >>> np.take_along_axis(x, index_array, axis=-1) # same as np.partition(x, kth=1) +// array([[2, 3, 4], +// [1, 1, 3]]) // // // -//go:linkname ApplyOverAxes py.apply_over_axes -func ApplyOverAxes(func_ *py.Object, a *py.Object, axes *py.Object) *py.Object +//go:linkname Argpartition py.argpartition +func Argpartition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object +// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Compute the bi-dimensional histogram of two data samples. +// Return the largest integer smaller or equal to the division of the inputs. +// It is equivalent to the Python ``//`` operator and pairs with the +// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` +// up to roundoff. // -// Parameters -// ---------- -// x : array_like, shape (N,) -// An array containing the x coordinates of the points to be -// histogrammed. -// y : array_like, shape (N,) -// An array containing the y coordinates of the points to be -// histogrammed. -// bins : int or array_like or [int, int] or [array, array], optional -// The bin specification: +// Parameters +// ---------- +// x1 : array_like +// Numerator. +// x2 : array_like +// Denominator. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// * If int, the number of bins for the two dimensions (nx=ny=bins). -// * If array_like, the bin edges for the two dimensions -// (x_edges=y_edges=bins). -// * If [int, int], the number of bins in each dimension -// (nx, ny = bins). -// * If [array, array], the bin edges in each dimension -// (x_edges, y_edges = bins). -// * A combination [int, array] or [array, int], where int -// is the number of bins and array is the bin edges. +// Returns +// ------- +// y : ndarray +// y = floor(`x1`/`x2`) +// This is a scalar if both `x1` and `x2` are scalars. // -// range : array_like, shape(2,2), optional -// The leftmost and rightmost edges of the bins along each dimension -// (if not specified explicitly in the `bins` parameters): -// ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range -// will be considered outliers and not tallied in the histogram. -// density : bool, optional -// 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``. -// 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 `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. +// See Also +// -------- +// remainder : Remainder complementary to floor_divide. +// divmod : Simultaneous floor division and remainder. +// divide : Standard division. +// floor : Round a number to the nearest integer toward minus infinity. +// ceil : Round a number to the nearest integer toward infinity. // -// Returns -// ------- -// H : ndarray, shape(nx, ny) -// The bi-dimensional histogram of samples `x` and `y`. Values in `x` -// are histogrammed along the first dimension and values in `y` are -// histogrammed along the second dimension. -// xedges : ndarray, shape(nx+1,) -// The bin edges along the first dimension. -// yedges : ndarray, shape(ny+1,) -// The bin edges along the second dimension. +// Examples +// -------- +// >>> np.floor_divide(7,3) +// 2 +// >>> np.floor_divide([1., 2., 3., 4.], 2.5) +// array([ 0., 0., 1., 1.]) // -// See Also -// -------- -// histogram : 1D histogram -// histogramdd : Multidimensional histogram +// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` +// on ndarrays. // -// Notes -// ----- -// 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. +// >>> x1 = np.array([1., 2., 3., 4.]) +// >>> x1 // 2.5 +// array([0., 0., 1., 1.]) // -// Please note that the histogram does not follow the Cartesian convention -// where `x` values are on the abscissa and `y` values on the ordinate -// axis. Rather, `x` is histogrammed along the first dimension of the -// array (vertical), and `y` along the second dimension of the array -// (horizontal). This ensures compatibility with `histogramdd`. +//go:linkname FloorDivide py.floor_divide +func FloorDivide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Examples -// -------- -// >>> import numpy as np -// >>> from matplotlib.image import NonUniformImage -// >>> import matplotlib.pyplot as plt +// Test element-wise for NaN and return result as a boolean array. // -// Construct a 2-D histogram with variable bin width. First define the bin -// edges: +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> xedges = [0, 1, 3, 5] -// >>> yedges = [0, 2, 3, 4, 6] +// Returns +// ------- +// y : ndarray or bool +// True where ``x`` is NaN, false otherwise. +// This is a scalar if `x` is a scalar. // -// Next we create a histogram H with random bin content: +// See Also +// -------- +// isinf, isneginf, isposinf, isfinite, isnat // -// >>> x = np.random.normal(2, 1, 100) -// >>> y = np.random.normal(1, 1, 100) -// >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) -// >>> # Histogram does not follow Cartesian convention (see Notes), -// >>> # therefore transpose H for visualization purposes. -// >>> H = H.T +// Notes +// ----- +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). This means that Not a Number is not equivalent to infinity. // -// :func:`imshow ` can only display square bins: +// Examples +// -------- +// >>> np.isnan(np.nan) +// True +// >>> np.isnan(np.inf) +// False +// >>> np.isnan([np.log(-1.),1.,np.log(0)]) +// array([ True, False, False]) // -// >>> fig = plt.figure(figsize=(7, 3)) -// >>> ax = fig.add_subplot(131, title='imshow: square bins') -// >>> plt.imshow(H, interpolation='nearest', origin='lower', -// ... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) -// +//go:linkname Isnan py.isnan +func Isnan(x *py.Object, out *py.Object) *py.Object +// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// :func:`pcolormesh ` can display actual edges: +// Logarithm of the sum of exponentiations of the inputs. // -// >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges', -// ... aspect='equal') -// >>> X, Y = np.meshgrid(xedges, yedges) -// >>> ax.pcolormesh(X, Y, H) -// +// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in +// statistics where the calculated probabilities of events may be so small +// as to exceed the range of normal floating point numbers. In such cases +// the logarithm of the calculated probability is stored. This function +// allows adding probabilities stored in such a fashion. // -// :class:`NonUniformImage ` can be used to -// display actual bin edges with interpolation: +// Parameters +// ---------- +// x1, x2 : array_like +// Input values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated', -// ... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]]) -// >>> im = NonUniformImage(ax, interpolation='bilinear') -// >>> xcenters = (xedges[:-1] + xedges[1:]) / 2 -// >>> ycenters = (yedges[:-1] + yedges[1:]) / 2 -// >>> im.set_data(xcenters, ycenters, H) -// >>> ax.add_image(im) -// >>> plt.show() +// Returns +// ------- +// result : ndarray +// Logarithm of ``exp(x1) + exp(x2)``. +// This is a scalar if both `x1` and `x2` are scalars. // -// It is also possible to construct a 2-D histogram without specifying bin -// edges: +// See Also +// -------- +// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. // -// >>> # Generate non-symmetric test data -// >>> n = 10000 -// >>> x = np.linspace(1, 100, n) -// >>> y = 2*np.log(x) + np.random.rand(n) - 0.5 -// >>> # Compute 2d histogram. Note the order of x/y and xedges/yedges -// >>> H, yedges, xedges = np.histogram2d(y, x, bins=20) +// Notes +// ----- +// .. versionadded:: 1.3.0 // -// Now we can plot the histogram using -// :func:`pcolormesh `, and a -// :func:`hexbin ` for comparison. +// Examples +// -------- +// >>> prob1 = np.log(1e-50) +// >>> prob2 = np.log(2.5e-50) +// >>> prob12 = np.logaddexp(prob1, prob2) +// >>> prob12 +// -113.87649168120691 +// >>> np.exp(prob12) +// 3.5000000000000057e-50 // -// >>> # Plot histogram using pcolormesh -// >>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True) -// >>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow') -// >>> ax1.plot(x, 2*np.log(x), 'k-') -// >>> ax1.set_xlim(x.min(), x.max()) -// >>> ax1.set_ylim(y.min(), y.max()) -// >>> ax1.set_xlabel('x') -// >>> ax1.set_ylabel('y') -// >>> ax1.set_title('histogram2d') -// >>> ax1.grid() +//go:linkname Logaddexp py.logaddexp +func Logaddexp(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// add_docstring(obj, docstring) // -// >>> # Create hexbin plot for comparison -// >>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow') -// >>> ax2.plot(x, 2*np.log(x), 'k-') -// >>> ax2.set_title('hexbin') -// >>> ax2.set_xlim(x.min(), x.max()) -// >>> ax2.set_xlabel('x') -// >>> ax2.grid() +// Add a docstring to a built-in obj if possible. +// If the obj already has a docstring raise a RuntimeError +// If this routine does not know how to add a docstring to the object +// raise a TypeError // -// >>> plt.show() +//go:linkname AddDocstring py.add_docstring +func AddDocstring(obj *py.Object, docstring *py.Object) *py.Object // +// Stack arrays in sequence vertically (row wise). // -//go:linkname Histogram2d py.histogram2d -func Histogram2d(x *py.Object, y *py.Object, bins *py.Object, range_ *py.Object, density *py.Object, weights *py.Object) *py.Object +// This is equivalent to concatenation along the first axis after 1-D arrays +// of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by +// `vsplit`. // -// Lower triangle of an array. +// This function makes most sense for arrays with up to 3 dimensions. For +// instance, for pixel-data with a height (first axis), width (second axis), +// and r/g/b channels (third axis). The functions `concatenate`, `stack` and +// `block` provide more general stacking and concatenation operations. // -// Return a copy of an array with elements above the `k`-th diagonal zeroed. -// For arrays with ``ndim`` exceeding 2, `tril` will apply to the final two -// axes. +// ``np.row_stack`` is an alias for `vstack`. They are the same function. // // Parameters // ---------- -// m : array_like, shape (..., M, N) -// Input array. -// k : int, optional -// Diagonal above which to zero elements. `k = 0` (the default) is the -// main diagonal, `k < 0` is below it and `k > 0` is above. -// -// Returns -// ------- -// tril : ndarray, shape (..., M, N) -// Lower triangle of `m`, of same shape and data-type as `m`. -// -// See Also -// -------- -// triu : same thing, only for the upper triangle -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1) -// array([[ 0, 0, 0], -// [ 4, 0, 0], -// [ 7, 8, 0], -// [10, 11, 12]]) -// -// >>> np.tril(np.arange(3*4*5).reshape(3, 4, 5)) -// array([[[ 0, 0, 0, 0, 0], -// [ 5, 6, 0, 0, 0], -// [10, 11, 12, 0, 0], -// [15, 16, 17, 18, 0]], -// [[20, 0, 0, 0, 0], -// [25, 26, 0, 0, 0], -// [30, 31, 32, 0, 0], -// [35, 36, 37, 38, 0]], -// [[40, 0, 0, 0, 0], -// [45, 46, 0, 0, 0], -// [50, 51, 52, 0, 0], -// [55, 56, 57, 58, 0]]]) -// +// 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`. // -//go:linkname Tril py.tril -func Tril(m *py.Object, k *py.Object) *py.Object +// .. versionadded:: 1.24 // -// Return a description for the given data type code. +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional +// Controls what kind of data casting may occur. Defaults to 'same_kind'. // -// Parameters -// ---------- -// char : str -// Data type code. +// .. versionadded:: 1.24 // // Returns // ------- -// out : str -// Description of the input data type code. +// stacked : ndarray +// The array formed by stacking the given arrays, will be at least 2-D. // // See Also // -------- -// dtype +// concatenate : Join a sequence of arrays along an existing axis. +// stack : Join a sequence of arrays along a new axis. +// block : Assemble an nd-array from nested lists of blocks. +// hstack : Stack arrays in sequence horizontally (column wise). +// dstack : Stack arrays in sequence depth wise (along third axis). +// column_stack : Stack 1-D arrays as columns into a 2-D array. +// vsplit : Split an array into multiple sub-arrays vertically (row-wise). // // Examples // -------- -// >>> import numpy as np -// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', -// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] -// >>> for typechar in typechars: -// ... print(typechar, ' : ', np.typename(typechar)) -// ... -// S1 : character -// ? : bool -// B : unsigned char -// D : complex double precision -// G : complex long double precision -// F : complex single precision -// I : unsigned integer -// H : unsigned short -// L : unsigned long integer -// O : object -// Q : unsigned long long integer -// S : string -// U : unicode -// V : void -// b : signed char -// d : double precision -// g : long precision -// f : single precision -// i : integer -// h : short -// l : long integer -// q : long long integer -// -// +// >>> a = np.array([1, 2, 3]) +// >>> b = np.array([4, 5, 6]) +// >>> np.vstack((a,b)) +// array([[1, 2, 3], +// [4, 5, 6]]) // -//go:linkname Typename py.typename -func Typename(char *py.Object) *py.Object +// >>> a = np.array([[1], [2], [3]]) +// >>> b = np.array([[4], [5], [6]]) +// >>> np.vstack((a,b)) +// array([[1], +// [2], +// [3], +// [4], +// [5], +// [6]]) // -// Find indices where elements should be inserted to maintain order. // -// Find the indices into a sorted array `a` such that, if the -// corresponding elements in `v` were inserted before the indices, the -// order of `a` would be preserved. // -// Assuming that `a` is sorted: +//go:linkname RowStack py.row_stack +func RowStack(tup *py.Object) *py.Object +// from_dlpack(x, /) // -// ====== ============================ -// `side` returned index `i` satisfies -// ====== ============================ -// left ``a[i-1] < v <= a[i]`` -// right ``a[i-1] <= v < a[i]`` -// ====== ============================ +// Create a NumPy array from an object implementing the ``__dlpack__`` +// protocol. Generally, the returned NumPy array is a read-only view +// of the input object. See [1]_ and [2]_ for more details. // // Parameters // ---------- -// a : 1-D array_like -// Input array. If `sorter` is None, then it must be sorted in -// ascending order, otherwise `sorter` must be an array of indices -// that sort it. -// v : array_like -// Values to insert into `a`. -// side : {'left', 'right'}, optional -// If 'left', the index of the first suitable location found is given. -// If 'right', return the last such index. If there is no suitable -// index, return either 0 or N (where N is the length of `a`). -// sorter : 1-D array_like, optional -// Optional array of integer indices that sort array a into ascending -// order. They are typically the result of argsort. +// x : object +// A Python object that implements the ``__dlpack__`` and +// ``__dlpack_device__`` methods. // // Returns // ------- -// indices : int or array of ints -// Array of insertion points with the same shape as `v`, -// or an integer if `v` is a scalar. -// -// See Also -// -------- -// sort : Return a sorted copy of an array. -// histogram : Produce histogram from 1-D data. -// -// Notes -// ----- -// Binary search is used to find the required insertion points. +// out : ndarray // -// As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing -// `nan` values. The enhanced sort order is documented in `sort`. +// References +// ---------- +// .. [1] Array API documentation, +// https://data-apis.org/array-api/latest/design_topics/data_interchange.html#syntax-for-data-interchange-with-dlpack // -// This function uses the same algorithm as the builtin python -// `bisect.bisect_left` (``side='left'``) and `bisect.bisect_right` -// (``side='right'``) functions, which is also vectorized -// in the `v` argument. +// .. [2] Python specification for DLPack, +// https://dmlc.github.io/dlpack/latest/python_spec.html // // Examples // -------- -// >>> import numpy as np -// >>> np.searchsorted([11,12,13,14,15], 13) -// 2 -// >>> np.searchsorted([11,12,13,14,15], 13, side='right') -// 3 -// >>> np.searchsorted([11,12,13,14,15], [-10, 20, 12, 13]) -// array([0, 5, 1, 2]) -// -// When `sorter` is used, the returned indices refer to the sorted -// array of `a` and not `a` itself: -// -// >>> a = np.array([40, 10, 20, 30]) -// >>> sorter = np.argsort(a) -// >>> sorter -// array([1, 2, 3, 0]) # Indices that would sort the array 'a' -// >>> result = np.searchsorted(a, 25, sorter=sorter) -// >>> result -// 2 -// >>> a[sorter[result]] -// 30 # The element at index 2 of the sorted array is 30. -// -// -//go:linkname Searchsorted py.searchsorted -func Searchsorted(a *py.Object, v *py.Object, side *py.Object, sorter *py.Object) *py.Object -// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> import torch +// >>> x = torch.arange(10) +// >>> # create a view of the torch tensor "x" in NumPy +// >>> y = np.from_dlpack(x) // -// Hyperbolic sine, element-wise. +//go:linkname FromDlpack py.from_dlpack +func FromDlpack(x *py.Object) *py.Object +// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or -// ``-1j * np.sin(1j*x)``. +// Convert angles from radians to degrees. // // Parameters // ---------- // x : array_like -// Input array. +// Input array in radians. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -18772,55 +17040,47 @@ func Searchsorted(a *py.Object, v *py.Object, side *py.Object, sorter *py.Object // // Returns // ------- -// y : ndarray -// The corresponding hyperbolic sine values. +// y : ndarray of floats +// The corresponding degree values; if `out` was supplied this is a +// reference to it. // This is a scalar if `x` is a scalar. // -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. +// See Also +// -------- +// rad2deg : equivalent function // // Examples // -------- -// >>> import numpy as np -// >>> np.sinh(0) -// 0.0 -// >>> np.sinh(np.pi*1j/2) -// 1j -// >>> np.sinh(np.pi*1j) # (exact value is 0) -// 1.2246063538223773e-016j -// >>> # Discrepancy due to vagaries of floating point arithmetic. +// Convert a radian array to degrees // -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.sinh([0.1], out1) -// >>> out2 is out1 +// >>> rad = np.arange(12.)*np.pi/6 +// >>> np.degrees(rad) +// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., +// 270., 300., 330.]) +// +// >>> out = np.zeros((rad.shape)) +// >>> r = np.degrees(rad, out) +// >>> np.all(r == out) // True // -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +//go:linkname Degrees py.degrees +func Degrees(x *py.Object, out *py.Object) *py.Object +// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname Sinh py.sinh -func Sinh(x *py.Object, out *py.Object) *py.Object -// add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Returns an element-wise indication of the sign of a number. +// +// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan +// is returned for nan inputs. +// +// For complex inputs, the `sign` function returns +// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. // -// Add arguments element-wise. +// complex(nan, 0) is returned for complex nan inputs. // // Parameters // ---------- -// x1, x2 : array_like -// The arrays to be added. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Input values. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -18839,336 +17099,376 @@ func Sinh(x *py.Object, out *py.Object) *py.Object // // Returns // ------- -// add : ndarray or scalar -// The sum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray +// The sign of `x`. +// This is a scalar if `x` is a scalar. // // Notes // ----- -// Equivalent to `x1` + `x2` in terms of array broadcasting. +// There is more than one definition of sign in common use for complex +// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` +// which is different from a common alternative, :math:`x/|x|`. // // Examples // -------- -// >>> import numpy as np -// >>> np.add(1.0, 4.0) -// 5.0 -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.add(x1, x2) -// array([[ 0., 2., 4.], -// [ 3., 5., 7.], -// [ 6., 8., 10.]]) -// -// The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 + x2 -// array([[ 0., 2., 4.], -// [ 3., 5., 7.], -// [ 6., 8., 10.]]) -// -//go:linkname Add py.add -func Add(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Returns the indices that would sort an array. -// -// Perform an indirect sort along the given axis using the algorithm specified -// by the `kind` keyword. It returns an array of indices of the same shape as -// `a` that index data along the given axis in sorted order. +// >>> np.sign([-5., 4.5]) +// array([-1., 1.]) +// >>> np.sign(0) +// 0 +// >>> np.sign(5-2j) +// (1+0j) // -// Parameters -// ---------- -// a : array_like -// Array to sort. -// axis : int or None, optional -// Axis along which to sort. The default is -1 (the last axis). If None, -// the flattened array is used. -// kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional -// Sorting algorithm. The default is 'quicksort'. Note that both 'stable' -// and 'mergesort' use timsort under the covers and, in general, the -// actual implementation will vary with data type. The 'mergesort' option -// is retained for backwards compatibility. -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument specifies -// which fields to compare first, second, etc. A single field can -// be specified as a string, and not all fields need be specified, -// but unspecified fields will still be used, in the order in which -// they come up in the dtype, to break ties. -// stable : bool, optional -// Sort stability. If ``True``, the returned array will maintain -// the relative order of ``a`` values which compare as equal. -// If ``False`` or ``None``, this is not guaranteed. Internally, -// this option selects ``kind='stable'``. Default: ``None``. +//go:linkname Sign py.sign +func Sign(x *py.Object, out *py.Object) *py.Object // -// .. versionadded:: 2.0.0 +// Get the current way of handling floating-point errors. // // Returns // ------- -// index_array : ndarray, int -// Array of indices that sort `a` along the specified `axis`. -// If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`. -// More generally, ``np.take_along_axis(a, index_array, axis=axis)`` -// always yields the sorted `a`, irrespective of dimensionality. +// res : dict +// A dictionary with keys "divide", "over", "under", and "invalid", +// whose values are from the strings "ignore", "print", "log", "warn", +// "raise", and "call". The keys represent possible floating-point +// exceptions, and the values define how these exceptions are handled. // // See Also // -------- -// sort : Describes sorting algorithms used. -// lexsort : Indirect stable sort with multiple keys. -// ndarray.sort : Inplace sort. -// argpartition : Indirect partial sort. -// take_along_axis : Apply ``index_array`` from argsort -// to an array as if by calling sort. +// geterrcall, seterr, seterrcall // // Notes // ----- -// See `sort` for notes on the different sorting algorithms. -// -// As of NumPy 1.4.0 `argsort` works with real/complex arrays containing -// nan values. The enhanced sort order is documented in `sort`. +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. // // Examples // -------- -// One dimensional array: +// >>> np.geterr() +// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) // -// >>> import numpy as np -// >>> x = np.array([3, 1, 2]) -// >>> np.argsort(x) -// array([1, 2, 0]) +// >>> oldsettings = np.seterr(all='warn', over='raise') +// >>> np.geterr() +// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} +// >>> np.arange(3.) / np.arange(3.) +// array([nan, 1., 1.]) // -// Two-dimensional array: // -// >>> x = np.array([[0, 3], [2, 2]]) -// >>> x -// array([[0, 3], -// [2, 2]]) // -// >>> ind = np.argsort(x, axis=0) # sorts along first axis (down) -// >>> ind -// array([[0, 1], -// [1, 0]]) -// >>> np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0) -// array([[0, 2], -// [2, 3]]) +//go:linkname Geterr py.geterr +func Geterr() *py.Object // -// >>> ind = np.argsort(x, axis=1) # sorts along last axis (across) -// >>> ind -// array([[0, 1], -// [0, 1]]) -// >>> np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1) -// array([[0, 3], -// [2, 2]]) +// Append values to the end of an array. // -// Indices of the sorted elements of a N-dimensional array: +// Parameters +// ---------- +// arr : array_like +// Values are appended to a copy of this array. +// values : array_like +// These values are appended to a copy of `arr`. It must be of the +// correct shape (the same shape as `arr`, excluding `axis`). If +// `axis` is not specified, `values` can be any shape and will be +// flattened before use. +// axis : int, optional +// The axis along which `values` are appended. If `axis` is not +// given, both `arr` and `values` are flattened before use. // -// >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape) -// >>> ind -// (array([0, 1, 1, 0]), array([0, 0, 1, 1])) -// >>> x[ind] # same as np.sort(x, axis=None) -// array([0, 2, 2, 3]) +// Returns +// ------- +// append : ndarray +// A copy of `arr` with `values` appended to `axis`. Note that +// `append` does not occur in-place: a new array is allocated and +// filled. If `axis` is None, `out` is a flattened array. // -// Sorting with keys: +// See Also +// -------- +// insert : Insert elements into an array. +// delete : Delete elements from an array. // -// >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '>> x -// array([(1, 0), (0, 1)], -// dtype=[('x', '>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]]) +// array([1, 2, 3, ..., 7, 8, 9]) // -// >>> np.argsort(x, order=('x','y')) -// array([1, 0]) +// When `axis` is specified, `values` must have the correct shape. // -// >>> np.argsort(x, order=('y','x')) -// array([0, 1]) +// >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0) +// array([[1, 2, 3], +// [4, 5, 6], +// [7, 8, 9]]) +// >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0) +// Traceback (most recent call last): +// ... +// ValueError: all the input arrays must have same number of dimensions, but +// the array at index 0 has 2 dimension(s) and the array at index 1 has 1 +// dimension(s) // // // -//go:linkname Argsort py.argsort -func Argsort(a *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object -// asanyarray(a, dtype=None, order=None, *, device=None, copy=None, like=None) +//go:linkname Append py.append +func Append(arr *py.Object, values *py.Object, axis *py.Object) *py.Object // -// Convert the input to an ndarray, but pass ndarray subclasses through. +// Return the directory that contains the NumPy \*.h header files. // -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes scalars, lists, lists of tuples, tuples, tuples of tuples, -// tuples of lists, and ndarrays. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'C'. -// device : str, optional -// The device on which to place the created array. Default: ``None``. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. +// Extension modules that need to compile against NumPy should use this +// function to locate the appropriate include directory. // -// .. versionadded:: 2.1.0 +// Notes +// ----- +// When using ``distutils``, for example in ``setup.py``:: // -// copy : bool, optional -// If ``True``, then the object is copied. If ``None`` then the object is -// copied only if needed, i.e. if ``__array__`` returns a copy, if obj -// is a nested sequence, or if a copy is needed to satisfy any of -// the other requirements (``dtype``, ``order``, etc.). -// For ``False`` it raises a ``ValueError`` if a copy cannot be avoided. -// Default: ``None``. +// import numpy as np +// ... +// Extension('extension_name', ... +// include_dirs=[np.get_include()]) +// ... // -// .. versionadded:: 2.1.0 // -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. // -// .. versionadded:: 1.20.0 +//go:linkname GetInclude py.get_include +func GetInclude() *py.Object +// Save several arrays into a single file in uncompressed ``.npz`` format. +// +// Provide arrays as keyword arguments to store them under the +// corresponding name in the output file: ``savez(fn, x=x, y=y)``. +// +// If arrays are specified as positional arguments, i.e., ``savez(fn, +// x, y)``, their names will be `arr_0`, `arr_1`, etc. +// +// Parameters +// ---------- +// file : str or file +// Either the filename (string) or an open file (file-like object) +// where the data will be saved. If file is a string or a Path, the +// ``.npz`` extension will be appended to the filename if it is not +// already there. +// args : Arguments, optional +// Arrays to save to the file. Please use keyword arguments (see +// `kwds` below) to assign names to arrays. Arrays specified as +// args will be named "arr_0", "arr_1", and so on. +// kwds : Keyword arguments, optional +// Arrays to save to the file. Each array will be saved to the +// output file with its corresponding keyword name. // // Returns // ------- -// out : ndarray or an ndarray subclass -// Array interpretation of `a`. If `a` is an ndarray or a subclass -// of ndarray, it is returned as-is and no copy is performed. +// None // // See Also // -------- -// asarray : Similar function which always returns ndarrays. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// asarray_chkfinite : Similar function which checks input for NaNs and -// Infs. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. +// save : Save a single array to a binary file in NumPy format. +// savetxt : Save an array to a file as plain text. +// savez_compressed : Save several arrays into a compressed ``.npz`` archive // -// Examples -// -------- -// Convert a list into an array: +// Notes +// ----- +// The ``.npz`` file format is a zipped archive of files named after the +// variables they contain. The archive is not compressed and each file +// in the archive contains one variable in ``.npy`` format. For a +// description of the ``.npy`` format, see :py:mod:`numpy.lib.format`. // -// >>> a = [1, 2] -// >>> import numpy as np -// >>> np.asanyarray(a) -// array([1, 2]) +// When opening the saved ``.npz`` file with `load` a `NpzFile` object is +// returned. This is a dictionary-like object which can be queried for +// its list of arrays (with the ``.files`` attribute), and for the arrays +// themselves. // -// Instances of `ndarray` subclasses are passed through as-is: +// Keys passed in `kwds` are used as filenames inside the ZIP archive. +// Therefore, keys should be valid filenames; e.g., avoid keys that begin with +// ``/`` or contain ``.``. // -// >>> a = np.array([(1., 2), (3., 4)], dtype='f4,i4').view(np.recarray) -// >>> np.asanyarray(a) is a -// True +// When naming variables with keyword arguments, it is not possible to name a +// variable ``file``, as this would cause the ``file`` argument to be defined +// twice in the call to ``savez``. // -//go:linkname Asanyarray py.asanyarray -func Asanyarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Examples +// -------- +// >>> from tempfile import TemporaryFile +// >>> outfile = TemporaryFile() +// >>> x = np.arange(10) +// >>> y = np.sin(x) // -// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. +// Using `savez` with \*args, the arrays are saved with default names. // -// The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is -// the signed angle in radians between the ray ending at the origin and -// passing through the point (1,0), and the ray ending at the origin and -// passing through the point (`x2`, `x1`). (Note the role reversal: the -// "`y`-coordinate" is the first function parameter, the "`x`-coordinate" -// is the second.) By IEEE convention, this function is defined for -// `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see -// Notes for specific values). +// >>> np.savez(outfile, x, y) +// >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file +// >>> npzfile = np.load(outfile) +// >>> npzfile.files +// ['arr_0', 'arr_1'] +// >>> npzfile['arr_0'] +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) // -// This function is not defined for complex-valued arguments; for the -// so-called argument of complex values, use `angle`. +// Using `savez` with \**kwds, the arrays are saved with the keyword names. // -// Parameters -// ---------- -// x1 : array_like, real-valued -// `y`-coordinates. -// x2 : array_like, real-valued -// `x`-coordinates. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> outfile = TemporaryFile() +// >>> np.savez(outfile, x=x, y=y) +// >>> _ = outfile.seek(0) +// >>> npzfile = np.load(outfile) +// >>> sorted(npzfile.files) +// ['x', 'y'] +// >>> npzfile['x'] +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) // -// Returns -// ------- -// angle : ndarray -// Array of angles in radians, in the range ``[-pi, pi]``. -// This is a scalar if both `x1` and `x2` are scalars. // -// See Also -// -------- -// arctan, tan, angle // -// Notes -// ----- -// *arctan2* is identical to the `atan2` function of the underlying -// C library. The following special values are defined in the C -// standard: [1]_ +//go:linkname Savez py.savez +func Savez(file *py.Object, __llgo_va_list ...interface{}) *py.Object // -// ====== ====== ================ -// `x1` `x2` `arctan2(x1,x2)` -// ====== ====== ================ -// +/- 0 +0 +/- 0 -// +/- 0 -0 +/- pi -// > 0 +/-inf +0 / +pi -// < 0 +/-inf -0 / -pi -// +/-inf +inf +/- (pi/4) -// +/-inf -inf +/- (3*pi/4) -// ====== ====== ================ +// Construct an array from a text file, using regular expression parsing. // -// Note that +0 and -0 are distinct floating point numbers, as are +inf -// and -inf. +// The returned array is always a structured array, and is constructed from +// all matches of the regular expression in the file. Groups in the regular +// expression are converted to fields of the structured array. // -// References -// ---------- -// .. [1] ISO/IEC standard 9899:1999, "Programming language C." +// Parameters +// ---------- +// file : path or file +// Filename or file object to read. // -// Examples -// -------- +// .. versionchanged:: 1.22.0 +// Now accepts `os.PathLike` implementations. +// regexp : str or regexp +// Regular expression used to parse the file. +// Groups in the regular expression correspond to fields in the dtype. +// dtype : dtype or list of dtypes +// Dtype for the structured array; must be a structured datatype. +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. // -// Consider four points in different quadrants: +// .. versionadded:: 1.14.0 // -// >>> import numpy as np -// >>> x = np.array([-1, +1, +1, -1]) -// >>> y = np.array([-1, -1, +1, +1]) -// >>> np.arctan2(y, x) * 180 / np.pi -// array([-135., -45., 45., 135.]) +// Returns +// ------- +// output : ndarray +// The output array, containing the part of the content of `file` that +// was matched by `regexp`. `output` is always a structured array. // -// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 -// and at several other special points, obtaining values in -// the range ``[-pi, pi]``: +// Raises +// ------ +// TypeError +// When `dtype` is not a valid dtype for a structured array. // -// >>> 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]) +// See Also +// -------- +// fromstring, loadtxt // -//go:linkname Atan2 py.atan2 -func Atan2(__llgo_va_list ...interface{}) *py.Object -// greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Notes +// ----- +// Dtypes for structured arrays can be specified in several forms, but all +// forms specify at least the data type and field name. For details see +// `basics.rec`. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> text = StringIO("1312 foo\n1534 bar\n444 qux") +// +// >>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything] +// >>> output = np.fromregex(text, regexp, +// ... [('num', np.int64), ('key', 'S3')]) +// >>> output +// array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')], +// dtype=[('num', '>> output['num'] +// array([1312, 1534, 444]) +// +// +// +//go:linkname Fromregex py.fromregex +func Fromregex(__llgo_va_list ...interface{}) *py.Object +// +// Range of values (maximum - minimum) along an axis. +// +// The name of the function comes from the acronym for 'peak to peak'. +// +// .. warning:: +// `ptp` preserves the data type of the array. This means the +// return value for an input of signed integers with n bits +// (e.g. `np.int8`, `np.int16`, etc) is also a signed integer +// with n bits. In that case, peak-to-peak values greater than +// ``2**(n-1)-1`` will be returned as negative values. An example +// with a work-around is shown below. +// +// Parameters +// ---------- +// a : array_like +// Input values. +// axis : None or int or tuple of ints, optional +// Axis along which to find the peaks. By default, flatten the +// array. `axis` may be negative, in +// which case it counts from the last to the first axis. +// +// .. versionadded:: 1.15.0 +// +// If this is a tuple of ints, a reduction is performed on multiple +// axes, instead of a single axis or all the axes as before. +// out : array_like +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output, +// but the type of the output values will be cast if necessary. +// +// 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 input array. +// +// If the default value is passed, then `keepdims` will not be +// passed through to the `ptp` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. +// +// Returns +// ------- +// 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 +// -------- +// >>> x = np.array([[4, 9, 2, 10], +// ... [6, 9, 7, 12]]) +// +// >>> np.ptp(x, axis=1) +// array([8, 6]) +// +// >>> np.ptp(x, axis=0) +// array([2, 0, 5, 2]) +// +// >>> np.ptp(x) +// 10 +// +// This example shows that a negative value can be returned when +// the input is an array of signed integers. +// +// >>> y = np.array([[1, 127], +// ... [0, 127], +// ... [-1, 127], +// ... [-2, 127]], dtype=np.int8) +// >>> np.ptp(y, axis=1) +// array([ 126, 127, -128, -127], dtype=int8) +// +// A work-around is to use the `view()` method to view the result as +// unsigned integers with the same bit width: +// +// >>> np.ptp(y, axis=1).view(np.uint8) +// array([126, 127, 128, 129], dtype=uint8) +// +// +// +//go:linkname Ptp py.ptp +func Ptp(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object) *py.Object +// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the truncated value of the input, element-wise. // -// Return the truth value of (x1 >= x2) element-wise. +// The truncated value of the scalar `x` is the nearest integer `i` which +// is closer to zero than `x` is. In short, the fractional part of the +// signed number `x` is discarded. // // Parameters // ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Input data. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -19187,490 +17487,1514 @@ func Atan2(__llgo_va_list ...interface{}) *py.Object // // Returns // ------- -// out : bool or ndarray of bool -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray or scalar +// The truncated value of each element in `x`. +// This is a scalar if `x` is a scalar. // // See Also // -------- -// greater, less, less_equal, equal, not_equal +// ceil, floor, rint, fix +// +// Notes +// ----- +// .. versionadded:: 1.3.0 // // Examples // -------- -// >>> import numpy as np -// >>> np.greater_equal([4, 2, 1], [2, 2, 2]) -// array([ True, True, False]) +// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) +// >>> np.trunc(a) +// array([-1., -1., -0., 0., 1., 1., 2.]) // -// The ``>=`` operator can be used as a shorthand for ``np.greater_equal`` -// on ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a >= b -// array([ True, True, False]) -// -//go:linkname GreaterEqual py.greater_equal -func GreaterEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Determine if a provided dtype is of a specified data type ``kind``. +//go:linkname Trunc py.trunc +func Trunc(x *py.Object, out *py.Object) *py.Object // -// This function only supports built-in NumPy's data types. -// Third-party dtypes are not yet supported. +// Return the string representation of a scalar dtype. // // Parameters // ---------- -// dtype : dtype -// The input dtype. -// kind : dtype or str or tuple of dtypes/strs. -// dtype or dtype kind. Allowed dtype kinds are: -// * ``'bool'`` : boolean kind -// * ``'signed integer'`` : signed integer data types -// * ``'unsigned integer'`` : unsigned integer data types -// * ``'integral'`` : integer data types -// * ``'real floating'`` : real-valued floating-point data types -// * ``'complex floating'`` : complex floating-point data types -// * ``'numeric'`` : numeric data types +// sctype : scalar dtype or object +// If a scalar dtype, the corresponding string character is +// returned. If an object, `sctype2char` tries to infer its scalar type +// and then return the corresponding string character. // // Returns // ------- -// out : bool +// typechar : str +// The string character corresponding to the scalar type. +// +// Raises +// ------ +// ValueError +// If `sctype` is an object for which the type can not be inferred. // // See Also // -------- -// issubdtype +// obj2sctype, issctype, issubsctype, mintypecode // // Examples // -------- -// >>> import numpy as np -// >>> np.isdtype(np.float32, np.float64) -// False -// >>> np.isdtype(np.float32, "real floating") -// True -// >>> np.isdtype(np.complex128, ("real floating", "complex floating")) -// True +// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: +// ... print(np.sctype2char(sctype)) +// l # may vary +// d +// D +// S +// O // +// >>> x = np.array([1., 2-1.j]) +// >>> np.sctype2char(x) +// 'D' +// >>> np.sctype2char(list) +// 'O' // // -//go:linkname Isdtype py.isdtype -func Isdtype(dtype *py.Object, kind *py.Object) *py.Object // -// Move axes of an array to new positions. +//go:linkname Sctype2char py.sctype2char +func Sctype2char(sctype *py.Object) *py.Object // -// Other axes remain in their original order. +// Return numbers spaced evenly on a log scale (a geometric progression). +// +// This is similar to `logspace`, but with endpoints specified directly. +// Each output sample is a constant multiple of the previous. +// +// .. versionchanged:: 1.16.0 +// Non-scalar `start` and `stop` are now supported. // // Parameters // ---------- -// a : np.ndarray -// The array whose axes should be reordered. -// source : int or sequence of int -// Original positions of the axes to move. These must be unique. -// destination : int or sequence of int -// Destination positions for each of the original axes. These must also be -// unique. +// start : array_like +// The starting value of the sequence. +// stop : array_like +// The final value of the sequence, unless `endpoint` is False. +// In that case, ``num + 1`` values are spaced over the +// interval in log-space, of which all but the last (a sequence of +// length `num`) are returned. +// num : integer, optional +// Number of samples to generate. Default is 50. +// endpoint : boolean, optional +// If true, `stop` is the last sample. Otherwise, it is not included. +// Default is True. +// dtype : dtype +// The type of the output array. If `dtype` is not given, the data type +// is inferred from `start` and `stop`. The inferred dtype will never be +// an integer; `float` is chosen even if the arguments would produce an +// array of integers. +// axis : int, optional +// The axis in the result to store the samples. Relevant only if start +// or stop are array-like. By default (0), the samples will be along a +// new axis inserted at the beginning. Use -1 to get an axis at the end. +// +// .. versionadded:: 1.16.0 // // Returns // ------- -// result : np.ndarray -// Array with moved axes. This array is a view of the input array. +// samples : ndarray +// `num` samples, equally spaced on a log scale. // // See Also // -------- -// transpose : Permute the dimensions of an array. -// swapaxes : Interchange two axes of an array. +// logspace : Similar to geomspace, but with endpoints specified using log +// and base. +// linspace : Similar to geomspace, but with arithmetic instead of geometric +// progression. +// arange : Similar to linspace, with the step size specified instead of the +// number of samples. +// :ref:`how-to-partition` +// +// Notes +// ----- +// If the inputs or dtype are complex, the output will follow a logarithmic +// spiral in the complex plane. (There are an infinite number of spirals +// passing through two points; the output will follow the shortest such path.) // // Examples // -------- -// >>> import numpy as np -// >>> x = np.zeros((3, 4, 5)) -// >>> np.moveaxis(x, 0, -1).shape -// (4, 5, 3) -// >>> np.moveaxis(x, -1, 0).shape -// (5, 3, 4) +// >>> np.geomspace(1, 1000, num=4) +// array([ 1., 10., 100., 1000.]) +// >>> np.geomspace(1, 1000, num=3, endpoint=False) +// array([ 1., 10., 100.]) +// >>> np.geomspace(1, 1000, num=4, endpoint=False) +// array([ 1. , 5.62341325, 31.6227766 , 177.827941 ]) +// >>> np.geomspace(1, 256, num=9) +// array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.]) // -// These all achieve the same result: +// Note that the above may not produce exact integers: // -// >>> np.transpose(x).shape -// (5, 4, 3) -// >>> np.swapaxes(x, 0, -1).shape -// (5, 4, 3) -// >>> np.moveaxis(x, [0, 1], [-1, -2]).shape -// (5, 4, 3) -// >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape -// (5, 4, 3) +// >>> np.geomspace(1, 256, num=9, dtype=int) +// array([ 1, 2, 4, 7, 16, 32, 63, 127, 256]) +// >>> np.around(np.geomspace(1, 256, num=9)).astype(int) +// array([ 1, 2, 4, 8, 16, 32, 64, 128, 256]) // +// Negative, decreasing, and complex inputs are allowed: // +// >>> np.geomspace(1000, 1, num=4) +// array([1000., 100., 10., 1.]) +// >>> np.geomspace(-1000, -1, num=4) +// array([-1000., -100., -10., -1.]) +// >>> np.geomspace(1j, 1000j, num=4) # Straight line +// array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j]) +// >>> np.geomspace(-1+0j, 1+0j, num=5) # Circle +// array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j, +// 6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j, +// 1.00000000e+00+0.00000000e+00j]) // -//go:linkname Moveaxis py.moveaxis -func Moveaxis(a *py.Object, source *py.Object, destination *py.Object) *py.Object +// Graphical illustration of `endpoint` parameter: // -// Roll the specified axis backwards, until it lies in a given position. +// >>> import matplotlib.pyplot as plt +// >>> N = 10 +// >>> y = np.zeros(N) +// >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o') +// [] +// >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o') +// [] +// >>> plt.axis([0.5, 2000, 0, 3]) +// [0.5, 2000, 0, 3] +// >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both') +// >>> plt.show() // -// This function continues to be supported for backward compatibility, but you -// should prefer `moveaxis`. The `moveaxis` function was added in NumPy -// 1.11. +// +// +//go:linkname Geomspace py.geomspace +func Geomspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, dtype *py.Object, axis *py.Object) *py.Object +// +// Stack arrays in sequence vertically (row wise). +// +// This is equivalent to concatenation along the first axis after 1-D arrays +// of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by +// `vsplit`. +// +// This function makes most sense for arrays with up to 3 dimensions. For +// instance, for pixel-data with a height (first axis), width (second axis), +// 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 // ---------- -// a : ndarray -// Input array. -// axis : int -// The axis to be rolled. The positions of the other axes do not -// change relative to one another. -// start : int, optional -// When ``start <= axis``, the axis is rolled back until it lies in -// this position. When ``start > axis``, the axis is rolled until it -// lies before this position. The default, 0, results in a "complete" -// roll. The following table describes how negative values of ``start`` -// are interpreted: +// 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. // -// .. table:: -// :align: left +// dtype : str or dtype +// If provided, the destination array will have this dtype. Cannot be +// provided together with `out`. // -// +-------------------+----------------------+ -// | ``start`` | Normalized ``start`` | -// +===================+======================+ -// | ``-(arr.ndim+1)`` | raise ``AxisError`` | -// +-------------------+----------------------+ -// | ``-arr.ndim`` | 0 | -// +-------------------+----------------------+ -// | |vdots| | |vdots| | -// +-------------------+----------------------+ -// | ``-1`` | ``arr.ndim-1`` | -// +-------------------+----------------------+ -// | ``0`` | ``0`` | -// +-------------------+----------------------+ -// | |vdots| | |vdots| | -// +-------------------+----------------------+ -// | ``arr.ndim`` | ``arr.ndim`` | -// +-------------------+----------------------+ -// | ``arr.ndim + 1`` | raise ``AxisError`` | -// +-------------------+----------------------+ +// .. versionadded:: 1.24 // -// .. |vdots| unicode:: U+22EE .. Vertical Ellipsis +// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional +// Controls what kind of data casting may occur. Defaults to 'same_kind'. +// +// .. versionadded:: 1.24 // // Returns // ------- -// res : ndarray -// For NumPy >= 1.10.0 a view of `a` is always returned. For earlier -// NumPy versions a view of `a` is returned only if the order of the -// axes is changed, otherwise the input array is returned. +// stacked : ndarray +// The array formed by stacking the given arrays, will be at least 2-D. // // See Also // -------- -// moveaxis : Move array axes to new positions. -// roll : Roll the elements of an array by a number of positions along a -// given axis. +// concatenate : Join a sequence of arrays along an existing axis. +// stack : Join a sequence of arrays along a new axis. +// block : Assemble an nd-array from nested lists of blocks. +// hstack : Stack arrays in sequence horizontally (column wise). +// dstack : Stack arrays in sequence depth wise (along third axis). +// column_stack : Stack 1-D arrays as columns into a 2-D array. +// vsplit : Split an array into multiple sub-arrays vertically (row-wise). // // Examples // -------- -// >>> import numpy as np -// >>> a = np.ones((3,4,5,6)) -// >>> np.rollaxis(a, 3, 1).shape -// (3, 6, 4, 5) -// >>> np.rollaxis(a, 2).shape -// (5, 3, 4, 6) -// >>> np.rollaxis(a, 1, 4).shape -// (3, 5, 6, 4) +// >>> a = np.array([1, 2, 3]) +// >>> b = np.array([4, 5, 6]) +// >>> np.vstack((a,b)) +// array([[1, 2, 3], +// [4, 5, 6]]) // +// >>> a = np.array([[1], [2], [3]]) +// >>> b = np.array([[4], [5], [6]]) +// >>> np.vstack((a,b)) +// array([[1], +// [2], +// [3], +// [4], +// [5], +// [6]]) // // -//go:linkname Rollaxis py.rollaxis -func Rollaxis(a *py.Object, axis *py.Object, start *py.Object) *py.Object -// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Trigonometric sine, element-wise. +//go:linkname Vstack py.vstack +func Vstack(tup *py.Object) *py.Object // -// Parameters -// ---------- -// x : array_like -// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Returns a bool array, where True if input element is real. // -// Returns -// ------- -// y : array_like -// The sine of each element of x. -// This is a scalar if `x` is a scalar. +// If element has complex type with zero complex part, the return value +// for that element is True. +// +// Parameters +// ---------- +// x : array_like +// Input array. +// +// Returns +// ------- +// out : ndarray, bool +// Boolean array of same shape as `x`. +// +// Notes +// ----- +// `isreal` may behave unexpectedly for string or object arrays (see examples) +// +// See Also +// -------- +// iscomplex +// isrealobj : Return True if x is not a complex type. +// +// Examples +// -------- +// >>> 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]) +// +// +// +//go:linkname Isreal py.isreal +func Isreal(x *py.Object) *py.Object +// add_ufunc_docstring(ufunc, new_docstring) +// +// Replace the docstring for a ufunc with new_docstring. +// This method will only work if the current docstring for +// the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.) +// +// Parameters +// ---------- +// ufunc : numpy.ufunc +// A ufunc whose current doc is NULL. +// new_docstring : string +// The new docstring for the ufunc. +// +// Notes +// ----- +// This method allocates memory for new_docstring on +// the heap. Technically this creates a mempory leak, since this +// memory will not be reclaimed until the end of the program +// even if the ufunc itself is removed. However this will only +// be a problem if the user is repeatedly creating ufuncs with +// no documentation, adding documentation via add_newdoc_ufunc, +// and then throwing away the ufunc. +// +//go:linkname AddNewdocUfunc py.add_newdoc_ufunc +func AddNewdocUfunc(__llgo_va_list ...interface{}) *py.Object +// +// Build a matrix object from a string, nested sequence, or array. +// +// Parameters +// ---------- +// obj : str or array_like +// Input data. If a string, variables in the current scope may be +// referenced by name. +// ldict : dict, optional +// A dictionary that replaces local operands in current frame. +// Ignored if `obj` is not a string or `gdict` is None. +// gdict : dict, optional +// A dictionary that replaces global operands in current frame. +// Ignored if `obj` is not a string. +// +// Returns +// ------- +// out : matrix +// Returns a matrix object, which is a specialized 2-D array. +// +// See Also +// -------- +// block : +// A generalization of this function for N-d arrays, that returns normal +// ndarrays. +// +// Examples +// -------- +// >>> A = np.mat('1 1; 1 1') +// >>> B = np.mat('2 2; 2 2') +// >>> C = np.mat('3 4; 5 6') +// >>> D = np.mat('7 8; 9 0') +// +// All the following expressions construct the same block matrix: +// +// >>> np.bmat([[A, B], [C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// >>> np.bmat('A,B; C,D') +// matrix([[1, 1, 2, 2], +// [1, 1, 2, 2], +// [3, 4, 7, 8], +// [5, 6, 9, 0]]) +// +// +// +//go:linkname Bmat py.bmat +func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object +// frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None) +// +// Interpret a buffer as a 1-dimensional array. +// +// Parameters +// ---------- +// buffer : buffer_like +// An object that exposes the buffer interface. +// dtype : data-type, optional +// Data-type of the returned array; default: float. +// count : int, optional +// Number of items to read. ``-1`` means all data in the buffer. +// offset : int, optional +// Start reading the buffer from this offset (in bytes); default: 0. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// 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 +// be specified as part of the data-type, e.g.:: +// +// >>> dt = np.dtype(int) +// >>> dt = dt.newbyteorder('>') +// >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP +// +// 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' +// >>> np.frombuffer(s, dtype='S1', count=5, offset=6) +// array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1') +// +// >>> np.frombuffer(b'\x01\x02', dtype=np.uint8) +// array([1, 2], dtype=uint8) +// >>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3) +// array([1, 2, 3], dtype=uint8) +// +//go:linkname Frombuffer py.frombuffer +func Frombuffer(buffer *py.Object, dtype *py.Object, count *py.Object, offset *py.Object) *py.Object +// +// Return the cumulative product of elements along a given axis. +// +// Parameters +// ---------- +// a : array_like +// Input array. +// axis : int, optional +// Axis along which the cumulative product is computed. By default +// the input is flattened. +// dtype : dtype, optional +// Type of the returned array, as well as of the accumulator in which +// the elements are multiplied. If *dtype* is not specified, it +// defaults to the dtype of `a`, unless `a` has an integer dtype with +// a precision less than that of the default platform integer. In +// that case, the default platform integer is used instead. +// out : ndarray, optional +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output +// but the type of the resulting values will be cast if necessary. +// +// Returns +// ------- +// cumprod : ndarray +// A new array holding the result is returned unless `out` is +// specified, in which case a reference to out is returned. +// +// See Also +// -------- +// :ref:`ufuncs-output-type` +// +// Notes +// ----- +// Arithmetic is modular when using integer types, and no error is +// raised on overflow. +// +// Examples +// -------- +// >>> a = np.array([1,2,3]) +// >>> np.cumprod(a) # intermediate results 1, 1*2 +// ... # total product 1*2*3 = 6 +// array([1, 2, 6]) +// >>> a = np.array([[1, 2, 3], [4, 5, 6]]) +// >>> np.cumprod(a, dtype=float) # specify type of output +// array([ 1., 2., 6., 24., 120., 720.]) +// +// The cumulative product for each column (i.e., over the rows) of `a`: +// +// >>> np.cumprod(a, axis=0) +// array([[ 1, 2, 3], +// [ 4, 10, 18]]) +// +// The cumulative product for each row (i.e. over the columns) of `a`: +// +// >>> np.cumprod(a,axis=1) +// array([[ 1, 2, 6], +// [ 4, 20, 120]]) +// +// +// +//go:linkname Cumprod py.cumprod +func Cumprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object +// +// Return the cross product of two (arrays of) vectors. +// +// The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular +// to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors +// are defined by the last axis of `a` and `b` by default, and these axes +// can have dimensions 2 or 3. Where the dimension of either `a` or `b` is +// 2, the third component of the input vector is assumed to be zero and the +// cross product calculated accordingly. In cases where both input vectors +// have dimension 2, the z-component of the cross product is returned. +// +// Parameters +// ---------- +// a : array_like +// Components of the first vector(s). +// b : array_like +// Components of the second vector(s). +// axisa : int, optional +// Axis of `a` that defines the vector(s). By default, the last axis. +// axisb : int, optional +// Axis of `b` that defines the vector(s). By default, the last axis. +// axisc : int, optional +// Axis of `c` containing the cross product vector(s). Ignored if +// both input vectors have dimension 2, as the return is scalar. +// By default, the last axis. +// axis : int, optional +// If defined, the axis of `a`, `b` and `c` that defines the vector(s) +// and cross product(s). Overrides `axisa`, `axisb` and `axisc`. +// +// Returns +// ------- +// c : ndarray +// Vector cross product(s). +// +// Raises +// ------ +// ValueError +// When the dimension of the vector(s) in `a` and/or `b` does not +// equal 2 or 3. +// +// See Also +// -------- +// inner : Inner product +// outer : Outer product. +// ix_ : Construct index arrays. +// +// Notes +// ----- +// .. versionadded:: 1.9.0 +// +// Supports full broadcasting of the inputs. +// +// Examples +// -------- +// Vector cross-product. +// +// >>> x = [1, 2, 3] +// >>> y = [4, 5, 6] +// >>> np.cross(x, y) +// array([-3, 6, -3]) +// +// One vector with dimension 2. +// +// >>> x = [1, 2] +// >>> y = [4, 5, 6] +// >>> np.cross(x, y) +// array([12, -6, -3]) +// +// Equivalently: +// +// >>> x = [1, 2, 0] +// >>> y = [4, 5, 6] +// >>> np.cross(x, y) +// array([12, -6, -3]) +// +// Both vectors with dimension 2. +// +// >>> x = [1,2] +// >>> y = [4,5] +// >>> np.cross(x, y) +// array(-3) +// +// Multiple vector cross-products. Note that the direction of the cross +// 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]]) +// >>> np.cross(x, y) +// array([[-3, 6, -3], +// [ 3, -6, 3]]) +// +// The orientation of `c` can be changed using the `axisc` keyword. +// +// >>> np.cross(x, y, axisc=0) +// array([[-3, 3], +// [ 6, -6], +// [-3, 3]]) +// +// Change the vector definition of `x` and `y` using `axisa` and `axisb`. +// +// >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]]) +// >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]]) +// >>> np.cross(x, y) +// array([[ -6, 12, -6], +// [ 0, 0, 0], +// [ 6, -12, 6]]) +// >>> np.cross(x, y, axisa=0, axisb=0) +// array([[-24, 48, -24], +// [-30, 60, -30], +// [-36, 72, -36]]) +// +// +// +//go:linkname Cross py.cross +func Cross(a *py.Object, b *py.Object, axisa *py.Object, axisb *py.Object, axisc *py.Object, axis *py.Object) *py.Object +//go:linkname Arccosh py.arccosh +func Arccosh(__llgo_va_list ...interface{}) *py.Object +// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise OR of two arrays element-wise. +// +// Computes the bit-wise OR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``|``. +// +// Parameters +// ---------- +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. +// +// See Also +// -------- +// logical_or +// bitwise_and +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. +// +// Examples +// -------- +// The number 13 has the binary representation ``00001101``. Likewise, +// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is +// then ``00011101``, or 29: +// +// >>> np.bitwise_or(13, 16) +// 29 +// >>> np.binary_repr(29) +// '11101' +// +// >>> np.bitwise_or(32, 2) +// 34 +// >>> np.bitwise_or([33, 4], 1) +// array([33, 5]) +// >>> np.bitwise_or([33, 4], [1, 2]) +// array([33, 6]) +// +// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) +// array([ 6, 5, 255]) +// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) +// array([ 6, 5, 255]) +// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), +// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) +// array([ 6, 5, 255, 2147483647]) +// >>> np.bitwise_or([True, True], [False, True]) +// array([ True, True]) +// +// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on +// ndarrays. +// +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([4, 4, 4]) +// >>> x1 | x2 +// array([ 6, 5, 255]) +// +//go:linkname BitwiseOr py.bitwise_or +func BitwiseOr(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Change the sign of x1 to that of x2, element-wise. +// +// If `x2` is a scalar, its sign will be copied to all elements of `x1`. +// +// Parameters +// ---------- +// x1 : array_like +// Values to change the sign of. +// x2 : array_like +// The sign of `x2` is copied to `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The values of `x1` with the sign of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> np.copysign(1.3, -1) +// -1.3 +// >>> 1/np.copysign(0, 1) +// inf +// >>> 1/np.copysign(0, -1) +// -inf +// +// >>> np.copysign([-1, 0, 1], -1.1) +// array([-1., -0., -1.]) +// >>> np.copysign([-1, 0, 1], np.arange(3)-1) +// array([-1., 0., 1.]) +// +//go:linkname Copysign py.copysign +func Copysign(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Return the next floating-point value after x1 towards x2, element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Values to find the next representable value of. +// x2 : array_like +// The direction where to look for the next representable value of `x1`. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// out : ndarray or scalar +// The next representable values of `x1` in the direction of `x2`. +// This is a scalar if both `x1` and `x2` are scalars. +// +// Examples +// -------- +// >>> eps = np.finfo(np.float64).eps +// >>> np.nextafter(1, 2) == eps + 1 +// True +// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] +// array([ True, True]) +// +//go:linkname Nextafter py.nextafter +func Nextafter(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// +// Return Pearson product-moment correlation coefficients. +// +// Please refer to the documentation for `cov` for more detail. The +// relationship between the correlation coefficient matrix, `R`, and the +// covariance matrix, `C`, is +// +// .. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } } +// +// The values of `R` are between -1 and 1, inclusive. +// +// Parameters +// ---------- +// x : array_like +// A 1-D or 2-D array containing multiple variables and observations. +// Each row of `x` represents a variable, and each column a single +// observation of all those variables. Also see `rowvar` below. +// y : array_like, optional +// An additional set of variables and observations. `y` has the same +// shape as `x`. +// rowvar : bool, optional +// If `rowvar` is True (default), then each row represents a +// variable, with observations in the columns. Otherwise, the relationship +// is transposed: each column represents a variable, while the rows +// contain observations. +// bias : _NoValue, optional +// Has no effect, do not use. +// +// .. deprecated:: 1.10.0 +// ddof : _NoValue, optional +// Has no effect, do not use. +// +// .. deprecated:: 1.10.0 +// dtype : data-type, optional +// Data-type of the result. By default, the return data-type will have +// at least `numpy.float64` precision. +// +// .. versionadded:: 1.20 +// +// Returns +// ------- +// R : ndarray +// The correlation coefficient matrix of the variables. +// +// See Also +// -------- +// cov : Covariance matrix +// +// Notes +// ----- +// Due to floating point rounding the resulting array may not be Hermitian, +// the diagonal elements may not be 1, and the elements may not satisfy the +// inequality abs(a) <= 1. The real and imaginary parts are clipped to the +// interval [-1, 1] in an attempt to improve on that situation but is not +// much help in the complex case. +// +// This function accepts but discards arguments `bias` and `ddof`. This is +// for backwards compatibility with previous versions of this function. These +// arguments had no effect on the return values of the function and can be +// safely ignored in this and previous versions of numpy. +// +// Examples +// -------- +// In this example we generate two random arrays, ``xarr`` and ``yarr``, and +// compute the row-wise and column-wise Pearson correlation coefficients, +// ``R``. Since ``rowvar`` is true by default, we first find the row-wise +// Pearson correlation coefficients between the variables of ``xarr``. +// +// >>> import numpy as np +// >>> rng = np.random.default_rng(seed=42) +// >>> xarr = rng.random((3, 3)) +// >>> xarr +// array([[0.77395605, 0.43887844, 0.85859792], +// [0.69736803, 0.09417735, 0.97562235], +// [0.7611397 , 0.78606431, 0.12811363]]) +// >>> R1 = np.corrcoef(xarr) +// >>> R1 +// array([[ 1. , 0.99256089, -0.68080986], +// [ 0.99256089, 1. , -0.76492172], +// [-0.68080986, -0.76492172, 1. ]]) +// +// If we add another set of variables and observations ``yarr``, we can +// compute the row-wise Pearson correlation coefficients between the +// variables in ``xarr`` and ``yarr``. +// +// >>> yarr = rng.random((3, 3)) +// >>> yarr +// array([[0.45038594, 0.37079802, 0.92676499], +// [0.64386512, 0.82276161, 0.4434142 ], +// [0.22723872, 0.55458479, 0.06381726]]) +// >>> R2 = np.corrcoef(xarr, yarr) +// >>> R2 +// array([[ 1. , 0.99256089, -0.68080986, 0.75008178, -0.934284 , +// -0.99004057], +// [ 0.99256089, 1. , -0.76492172, 0.82502011, -0.97074098, +// -0.99981569], +// [-0.68080986, -0.76492172, 1. , -0.99507202, 0.89721355, +// 0.77714685], +// [ 0.75008178, 0.82502011, -0.99507202, 1. , -0.93657855, +// -0.83571711], +// [-0.934284 , -0.97074098, 0.89721355, -0.93657855, 1. , +// 0.97517215], +// [-0.99004057, -0.99981569, 0.77714685, -0.83571711, 0.97517215, +// 1. ]]) +// +// Finally if we use the option ``rowvar=False``, the columns are now +// being treated as the variables and we will find the column-wise Pearson +// correlation coefficients between variables in ``xarr`` and ``yarr``. +// +// >>> R3 = np.corrcoef(xarr, yarr, rowvar=False) +// >>> R3 +// array([[ 1. , 0.77598074, -0.47458546, -0.75078643, -0.9665554 , +// 0.22423734], +// [ 0.77598074, 1. , -0.92346708, -0.99923895, -0.58826587, +// -0.44069024], +// [-0.47458546, -0.92346708, 1. , 0.93773029, 0.23297648, +// 0.75137473], +// [-0.75078643, -0.99923895, 0.93773029, 1. , 0.55627469, +// 0.47536961], +// [-0.9665554 , -0.58826587, 0.23297648, 0.55627469, 1. , +// -0.46666491], +// [ 0.22423734, -0.44069024, 0.75137473, 0.47536961, -0.46666491, +// 1. ]]) +// +// +// +//go:linkname Corrcoef py.corrcoef +func Corrcoef(x *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object) *py.Object +// +// Return the indices to access (n, n) arrays, given a masking function. +// +// Assume `mask_func` is a function that, for a square array a of size +// ``(n, n)`` with a possible offset argument `k`, when called as +// ``mask_func(a, k)`` returns a new array with zeros in certain locations +// (functions like `triu` or `tril` do precisely this). Then this function +// returns the indices where the non-zero values would be located. +// +// Parameters +// ---------- +// n : int +// The returned indices will be valid to access arrays of shape (n, n). +// mask_func : callable +// A function whose call signature is similar to that of `triu`, `tril`. +// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. +// `k` is an optional argument to the function. +// k : scalar +// An optional argument which is passed through to `mask_func`. Functions +// like `triu`, `tril` take a second argument that is interpreted as an +// offset. +// +// Returns +// ------- +// indices : tuple of arrays. +// The `n` arrays of indices corresponding to the locations where +// ``mask_func(np.ones((n, n)), k)`` is True. +// +// See Also +// -------- +// triu, tril, triu_indices, tril_indices +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// These are the indices that would allow you to access the upper triangular +// part of any 3x3 array: +// +// >>> iu = np.mask_indices(3, np.triu) +// +// For example, if `a` is a 3x3 array: +// +// >>> a = np.arange(9).reshape(3, 3) +// >>> a +// array([[0, 1, 2], +// [3, 4, 5], +// [6, 7, 8]]) +// >>> a[iu] +// array([0, 1, 2, 4, 5, 8]) +// +// An offset can be passed also to the masking function. This gets us the +// indices starting on the first diagonal right of the main one: +// +// >>> iu1 = np.mask_indices(3, np.triu, 1) +// +// with which we now extract only three elements: +// +// >>> a[iu1] +// array([1, 2, 5]) +// +// +// +//go:linkname MaskIndices py.mask_indices +func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object +// +// lexsort(keys, axis=-1) +// +// Perform an indirect stable sort using a sequence of keys. +// +// Given multiple sorting keys, which can be interpreted as columns in a +// spreadsheet, lexsort returns an array of integer indices that describes +// the sort order by multiple columns. The last key in the sequence is used +// for the primary sort order, the second-to-last key for the secondary sort +// order, and so on. The keys argument must be a sequence of objects that +// can be converted to arrays of the same shape. If a 2D array is provided +// for the keys argument, its rows are interpreted as the sorting keys and +// sorting is according to the last row, second last row etc. +// +// Parameters +// ---------- +// keys : (k, N) array or tuple containing k (N,)-shaped sequences +// The `k` different "columns" to be sorted. The last column (or row if +// `keys` is a 2D array) is the primary sort key. +// axis : int, optional +// Axis to be indirectly sorted. By default, sort over the last axis. +// +// Returns +// ------- +// indices : (N,) ndarray of ints +// Array of indices that sort the keys along the specified axis. +// +// See Also +// -------- +// argsort : Indirect sort. +// ndarray.sort : In-place sort. +// sort : Return a sorted copy of an array. +// +// Examples +// -------- +// Sort names: first by surname, then by name. +// +// >>> surnames = ('Hertz', 'Galilei', 'Hertz') +// >>> first_names = ('Heinrich', 'Galileo', 'Gustav') +// >>> ind = np.lexsort((first_names, surnames)) +// >>> ind +// array([1, 2, 0]) +// +// >>> [surnames[i] + ", " + first_names[i] for i in ind] +// ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich'] +// +// Sort two columns of numbers: +// +// >>> a = [1,5,1,4,3,4,4] # First column +// >>> b = [9,4,0,4,0,2,1] # Second column +// >>> ind = np.lexsort((b,a)) # Sort by a, then by b +// >>> ind +// array([2, 0, 4, 6, 5, 3, 1]) +// +// >>> [(a[i],b[i]) for i in ind] +// [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)] +// +// Note that sorting is first according to the elements of ``a``. +// Secondary sorting is according to the elements of ``b``. +// +// A normal ``argsort`` would have yielded: +// +// >>> [(a[i],b[i]) for i in np.argsort(a)] +// [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)] +// +// Structured arrays are sorted lexically by ``argsort``: +// +// >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)], +// ... dtype=np.dtype([('x', int), ('y', int)])) +// +// >>> np.argsort(x) # or np.argsort(x, order=('x', 'y')) +// array([2, 0, 4, 6, 5, 3, 1]) +// +// +// +//go:linkname Lexsort py.lexsort +func Lexsort(keys *py.Object, axis *py.Object) *py.Object +// +// Return an array representing the indices of a grid. +// +// Compute an array where the subarrays contain index values 0, 1, ... +// varying only along the corresponding axis. +// +// Parameters +// ---------- +// dimensions : sequence of ints +// The shape of the grid. +// dtype : dtype, optional +// Data type of the result. +// sparse : boolean, optional +// Return a sparse representation of the grid instead of a dense +// representation. Default is False. +// +// .. versionadded:: 1.17 +// +// Returns +// ------- +// grid : one ndarray or tuple of ndarrays +// If sparse is False: +// Returns one array of grid indices, +// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. +// If sparse is True: +// Returns a tuple of arrays, with +// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with +// dimensions[i] in the ith place +// +// See Also +// -------- +// mgrid, ogrid, meshgrid +// +// Notes +// ----- +// The output shape in the dense case is obtained by prepending the number +// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` +// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is +// ``(N, r0, ..., rN-1)``. +// +// The subarrays ``grid[k]`` contains the N-D array of indices along the +// ``k-th`` axis. Explicitly:: +// +// grid[k, i0, i1, ..., iN-1] = ik +// +// Examples +// -------- +// >>> grid = np.indices((2, 3)) +// >>> grid.shape +// (2, 2, 3) +// >>> grid[0] # row indices +// array([[0, 0, 0], +// [1, 1, 1]]) +// >>> grid[1] # column indices +// array([[0, 1, 2], +// [0, 1, 2]]) +// +// The indices can be used as an index into an array. +// +// >>> x = np.arange(20).reshape(5, 4) +// >>> row, col = np.indices((2, 3)) +// >>> x[row, col] +// array([[0, 1, 2], +// [4, 5, 6]]) +// +// Note that it would be more straightforward in the above example to +// extract the required elements directly with ``x[:2, :3]``. +// +// If sparse is set to true, the grid will be returned in a sparse +// representation. +// +// >>> i, j = np.indices((2, 3), sparse=True) +// >>> i.shape +// (2, 1) +// >>> j.shape +// (1, 3) +// >>> i # row indices +// array([[0], +// [1]]) +// >>> j # column indices +// array([[0, 1, 2]]) +// +// +// +//go:linkname Indices py.indices +func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object +// +// Compute the standard deviation along the specified axis. +// +// Returns the standard deviation, a measure of the spread of a distribution, +// of the array elements. The standard deviation is computed for the +// flattened array by default, otherwise over the specified axis. +// +// Parameters +// ---------- +// a : array_like +// Calculate the standard deviation of these values. +// axis : None or int or tuple of ints, optional +// Axis or axes along which the standard deviation is computed. The +// default is to compute the standard deviation of the flattened array. +// +// .. versionadded:: 1.7.0 +// +// If this is a tuple of ints, a standard deviation is performed over +// multiple axes, instead of a single axis or all the axes as before. +// dtype : dtype, optional +// Type to use in computing the standard deviation. For arrays of +// integer type the default is float64, for arrays of float types it is +// the same as the array type. +// out : ndarray, optional +// Alternative output array in which to place the result. It must have +// the same shape as the expected output but the type (of the calculated +// values) will be cast if necessary. +// ddof : int, optional +// Means Delta Degrees of Freedom. The divisor used in calculations +// is ``N - ddof``, where ``N`` represents the number of elements. +// By default `ddof` is zero. +// 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 input array. +// +// If the default value is passed, then `keepdims` will not be +// passed through to the `std` method of sub-classes of +// `ndarray`, however any non-default value will be. If the +// sub-class' method does not implement `keepdims` any +// exceptions will be raised. +// +// where : array_like of bool, optional +// Elements to include in the standard deviation. +// See `~numpy.ufunc.reduce` for details. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// standard_deviation : ndarray, see dtype parameter above. +// If `out` is None, return a new array containing the standard deviation, +// otherwise return a reference to the output array. +// +// See Also +// -------- +// var, mean, nanmean, nanstd, nanvar +// :ref:`ufuncs-output-type` +// +// Notes +// ----- +// The standard deviation is the square root of the average of the squared +// deviations from the mean, i.e., ``std = sqrt(mean(x))``, where +// ``x = abs(a - a.mean())**2``. +// +// The average squared deviation is typically calculated as ``x.sum() / N``, +// where ``N = len(x)``. If, however, `ddof` is specified, the divisor +// ``N - ddof`` is used instead. In standard statistical practice, ``ddof=1`` +// provides an unbiased estimator of the variance of the infinite population. +// ``ddof=0`` provides a maximum likelihood estimate of the variance for +// normally distributed variables. The standard deviation computed in this +// function is the square root of the estimated variance, so even with +// ``ddof=1``, it will not be an unbiased estimate of the standard deviation +// per se. +// +// Note that, for complex numbers, `std` takes the absolute +// value before squaring, so that the result is always real and nonnegative. +// +// For floating-point input, the *std* is computed using the same +// precision the input has. Depending on the input data, this can cause +// the results to be inaccurate, especially for float32 (see example below). +// Specifying a higher-accuracy accumulator using the `dtype` keyword can +// alleviate this issue. +// +// Examples +// -------- +// >>> a = np.array([[1, 2], [3, 4]]) +// >>> np.std(a) +// 1.1180339887498949 # may vary +// >>> np.std(a, axis=0) +// array([1., 1.]) +// >>> np.std(a, axis=1) +// array([0.5, 0.5]) +// +// In single precision, std() can be inaccurate: +// +// >>> a = np.zeros((2, 512*512), dtype=np.float32) +// >>> a[0, :] = 1.0 +// >>> a[1, :] = 0.1 +// >>> np.std(a) +// 0.45000005 +// +// Computing the standard deviation in float64 is more accurate: +// +// >>> np.std(a, dtype=np.float64) +// 0.44999999925494177 # may vary +// +// Specifying a where argument: +// +// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) +// >>> np.std(a) +// 2.614064523559687 # may vary +// >>> np.std(a, where=[[True], [True], [False]]) +// 2.0 +// +// +// +//go:linkname Std py.std +func Std(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object +//go:linkname Absolute py.absolute +func Absolute(__llgo_va_list ...interface{}) *py.Object +//go:linkname Add py.add +func Add(__llgo_va_list ...interface{}) *py.Object +// geterrobj() +// +// Return the current object that defines floating-point error handling. +// +// The error object contains all information that defines the error handling +// behavior in NumPy. `geterrobj` is used internally by the other +// functions that get and set error handling behavior (`geterr`, `seterr`, +// `geterrcall`, `seterrcall`). +// +// Returns +// ------- +// errobj : list +// The error object, a list containing three elements: +// [internal numpy buffer size, error mask, error callback function]. +// +// The error mask is a single integer that holds the treatment information +// on all four floating point errors. The information for each error type +// is contained in three bits of the integer. If we print it in base 8, we +// can see what treatment is set for "invalid", "under", "over", and +// "divide" (in that order). The printed string can be interpreted with +// +// * 0 : 'ignore' +// * 1 : 'warn' +// * 2 : 'raise' +// * 3 : 'call' +// * 4 : 'print' +// * 5 : 'log' +// +// See Also +// -------- +// seterrobj, seterr, geterr, seterrcall, geterrcall +// getbufsize, setbufsize // -// See Also -// -------- -// arcsin, sinh, cos +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. // -// Notes -// ----- -// The sine is one of the fundamental functions of trigonometry (the -// mathematical study of triangles). Consider a circle of radius 1 -// centered on the origin. A ray comes in from the :math:`+x` axis, makes -// an angle at the origin (measured counter-clockwise from that axis), and -// departs from the origin. The :math:`y` coordinate of the outgoing -// ray's intersection with the unit circle is the sine of that angle. It -// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The -// function has zeroes where the angle is a multiple of :math:`\pi`. -// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. -// The numerous properties of the sine and related functions are included -// in any standard trigonometry text. +// Examples +// -------- +// >>> np.geterrobj() # first get the defaults +// [8192, 521, None] // -// Examples -// -------- -// >>> import numpy as np +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// ... +// >>> old_bufsize = np.setbufsize(20000) +// >>> old_err = np.seterr(divide='raise') +// >>> old_handler = np.seterrcall(err_handler) +// >>> np.geterrobj() +// [8192, 521, ] // -// Print sine of one angle: +// >>> old_err = np.seterr(all='ignore') +// >>> np.base_repr(np.geterrobj()[1], 8) +// '0' +// >>> old_err = np.seterr(divide='warn', over='log', under='call', +// ... invalid='print') +// >>> np.base_repr(np.geterrobj()[1], 8) +// '4351' // -// >>> np.sin(np.pi/2.) -// 1.0 +//go:linkname Geterrobj py.geterrobj +func Geterrobj() *py.Object // -// Print sines of an array of angles given in degrees: +// Get help information for an array, function, class, or module. // -// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) -// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) +// Parameters +// ---------- +// object : object or str, optional +// Input object or name to get information about. If `object` is +// an `ndarray` instance, information about the array is printed. +// If `object` is a numpy object, its docstring is given. If it is +// a string, available modules are searched for matching objects. +// If None, information about `info` itself is returned. +// maxwidth : int, optional +// Printing width. +// output : file like object, optional +// File like object that the output is written to, default is +// ``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. // -// Plot the sine function: +// See Also +// -------- +// source, lookfor // -// >>> import matplotlib.pylab as plt -// >>> x = np.linspace(-np.pi, np.pi, 201) -// >>> plt.plot(x, np.sin(x)) -// >>> plt.xlabel('Angle [rad]') -// >>> plt.ylabel('sin(x)') -// >>> plt.axis('tight') -// >>> plt.show() +// Notes +// ----- +// When used interactively with an object, ``np.info(obj)`` is equivalent +// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython +// prompt. // -//go:linkname Sin py.sin -func Sin(x *py.Object, out *py.Object) *py.Object -// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Examples +// -------- +// >>> np.info(np.polyval) # doctest: +SKIP +// polyval(p, x) +// Evaluate the polynomial p at x. +// ... // -// Test element-wise for finiteness (not infinity and not Not a Number). +// When using a string for `object` it is possible to get multiple results. // -// The result is returned as a boolean array. +// >>> np.info('fft') # doctest: +SKIP +// *** Found in numpy *** +// Core FFT routines +// ... +// *** Found in numpy.fft *** +// fft(a, n=None, axis=-1) +// ... +// *** Repeat reference found in numpy.fft.fftpack *** +// *** Total of 3 references found. *** // -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// When the argument is an array, information about the array is printed. // -// Returns -// ------- -// y : ndarray, bool -// True where ``x`` is not positive infinity, negative infinity, -// or NaN; false otherwise. -// This is a scalar if `x` is a scalar. +// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) +// >>> np.info(a) +// class: ndarray +// shape: (2, 3) +// strides: (24, 8) +// itemsize: 8 +// aligned: True +// contiguous: True +// fortran: False +// data pointer: 0x562b6e0d2860 # may vary +// byteorder: little +// byteswap: False +// type: complex64 // -// See Also -// -------- -// isinf, isneginf, isposinf, isnan // -// Notes -// ----- -// Not a Number, positive infinity and negative infinity are considered -// to be non-finite. // -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// Also that positive infinity is not equivalent to negative infinity. But -// infinity is equivalent to positive infinity. Errors result if the -// second argument is also supplied when `x` is a scalar input, or if -// first and second arguments have different shapes. +//go:linkname Info py.info +func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object +// fromiter(iter, dtype, count=-1, *, like=None) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.isfinite(1) -// True -// >>> np.isfinite(0) -// True -// >>> np.isfinite(np.nan) -// False -// >>> np.isfinite(np.inf) -// False -// >>> np.isfinite(-np.inf) -// False -// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) -// array([False, True, False]) +// Create a new 1-dimensional array from an iterable object. // -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isfinite(x, y) -// array([0, 1, 0]) -// >>> y -// array([0, 1, 0]) +// Parameters +// ---------- +// iter : iterable object +// An iterable object providing data for the array. +// dtype : data-type +// The data-type of the returned array. // -//go:linkname Isfinite py.isfinite -func Isfinite(x *py.Object, out *py.Object) *py.Object -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// .. versionchanged:: 1.23 +// Object and subarray dtypes are now supported (note that the final +// result is not 1-D for a subarray dtype). // -// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. +// count : int, optional +// The number of items to read from *iterable*. The default is -1, +// which means all data is read. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. // -// The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is -// the signed angle in radians between the ray ending at the origin and -// passing through the point (1,0), and the ray ending at the origin and -// passing through the point (`x2`, `x1`). (Note the role reversal: the -// "`y`-coordinate" is the first function parameter, the "`x`-coordinate" -// is the second.) By IEEE convention, this function is defined for -// `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see -// Notes for specific values). +// .. versionadded:: 1.20.0 // -// This function is not defined for complex-valued arguments; for the -// so-called argument of complex values, use `angle`. +// Returns +// ------- +// out : ndarray +// The output array. // -// Parameters -// ---------- -// x1 : array_like, real-valued -// `y`-coordinates. -// x2 : array_like, real-valued -// `x`-coordinates. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Notes +// ----- +// Specify `count` to improve performance. It allows ``fromiter`` to +// pre-allocate the output array, instead of resizing it on demand. // -// Returns -// ------- -// angle : ndarray -// Array of angles in radians, in the range ``[-pi, pi]``. -// This is a scalar if both `x1` and `x2` are scalars. +// Examples +// -------- +// >>> iterable = (x*x for x in range(5)) +// >>> np.fromiter(iterable, float) +// array([ 0., 1., 4., 9., 16.]) // -// See Also -// -------- -// arctan, tan, angle +// A carefully constructed subarray dtype will lead to higher dimensional +// results: // -// Notes -// ----- -// *arctan2* is identical to the `atan2` function of the underlying -// C library. The following special values are defined in the C -// standard: [1]_ +// >>> 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]]) +// +//go:linkname Fromiter py.fromiter +func Fromiter(iter *py.Object, dtype *py.Object, count *py.Object) *py.Object +// Context manager for setting print options. // -// ====== ====== ================ -// `x1` `x2` `arctan2(x1,x2)` -// ====== ====== ================ -// +/- 0 +0 +/- 0 -// +/- 0 -0 +/- pi -// > 0 +/-inf +0 / +pi -// < 0 +/-inf -0 / -pi -// +/-inf +inf +/- (pi/4) -// +/-inf -inf +/- (3*pi/4) -// ====== ====== ================ +// Set print options for the scope of the `with` block, and restore the old +// options at the end. See `set_printoptions` for the full description of +// available options. // -// Note that +0 and -0 are distinct floating point numbers, as are +inf -// and -inf. +// Examples +// -------- // -// References -// ---------- -// .. [1] ISO/IEC standard 9899:1999, "Programming language C." +// >>> from numpy.testing import assert_equal +// >>> with np.printoptions(precision=2): +// ... np.array([2.0]) / 3 +// array([0.67]) // -// Examples -// -------- +// The `as`-clause of the `with`-statement gives the current print options: // -// Consider four points in different quadrants: +// >>> with np.printoptions(precision=2) as opts: +// ... assert_equal(opts, np.get_printoptions()) // -// >>> import numpy as np -// >>> x = np.array([-1, +1, +1, -1]) -// >>> y = np.array([-1, -1, +1, +1]) -// >>> np.arctan2(y, x) * 180 / np.pi -// array([-135., -45., 45., 135.]) +// See Also +// -------- +// set_printoptions, get_printoptions // -// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 -// and at several other special points, obtaining values in -// the range ``[-pi, pi]``: // -// >>> 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]) // -//go:linkname Arctan2 py.arctan2 -func Arctan2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, -// like=None) +//go:linkname Printoptions py.printoptions +func Printoptions(__llgo_va_list ...interface{}) *py.Object // -// Create an array. +// Return an ndarray of the provided type that satisfies requirements. +// +// This function is useful to be sure that an array with the correct flags +// is returned for passing to compiled code (perhaps through ctypes). // // Parameters // ---------- -// object : array_like -// An array, any object exposing the array interface, an object whose -// ``__array__`` method returns an array, or any (nested) sequence. -// If object is a scalar, a 0-dimensional array containing object is -// returned. -// dtype : data-type, optional -// The desired data-type for the array. If not given, NumPy will try to use -// a default ``dtype`` that can represent the values (by applying promotion -// rules when necessary.) -// copy : bool, optional -// If ``True`` (default), then the array data is copied. If ``None``, -// a copy will only be made if ``__array__`` returns a copy, if obj is -// a nested sequence, or if a copy is needed to satisfy any of the other -// requirements (``dtype``, ``order``, etc.). Note that any copy of -// the data is shallow, i.e., for arrays with object dtype, the new -// array will point to the same objects. See Examples for `ndarray.copy`. -// For ``False`` it raises a ``ValueError`` if a copy cannot be avoided. -// Default: ``True``. -// order : {'K', 'A', 'C', 'F'}, optional -// Specify the memory layout of the array. If object is not an array, the -// newly created array will be in C order (row major) unless 'F' is -// specified, in which case it will be in Fortran order (column major). -// If object is an array the following holds. -// -// ===== ========= =================================================== -// order no copy copy=True -// ===== ========= =================================================== -// 'K' unchanged F & C order preserved, otherwise most similar order -// 'A' unchanged F order if input is F and not C, otherwise C order -// 'C' C order C order -// 'F' F order F order -// ===== ========= =================================================== +// a : array_like +// The object to be converted to a type-and-requirement-satisfying array. +// dtype : data-type +// 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 sequence of str +// The requirements list can be any of the following // -// When ``copy=None`` and a copy is made for other reasons, the result is -// the same as if ``copy=True``, with some exceptions for 'A', see the -// Notes section. The default order is 'K'. -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise -// 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 prepended to the shape as -// needed to meet this requirement. +// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array +// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array +// * 'ALIGNED' ('A') - ensure a data-type aligned array +// * 'WRITEABLE' ('W') - ensure a writable array +// * 'OWNDATA' ('O') - ensure an array that owns its own data +// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass // 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 @@ -19683,465 +19007,539 @@ func Arctan2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // Returns // ------- // out : ndarray -// An array object satisfying the specified requirements. +// Array with specified requirements and type if given. // // See Also // -------- -// empty_like : Return an empty array with shape and type of input. -// ones_like : Return an array of ones with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. -// copy: Return an array copy of the given object. -// +// asarray : Convert input to an ndarray. +// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. +// ascontiguousarray : Convert input to a contiguous array. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// ndarray.flags : Information about the memory layout of the array. // // Notes // ----- -// When order is 'A' and ``object`` is an array in neither 'C' nor 'F' order, -// and a copy is forced by a change in dtype, then the order of the result is -// not necessarily 'C' as expected. This is likely a bug. +// The returned array will be guaranteed to have the listed requirements +// by making a copy if needed. // // Examples // -------- -// >>> import numpy as np -// >>> np.array([1, 2, 3]) -// array([1, 2, 3]) +// >>> x = np.arange(6).reshape(2,3) +// >>> x.flags +// C_CONTIGUOUS : True +// F_CONTIGUOUS : False +// OWNDATA : False +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False // -// Upcasting: +// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) +// >>> y.flags +// C_CONTIGUOUS : False +// F_CONTIGUOUS : True +// OWNDATA : True +// WRITEABLE : True +// ALIGNED : True +// WRITEBACKIFCOPY : False // -// >>> np.array([1, 2, 3.0]) -// array([ 1., 2., 3.]) // -// More than one dimension: // -// >>> np.array([[1, 2], [3, 4]]) -// array([[1, 2], -// [3, 4]]) +//go:linkname Require py.require +func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object // -// Minimum dimensions 2: +// Take values from the input array by matching 1d index and data slices. // -// >>> np.array([1, 2, 3], ndmin=2) -// array([[1, 2, 3]]) +// This iterates over matching 1d slices oriented along the specified axis in +// the index and data arrays, and uses the former to look up values in the +// latter. These slices can be different lengths. // -// Type provided: +// Functions returning an index along an axis, like `argsort` and +// `argpartition`, produce suitable indices for this function. // -// >>> np.array([1, 2, 3], dtype=complex) -// array([ 1.+0.j, 2.+0.j, 3.+0.j]) +// .. versionadded:: 1.15.0 // -// Data-type consisting of more than one element: +// Parameters +// ---------- +// arr : ndarray (Ni..., M, Nk...) +// Source array +// indices : ndarray (Ni..., J, Nk...) +// Indices to take along each 1d slice of `arr`. This must match the +// dimension of arr, but dimensions Ni and Nj only need to broadcast +// against `arr`. +// axis : int +// The axis to take 1d slices along. If axis is None, the input array is +// treated as if it had first been flattened to 1d, for consistency with +// `sort` and `argsort`. // -// >>> x = np.array([(1,2),(3,4)],dtype=[('a','>> x['a'] -// array([1, 3], dtype=int32) +// Returns +// ------- +// out: ndarray (Ni..., J, Nk...) +// The indexed result. // -// Creating an array from sub-classes: +// Notes +// ----- +// This is equivalent to (but faster than) the following use of `ndindex` and +// `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: // -// >>> np.array(np.asmatrix('1 2; 3 4')) -// array([[1, 2], -// [3, 4]]) +// Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] +// J = indices.shape[axis] # Need not equal M +// out = np.empty(Ni + (J,) + Nk) // -// >>> np.array(np.asmatrix('1 2; 3 4'), subok=True) -// matrix([[1, 2], -// [3, 4]]) +// for ii in ndindex(Ni): +// for kk in ndindex(Nk): +// a_1d = a [ii + s_[:,] + kk] +// indices_1d = indices[ii + s_[:,] + kk] +// out_1d = out [ii + s_[:,] + kk] +// for j in range(J): +// out_1d[j] = a_1d[indices_1d[j]] // -//go:linkname Array py.array -func Array(object *py.Object, dtype *py.Object) *py.Object -// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Equivalently, eliminating the inner loop, the last two lines would be:: // -// Compute the absolute values element-wise. +// out_1d[:] = a_1d[indices_1d] // -// This function returns the absolute values (positive magnitude) of the -// data in `x`. Complex values are not handled, use `absolute` to find the -// absolute values of complex data. +// See Also +// -------- +// take : Take along an axis, using the same indices for every 1d slice +// put_along_axis : +// Put values into the destination array by matching 1d index and data slices // -// Parameters -// ---------- -// x : array_like -// The array of numbers for which the absolute values are required. If -// `x` is a scalar, the result `y` will also be a scalar. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Examples +// -------- // -// Returns -// ------- -// y : ndarray or scalar -// The absolute values of `x`, the returned values are always floats. -// This is a scalar if `x` is a scalar. +// For this sample array +// +// >>> a = np.array([[10, 30, 20], [60, 40, 50]]) +// +// We can sort either by using sort directly, or argsort and this function +// +// >>> np.sort(a, axis=1) +// array([[10, 20, 30], +// [40, 50, 60]]) +// >>> ai = np.argsort(a, axis=1) +// >>> ai +// array([[0, 2, 1], +// [1, 2, 0]]) +// >>> np.take_along_axis(a, ai, axis=1) +// array([[10, 20, 30], +// [40, 50, 60]]) // -// See Also -// -------- -// absolute : Absolute values including `complex` types. +// The same works for max and min, if you maintain the trivial dimension +// with ``keepdims``: // -// Examples -// -------- -// >>> import numpy as np -// >>> np.fabs(-1) -// 1.0 -// >>> np.fabs([-1.2, 1.2]) -// array([ 1.2, 1.2]) +// >>> np.max(a, axis=1, keepdims=True) +// array([[30], +// [60]]) +// >>> ai = np.argmax(a, axis=1, keepdims=True) +// >>> ai +// array([[1], +// [0]]) +// >>> np.take_along_axis(a, ai, axis=1) +// array([[30], +// [60]]) // -//go:linkname Fabs py.fabs -func Fabs(x *py.Object, out *py.Object) *py.Object +// If we want to get the max and min at the same time, we can stack the +// indices first // -// Returns a boolean array where two arrays are element-wise equal within a -// tolerance. +// >>> ai_min = np.argmin(a, axis=1, keepdims=True) +// >>> ai_max = np.argmax(a, axis=1, keepdims=True) +// >>> ai = np.concatenate([ai_min, ai_max], axis=1) +// >>> ai +// array([[0, 1], +// [1, 0]]) +// >>> np.take_along_axis(a, ai, axis=1) +// array([[10, 30], +// [40, 60]]) // -// The tolerance values are positive, typically very small numbers. The -// relative difference (`rtol` * abs(`b`)) and the absolute difference -// `atol` are added together to compare against the absolute difference -// between `a` and `b`. // -// .. warning:: The default `atol` is not appropriate for comparing numbers -// with magnitudes much smaller than one (see Notes). +//go:linkname TakeAlongAxis py.take_along_axis +func TakeAlongAxis(arr *py.Object, indices *py.Object, axis *py.Object) *py.Object +// asanyarray(a, dtype=None, order=None, *, like=None) +// +// Convert the input to an ndarray, but pass ndarray subclasses through. // // Parameters // ---------- -// a, b : array_like -// Input arrays to compare. -// rtol : array_like -// The relative tolerance parameter (see Notes). -// atol : array_like -// The absolute tolerance parameter (see Notes). -// equal_nan : bool -// Whether to compare NaN's as equal. If True, NaN's in `a` will be -// considered equal to NaN's in `b` in the output array. +// a : array_like +// Input data, in any form that can be converted to an array. This +// includes scalars, lists, lists of tuples, tuples, tuples of tuples, +// tuples of lists, and ndarrays. +// dtype : data-type, optional +// By default, the data-type is inferred from the input data. +// order : {'C', 'F', 'A', 'K'}, optional +// Memory layout. 'A' and 'K' depend on the order of input array a. +// 'C' row-major (C-style), +// 'F' column-major (Fortran-style) memory representation. +// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise +// 'K' (keep) preserve input order +// Defaults to 'C'. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // // Returns // ------- -// y : array_like -// Returns a boolean array of where `a` and `b` are equal within the -// given tolerance. If both `a` and `b` are scalars, returns a single -// boolean value. +// out : ndarray or an ndarray subclass +// Array interpretation of `a`. If `a` is an ndarray or a subclass +// of ndarray, it is returned as-is and no copy is performed. // // See Also // -------- -// allclose -// math.isclose +// asarray : Similar function which always returns ndarrays. +// ascontiguousarray : Convert input to a contiguous array. +// asfarray : Convert input to a floating point ndarray. +// asfortranarray : Convert input to an ndarray with column-major +// memory order. +// asarray_chkfinite : Similar function which checks input for NaNs and +// Infs. +// fromiter : Create an array from an iterator. +// fromfunction : Construct an array by executing a function on grid +// positions. // -// Notes -// ----- -// For finite values, isclose uses the following equation to test whether -// two floating point values are equivalent.:: +// Examples +// -------- +// Convert a list into an array: // -// absolute(a - b) <= (atol + rtol * absolute(b)) +// >>> a = [1, 2] +// >>> np.asanyarray(a) +// array([1, 2]) // -// Unlike the built-in `math.isclose`, the above equation is not symmetric -// in `a` and `b` -- it assumes `b` is the reference value -- so that -// `isclose(a, b)` might be different from `isclose(b, a)`. +// Instances of `ndarray` subclasses are passed through as-is: // -// The default value of `atol` is not appropriate when the reference value -// `b` has magnitude smaller than one. For example, it is unlikely that -// ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet -// ``isclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure -// to select `atol` for the use case at hand, especially for defining the -// threshold below which a non-zero value in `a` will be considered "close" -// to a very small or zero value in `b`. +// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray) +// >>> np.asanyarray(a) is a +// True // -// `isclose` is not defined for non-numeric data types. -// :class:`bool` is considered a numeric data-type for this purpose. +//go:linkname Asanyarray py.asanyarray +func Asanyarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object // -// Examples -// -------- -// >>> import numpy as np -// >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8]) -// array([ True, False]) +// empty_like(prototype, dtype=None, order='K', subok=True, shape=None) // -// >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9]) -// array([ True, True]) +// Return a new array with the same shape and type as a given array. // -// >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9]) -// array([False, True]) +// Parameters +// ---------- +// prototype : array_like +// The shape and data-type of `prototype` define these same attributes +// of the returned array. +// dtype : data-type, optional +// Overrides the data type of the result. // -// >>> np.isclose([1.0, np.nan], [1.0, np.nan]) -// array([ True, False]) +// .. versionadded:: 1.6.0 +// order : {'C', 'F', 'A', or 'K'}, optional +// Overrides the memory layout of the result. 'C' means C-order, +// 'F' means F-order, 'A' means 'F' if `prototype` is Fortran +// contiguous, 'C' otherwise. 'K' means match the layout of `prototype` +// as closely as possible. // -// >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) -// array([ True, True]) +// .. versionadded:: 1.6.0 +// subok : bool, optional. +// If True, then the newly created array will use the sub-class +// type of `prototype`, otherwise it will be a base-class array. Defaults +// to True. +// shape : int or sequence of ints, optional. +// Overrides the shape of the result. If order='K' and the number of +// dimensions is unchanged, will try to keep order, otherwise, +// order='C' is implied. // -// >>> np.isclose([1e-8, 1e-7], [0.0, 0.0]) -// array([ True, False]) +// .. versionadded:: 1.17.0 // -// >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0) -// array([False, False]) +// Returns +// ------- +// out : ndarray +// Array of uninitialized (arbitrary) data with the same +// shape and type as `prototype`. // -// >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0]) -// array([ True, True]) +// See Also +// -------- +// ones_like : Return an array of ones with shape and type of input. +// zeros_like : Return an array of zeros with shape and type of input. +// full_like : Return a new array with shape of input filled with value. +// empty : Return a new uninitialized array. // -// >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0) -// array([False, True]) +// Notes +// ----- +// This function does *not* initialize the returned array; to do that use +// `zeros_like` or `ones_like` instead. It may be marginally faster than +// the functions that do set the array values. // +// Examples +// -------- +// >>> a = ([1,2,3], [4,5,6]) # a is array-like +// >>> np.empty_like(a) +// array([[-1073741821, -1073741821, 3], # uninitialized +// [ 0, 0, -1073741821]]) +// >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) +// >>> np.empty_like(a) +// array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], # uninitialized +// [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]]) // // -//go:linkname Isclose py.isclose -func Isclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object // -// Return the shape of an array. +//go:linkname EmptyLike py.empty_like +func EmptyLike(prototype *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object +// +// Returns the indices of the maximum values along an axis. // // Parameters // ---------- // a : array_like // Input array. +// axis : int, optional +// By default, the index is into the flattened array, otherwise +// along the specified axis. +// out : array, optional +// If provided, the result will be inserted into this array. It should +// be of the appropriate shape and dtype. +// 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 array. +// +// .. versionadded:: 1.22.0 // // Returns // ------- -// shape : tuple of ints -// The elements of the shape tuple give the lengths of the -// corresponding array dimensions. +// index_array : ndarray of ints +// Array of indices into the array. It has the same shape as `a.shape` +// with the dimension along `axis` removed. If `keepdims` is set to True, +// then the size of `axis` will be 1 with the resulting array having same +// shape as `a.shape`. // // See Also // -------- -// len : ``len(a)`` is equivalent to ``np.shape(a)[0]`` for N-D arrays with -// ``N>=1``. -// ndarray.shape : Equivalent array method. +// ndarray.argmax, argmin +// amax : The maximum value along a given axis. +// unravel_index : Convert a flat index into an index tuple. +// take_along_axis : Apply ``np.expand_dims(index_array, axis)`` +// from argmax to an array as if by calling max. +// +// Notes +// ----- +// In case of multiple occurrences of the maximum values, the indices +// corresponding to the first occurrence are returned. // // Examples // -------- -// >>> import numpy as np -// >>> np.shape(np.eye(3)) -// (3, 3) -// >>> np.shape([[1, 3]]) +// >>> a = np.arange(6).reshape(2,3) + 10 +// >>> a +// array([[10, 11, 12], +// [13, 14, 15]]) +// >>> np.argmax(a) +// 5 +// >>> np.argmax(a, axis=0) +// array([1, 1, 1]) +// >>> np.argmax(a, axis=1) +// array([2, 2]) +// +// Indexes of the maximal elements of a N-dimensional array: +// +// >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape) +// >>> ind // (1, 2) -// >>> np.shape([0]) -// (1,) -// >>> np.shape(0) -// () +// >>> a[ind] +// 15 // -// >>> a = np.array([(1, 2), (3, 4), (5, 6)], -// ... dtype=[('x', 'i4'), ('y', 'i4')]) -// >>> np.shape(a) -// (3,) -// >>> a.shape -// (3,) +// >>> b = np.arange(6) +// >>> b[1] = 5 +// >>> b +// array([0, 5, 2, 3, 4, 5]) +// >>> np.argmax(b) # Only the first occurrence is returned. +// 1 +// +// >>> x = np.array([[4,2,3], [1,0,3]]) +// >>> index_array = np.argmax(x, axis=-1) +// >>> # Same as np.amax(x, axis=-1, keepdims=True) +// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) +// array([[4], +// [3]]) +// >>> # Same as np.amax(x, axis=-1) +// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) +// array([4, 3]) // +// Setting `keepdims` to `True`, // +// >>> x = np.arange(24).reshape((2, 3, 4)) +// >>> res = np.argmax(x, axis=1, keepdims=True) +// >>> res.shape +// (2, 1, 4) // -//go:linkname Shape py.shape -func Shape(a *py.Object) *py.Object -// arange([start,] stop[, step,], dtype=None, *, device=None, like=None) // -// Return evenly spaced values within a given interval. +//go:linkname Argmax py.argmax +func Argmax(a *py.Object, axis *py.Object, out *py.Object) *py.Object // -// ``arange`` can be called with a varying number of positional arguments: +// Return the cumulative product over the given axis. // -// * ``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``. +// .. deprecated:: 1.25.0 +// ``cumproduct`` is deprecated as of NumPy 1.25.0, and will be +// removed in NumPy 2.0. Please use `cumprod` instead. // -// 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. +// See Also +// -------- +// cumprod : equivalent function; see for details. // -// When using a non-integer step, such as 0.1, it is often better to use -// `numpy.linspace`. // -// See the Warning sections below for more information. +//go:linkname Cumproduct py.cumproduct +func Cumproduct(__llgo_va_list ...interface{}) *py.Object +// +// Interchange two axes of an array. // // Parameters // ---------- -// start : integer or real, optional -// Start of interval. The interval includes this value. The default -// start value is 0. -// stop : integer or real -// End of interval. The interval does not include this value, except -// in some cases where `step` is not an integer and floating point -// round-off affects the length of `out`. -// step : integer or real, optional -// Spacing between values. For any output `out`, this is the distance -// 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, optional -// The type of the output array. If `dtype` is not given, infer the data -// type from the other input arguments. -// device : str, optional -// The device on which to place the created array. Default: ``None``. -// For Array-API interoperability only, so must be ``"cpu"`` if passed. -// -// .. versionadded:: 2.0.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 +// a : array_like +// Input array. +// axis1 : int +// First axis. +// axis2 : int +// Second axis. // // Returns // ------- -// arange : ndarray -// Array of evenly spaced values. -// -// For floating point arguments, the length of the result is -// ``ceil((stop - start)/step)``. Because of floating point overflow, -// this rule may result in the last element of `out` being greater -// than `stop`. +// a_swapped : ndarray +// For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is +// returned; otherwise a new array is created. For earlier NumPy +// versions a view of `a` is returned only if the order of the +// axes is changed, otherwise the input array is returned. // -// Warnings +// Examples // -------- -// The length of the output might not be numerically stable. +// >>> x = np.array([[1,2,3]]) +// >>> np.swapaxes(x,0,1) +// array([[1], +// [2], +// [3]]) // -// Another stability issue is due to the internal implementation of -// `numpy.arange`. -// The actual step value used to populate the array is -// ``dtype(start + step) - dtype(start)`` and not `step`. Precision loss -// can occur here, due to casting or due to using floating points when -// `start` is much larger than `step`. This can lead to unexpected -// behaviour. For example:: +// >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]]) +// >>> x +// array([[[0, 1], +// [2, 3]], +// [[4, 5], +// [6, 7]]]) // -// >>> np.arange(0, 5, 0.5, dtype=int) -// array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) -// >>> np.arange(-3, 3, 0.5, dtype=int) -// array([-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]) +// >>> np.swapaxes(x,0,2) +// array([[[0, 4], +// [2, 6]], +// [[1, 5], +// [3, 7]]]) // -// 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 +//go:linkname Swapaxes py.swapaxes +func Swapaxes(a *py.Object, axis1 *py.Object, axis2 *py.Object) *py.Object +// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// 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` +// Compute bit-wise inversion, or bit-wise NOT, element-wise. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.arange(3) -// array([0, 1, 2]) -// >>> np.arange(3.0) -// array([ 0., 1., 2.]) -// >>> np.arange(3,7) -// array([3, 4, 5, 6]) -// >>> np.arange(3,7,2) -// array([3, 5]) +// Computes the bit-wise NOT of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``~``. // -//go:linkname Arange py.arange -func Arange(start *py.Object, stop *py.Object, step *py.Object, dtype *py.Object) *py.Object +// For signed integer inputs, the two's complement is returned. In a +// two's-complement system negative numbers are represented by the two's +// complement of the absolute value. This is the most common method of +// representing signed integers on computers [1]_. A N-bit +// two's-complement system can represent every integer in the range +// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. // -// Construct an array by executing a function over each coordinate. +// Parameters +// ---------- +// x : array_like +// Only integer and boolean types are handled. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// The resulting array therefore has a value ``fn(x, y, z)`` at -// coordinate ``(x, y, z)``. +// Returns +// ------- +// out : ndarray or scalar +// Result. +// This is a scalar if `x` is a scalar. // -// Parameters -// ---------- -// function : callable -// The function is called with N parameters, where N is the rank of -// `shape`. Each parameter represents the coordinates of the array -// varying along a specific axis. For example, if `shape` -// were ``(2, 2)``, then the parameters would be -// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` -// shape : (N,) tuple of ints -// Shape of the output array, which also determines the shape of -// the coordinate arrays passed to `function`. -// dtype : data-type, optional -// Data-type of the coordinate arrays passed to `function`. -// By default, `dtype` is float. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// See Also +// -------- +// bitwise_and, bitwise_or, bitwise_xor +// logical_not +// binary_repr : +// Return the binary representation of the input number as a string. // -// .. versionadded:: 1.20.0 +// Notes +// ----- +// `bitwise_not` is an alias for `invert`: // -// Returns -// ------- -// fromfunction : any -// The result of the call to `function` is passed back directly. -// Therefore the shape of `fromfunction` is completely determined by -// `function`. If `function` returns a scalar value, the shape of -// `fromfunction` would not match the `shape` parameter. +// >>> np.bitwise_not is np.invert +// True // -// See Also -// -------- -// indices, meshgrid +// References +// ---------- +// .. [1] Wikipedia, "Two's complement", +// https://en.wikipedia.org/wiki/Two's_complement // -// Notes -// ----- -// Keywords other than `dtype` and `like` are passed to `function`. +// Examples +// -------- +// We've seen that 13 is represented by ``00001101``. +// The invert or bit-wise NOT of 13 is then: // -// Examples -// -------- -// >>> import numpy as np -// >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) -// array([[0., 0.], -// [1., 1.]]) +// >>> x = np.invert(np.array(13, dtype=np.uint8)) +// >>> x +// 242 +// >>> np.binary_repr(x, width=8) +// '11110010' // -// >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) -// array([[0., 1.], -// [0., 1.]]) +// The result depends on the bit-width: // -// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) -// array([[ True, False, False], -// [False, True, False], -// [False, False, True]]) +// >>> x = np.invert(np.array(13, dtype=np.uint16)) +// >>> x +// 65522 +// >>> np.binary_repr(x, width=16) +// '1111111111110010' // -// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) -// array([[0, 1, 2], -// [1, 2, 3], -// [2, 3, 4]]) +// When using signed integer types the result is the two's complement of +// the result for the unsigned type: // +// >>> np.invert(np.array([13], dtype=np.int8)) +// array([-14], dtype=int8) +// >>> np.binary_repr(-14, width=8) +// '11110010' // +// Booleans are accepted as well: // -//go:linkname Fromfunction py.fromfunction -func Fromfunction(function *py.Object, shape *py.Object) *py.Object -// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> np.invert(np.array([True, False])) +// array([False, True]) // -// Compute the Heaviside step function. +// The ``~`` operator can be used as a shorthand for ``np.invert`` on +// ndarrays. // -// The Heaviside step function [1]_ is defined as:: +// >>> x1 = np.array([True, False]) +// >>> ~x1 +// array([False, True]) // -// 0 if x1 < 0 -// heaviside(x1, x2) = x2 if x1 == 0 -// 1 if x1 > 0 +//go:linkname Invert py.invert +func Invert(x *py.Object, out *py.Object) *py.Object +// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. +// Convert angles from degrees to radians. // // Parameters // ---------- -// x1 : array_like -// Input values. -// x2 : array_like -// The value of the function when x1 is 0. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Input array in degrees. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -20160,113 +19558,146 @@ func Fromfunction(function *py.Object, shape *py.Object) *py.Object // // Returns // ------- -// out : ndarray or scalar -// The output array, element-wise Heaviside step function of `x1`. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray +// The corresponding radian values. +// This is a scalar if `x` is a scalar. // -// References -// ---------- -// .. [1] Wikipedia, "Heaviside step function", -// https://en.wikipedia.org/wiki/Heaviside_step_function +// See Also +// -------- +// deg2rad : equivalent function // // Examples // -------- -// >>> import numpy as np -// >>> np.heaviside([-1.5, 0, 2.0], 0.5) -// array([ 0. , 0.5, 1. ]) -// >>> np.heaviside([-1.5, 0, 2.0], 1) -// array([ 0., 1., 1.]) +// Convert a degree array to radians // -//go:linkname Heaviside py.heaviside -func Heaviside(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -//go:linkname Log10 py.log10 -func Log10(__llgo_va_list ...interface{}) *py.Object -// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> deg = np.arange(12.) * 30. +// >>> np.radians(deg) +// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , +// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, +// 5.23598776, 5.75958653]) // -// Element-wise minimum of array elements. +// >>> out = np.zeros((deg.shape)) +// >>> ret = np.radians(deg, out) +// >>> ret is out +// True // -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. +//go:linkname Radians py.radians +func Radians(x *py.Object, out *py.Object) *py.Object +// fastCopyAndTranspose(a) // -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// .. deprecated:: 1.24 // -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. +// fastCopyAndTranspose is deprecated and will be removed. Use the copy and +// transpose methods instead, e.g. ``arr.T.copy()`` // -// See Also -// -------- -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. +//go:linkname FastCopyAndTranspose py.fastCopyAndTranspose +func FastCopyAndTranspose(a *py.Object) *py.Object // -// fmax, amax, nanmax +// Evenly round to the given number of decimals. // -// Notes -// ----- -// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when -// neither x1 nor x2 are NaNs, but it is faster and does proper -// broadcasting. +// Parameters +// ---------- +// a : array_like +// Input data. +// decimals : int, optional +// Number of decimal places to round to (default: 0). If +// decimals is negative, it specifies the number of positions to +// the left of the decimal point. +// out : ndarray, optional +// Alternative output array in which to place the result. It must have +// the same shape as the expected output, but the type of the output +// values will be cast if necessary. See :ref:`ufuncs-output-type` for more +// details. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.minimum([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) +// Returns +// ------- +// rounded_array : ndarray +// An array of the same type as `a`, containing the rounded values. +// Unless `out` was specified, a new array is created. A reference to +// the result is returned. // -// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) +// The real and imaginary parts of complex numbers are rounded +// separately. The result of rounding a float is a float. // -// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.minimum(-np.inf, 1) -// -inf +// See Also +// -------- +// ndarray.round : equivalent method +// around : an alias for this function +// ceil, fix, floor, rint, trunc // -//go:linkname Minimum py.minimum -func Minimum(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Return the fractional and integral parts of an array, element-wise. +// Notes +// ----- +// 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. // -// The fractional and integral parts are negative if the given number is -// negative. +// ``np.round`` uses a fast but sometimes inexact algorithm to round +// floating-point datatypes. For positive `decimals` it is equivalent to +// ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has +// error due to the inexact representation of decimal fractions in the IEEE +// floating point standard [1]_ and errors introduced when scaling by powers +// of ten. For instance, note the extra "1" in the following: +// +// >>> np.round(56294995342131.5, 3) +// 56294995342131.51 +// +// If your goal is to print such values with a fixed number of decimals, it is +// preferable to use numpy's float printing routines to limit the number of +// printed decimals: +// +// >>> np.format_float_positional(56294995342131.5, precision=3) +// '56294995342131.5' +// +// The float printing routines use an accurate but much more computationally +// demanding algorithm to compute the number of digits after the decimal +// point. +// +// Alternatively, Python's builtin `round` function uses a more accurate +// but slower algorithm for 64-bit floating point values: +// +// >>> round(56294995342131.5, 3) +// 56294995342131.5 +// >>> np.round(16.055, 2), round(16.055, 2) # equals 16.0549999999999997 +// (16.06, 16.05) +// +// +// References +// ---------- +// .. [1] "Lecture Notes on the Status of IEEE 754", William Kahan, +// https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF +// +// Examples +// -------- +// >>> np.round([0.37, 1.64]) +// array([0., 2.]) +// >>> np.round([0.37, 1.64], decimals=1) +// array([0.4, 1.6]) +// >>> np.round([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value +// array([0., 2., 2., 4., 4.]) +// >>> np.round([1,2,3,11], decimals=1) # ndarray of ints is returned +// array([ 1, 2, 3, 11]) +// >>> np.round([1,2,3,11], decimals=-1) +// array([ 0, 0, 0, 10]) +// +// +// +//go:linkname Round py.round +func Round(a *py.Object, decimals *py.Object, out *py.Object) *py.Object +// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the bit-wise AND of two arrays element-wise. +// +// Computes the bit-wise AND of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``&``. // // Parameters // ---------- -// x : array_like -// Input array. +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -20285,398 +19716,444 @@ func Minimum(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // // Returns // ------- -// y1 : ndarray -// Fractional part of `x`. -// This is a scalar if `x` is a scalar. -// y2 : ndarray -// Integral part of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// For integer input the return values are floats. +// out : ndarray or scalar +// Result. +// This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values -// switched, except it always has a positive remainder. +// logical_and +// bitwise_or +// bitwise_xor +// binary_repr : +// Return the binary representation of the input number as a string. // // Examples // -------- -// >>> import numpy as np -// >>> np.modf([0, 3.5]) -// (array([ 0. , 0.5]), array([ 0., 3.])) -// >>> np.modf(-0.5) -// (-0.5, -0) -// -//go:linkname Modf py.modf -func Modf(x *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise AND of 13 and 17 is +// therefore ``000000001``, or 1: // -// Return the indices of the elements that are non-zero. +// >>> np.bitwise_and(13, 17) +// 1 // -// Returns a tuple of arrays, one for each dimension of `a`, -// containing the indices of the non-zero elements in that -// dimension. The values in `a` are always tested and returned in -// row-major, C-style order. +// >>> np.bitwise_and(14, 13) +// 12 +// >>> np.binary_repr(12) +// '1100' +// >>> np.bitwise_and([14,3], 13) +// array([12, 1]) // -// To group the indices by element, rather than dimension, use `argwhere`, -// which returns a row for each non-zero element. +// >>> np.bitwise_and([11,7], [4,25]) +// array([0, 1]) +// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) +// array([ 2, 4, 16]) +// >>> np.bitwise_and([True, True], [False, True]) +// array([False, True]) // -// .. note:: +// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on +// ndarrays. // -// When called on a zero-d array or scalar, ``nonzero(a)`` is treated -// as ``nonzero(atleast_1d(a))``. +// >>> x1 = np.array([2, 5, 255]) +// >>> x2 = np.array([3, 14, 16]) +// >>> x1 & x2 +// array([ 2, 4, 16]) // -// .. deprecated:: 1.17.0 +//go:linkname BitwiseAnd py.bitwise_and +func BitwiseAnd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Use `atleast_1d` explicitly if this behavior is deliberate. +// Return the string representation of an array. // // Parameters // ---------- -// a : array_like +// arr : ndarray // Input array. +// max_line_width : int, optional +// Inserts newlines if text is longer than `max_line_width`. +// Defaults to ``numpy.get_printoptions()['linewidth']``. +// precision : int, optional +// Floating point precision. +// Defaults to ``numpy.get_printoptions()['precision']``. +// suppress_small : bool, optional +// Represent numbers "very close" to zero as zero; default is False. +// Very close is defined by precision: if the precision is 8, e.g., +// numbers smaller (in absolute value) than 5e-9 are represented as +// zero. +// Defaults to ``numpy.get_printoptions()['suppress']``. // // Returns // ------- -// tuple_of_arrays : tuple -// Indices of elements that are non-zero. +// string : str +// The string representation of an array. // // See Also // -------- -// flatnonzero : -// Return indices that are non-zero in the flattened version of the input -// array. -// ndarray.nonzero : -// Equivalent ndarray method. -// count_nonzero : -// Counts the number of non-zero elements in the input array. -// -// Notes -// ----- -// While the nonzero values can be obtained with ``a[nonzero(a)]``, it is -// recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which -// will correctly handle 0-d arrays. +// array_str, array2string, set_printoptions // // Examples // -------- -// >>> import numpy as np -// >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]]) -// >>> x -// array([[3, 0, 0], -// [0, 4, 0], -// [5, 6, 0]]) -// >>> np.nonzero(x) -// (array([0, 1, 2, 2]), array([0, 1, 0, 1])) +// >>> np.array_repr(np.array([1,2])) +// 'array([1, 2])' +// >>> np.array_repr(np.ma.array([0.])) +// 'MaskedArray([0.])' +// >>> np.array_repr(np.array([], np.int32)) +// 'array([], dtype=int32)' // -// >>> x[np.nonzero(x)] -// array([3, 4, 5, 6]) -// >>> np.transpose(np.nonzero(x)) -// array([[0, 0], -// [1, 1], -// [2, 0], -// [2, 1]]) +// >>> x = np.array([1e-6, 4e-7, 2, 3]) +// >>> np.array_repr(x, precision=6, suppress_small=True) +// 'array([0.000001, 0. , 2. , 3. ])' // -// A common use for ``nonzero`` is to find the indices of an array, where -// a condition is True. Given an array `a`, the condition `a` > 3 is a -// boolean array and since False is interpreted as 0, np.nonzero(a > 3) -// yields the indices of the `a` where the condition is true. // -// >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) -// >>> a > 3 -// array([[False, False, False], -// [ True, True, True], -// [ True, True, True]]) -// >>> np.nonzero(a > 3) -// (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) // -// Using this result to index `a` is equivalent to using the mask directly: +//go:linkname ArrayRepr py.array_repr +func ArrayRepr(arr *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object // -// >>> a[np.nonzero(a > 3)] -// array([4, 5, 6, 7, 8, 9]) -// >>> a[a > 3] # prefer this spelling -// array([4, 5, 6, 7, 8, 9]) +// Return a string representation of an array. // -// ``nonzero`` can also be called as a method of the array. +// Parameters +// ---------- +// a : ndarray +// Input array. +// max_line_width : int, optional +// Inserts newlines if text is longer than `max_line_width`. +// Defaults to ``numpy.get_printoptions()['linewidth']``. +// precision : int or None, optional +// Floating point precision. +// Defaults to ``numpy.get_printoptions()['precision']``. +// suppress_small : bool, optional +// Represent numbers "very close" to zero as zero; default is False. +// Very close is defined by precision: if the precision is 8, e.g., +// numbers smaller (in absolute value) than 5e-9 are represented as +// zero. +// Defaults to ``numpy.get_printoptions()['suppress']``. +// separator : str, optional +// Inserted between elements. +// prefix : str, optional +// suffix : str, optional +// The length of the prefix and suffix strings are used to respectively +// align and wrap the output. An array is typically printed as:: // -// >>> (a > 3).nonzero() -// (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) +// prefix + array2string(a) + suffix // +// The output is left-padded by the length of the prefix string, and +// wrapping is forced at the column ``max_line_width - len(suffix)``. +// It should be noted that the content of prefix and suffix strings are +// not included in the output. +// style : _NoValue, optional +// Has no effect, do not use. +// +// .. deprecated:: 1.14.0 +// formatter : dict of callables, optional +// If not None, the keys should indicate the type(s) that the respective +// formatting function applies to. Callables should return a string. +// Types that are not specified (by their corresponding keys) are handled +// by the default formatters. Individual types for which a formatter +// can be set are: // +// - 'bool' +// - 'int' +// - 'timedelta' : a `numpy.timedelta64` +// - 'datetime' : a `numpy.datetime64` +// - 'float' +// - 'longfloat' : 128-bit floats +// - 'complexfloat' +// - 'longcomplexfloat' : composed of two 128-bit floats +// - 'void' : type `numpy.void` +// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` // -//go:linkname Nonzero py.nonzero -func Nonzero(__llgo_va_list ...interface{}) *py.Object +// Other keys that can be used to set a group of types at once are: // -// Check if the array is Fortran contiguous but *not* C contiguous. +// - 'all' : sets all types +// - 'int_kind' : sets 'int' +// - 'float_kind' : sets 'float' and 'longfloat' +// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' +// - 'str_kind' : sets 'numpystr' +// threshold : int, optional +// Total number of array elements which trigger summarization +// rather than full repr. +// Defaults to ``numpy.get_printoptions()['threshold']``. +// edgeitems : int, optional +// Number of array items in summary at beginning and end of +// each dimension. +// Defaults to ``numpy.get_printoptions()['edgeitems']``. +// sign : string, either '-', '+', or ' ', optional +// Controls printing of the sign of floating-point types. If '+', always +// print the sign of positive values. If ' ', always prints a space +// (whitespace character) in the sign position of positive values. If +// '-', omit the sign character of positive values. +// Defaults to ``numpy.get_printoptions()['sign']``. +// floatmode : str, optional +// Controls the interpretation of the `precision` option for +// floating-point types. +// Defaults to ``numpy.get_printoptions()['floatmode']``. +// Can take the following values: // -// This function is obsolete. If you only want to check if an array is Fortran -// contiguous use ``a.flags.f_contiguous`` instead. +// - 'fixed': Always print exactly `precision` fractional digits, +// even if this would print more or fewer digits than +// necessary to specify the value uniquely. +// - 'unique': Print the minimum number of fractional digits necessary +// to represent each value uniquely. Different elements may +// have a different number of digits. The value of the +// `precision` option is ignored. +// - 'maxprec': Print at most `precision` fractional digits, but if +// an element can be uniquely represented with fewer digits +// only print it with that many. +// - 'maxprec_equal': Print at most `precision` fractional digits, +// but if every element in the array can be uniquely +// represented with an equal number of fewer digits, use that +// many digits for all elements. +// legacy : string or `False`, optional +// If set to the string `'1.13'` enables 1.13 legacy printing mode. This +// approximates numpy 1.13 print output by including a space in the sign +// position of floats and different behavior for 0d arrays. If set to +// `False`, disables legacy mode. Unrecognized strings will be ignored +// with a warning for forward compatibility. // -// Parameters -// ---------- -// a : ndarray -// Input array. +// .. versionadded:: 1.14.0 // // Returns // ------- -// isfortran : bool -// Returns True if the array is Fortran contiguous but *not* C contiguous. +// array_str : str +// String representation of the array. // +// Raises +// ------ +// TypeError +// if a callable in `formatter` does not return a string. // -// Examples +// See Also // -------- +// array_str, array_repr, set_printoptions, get_printoptions // -// np.array allows to specify whether the array is written in C-contiguous -// order (last index varies the fastest), or FORTRAN-contiguous order in -// memory (first index varies the fastest). -// -// >>> import numpy as np -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// -// >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') -// >>> b -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(b) -// True +// Notes +// ----- +// If a formatter is specified for a certain type, the `precision` keyword is +// ignored for that type. // +// This is a very flexible function; `array_repr` and `array_str` are using +// `array2string` internally so keywords with the same name should work +// identically in all three functions. // -// The transpose of a C-ordered array is a FORTRAN-ordered array. +// Examples +// -------- +// >>> x = np.array([1e-16,1,2,3]) +// >>> np.array2string(x, precision=2, separator=',', +// ... suppress_small=True) +// '[0.,1.,2.,3.]' // -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// >>> b = a.T -// >>> b -// array([[1, 4], -// [2, 5], -// [3, 6]]) -// >>> np.isfortran(b) -// True +// >>> x = np.arange(3.) +// >>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x}) +// '[0.00 1.00 2.00]' // -// C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. +// >>> x = np.arange(3) +// >>> np.array2string(x, formatter={'int':lambda x: hex(x)}) +// '[0x0 0x1 0x2]' // -// >>> np.isfortran(np.array([1, 2], order='F')) -// False // // +//go:linkname Array2string py.array2string +func Array2string(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object, separator *py.Object, prefix *py.Object, style *py.Object, formatter *py.Object, threshold *py.Object, edgeitems *py.Object, sign *py.Object, floatmode *py.Object, suffix *py.Object) *py.Object // -//go:linkname Isfortran py.isfortran -func Isfortran(a *py.Object) *py.Object -// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Return the current callback function used on floating-point errors. // -// Compute the truth value of x1 AND x2 element-wise. +// When the error handling for a floating-point error (one of "divide", +// "over", "under", or "invalid") is set to 'call' or 'log', the function +// that is called or the log instance that is written to is returned by +// `geterrcall`. This function or log instance has been set with +// `seterrcall`. // -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Returns +// ------- +// errobj : callable, log instance or None +// The current error handler. If no handler was set through `seterrcall`, +// ``None`` is returned. // -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical AND operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. +// See Also +// -------- +// seterrcall, seterr, geterr // -// See Also -// -------- -// logical_or, logical_not, logical_xor -// bitwise_and +// Notes +// ----- +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.logical_and(True, False) -// False -// >>> np.logical_and([True, False], [False, False]) -// array([False, False]) +// Examples +// -------- +// >>> np.geterrcall() # we did not yet set a handler, returns None // -// >>> x = np.arange(5) -// >>> np.logical_and(x>1, x<4) -// array([False, False, True, True, False]) +// >>> oldsettings = np.seterr(all='call') +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// >>> oldhandler = np.seterrcall(err_handler) +// >>> np.array([1, 2, 3]) / 0.0 +// Floating point error (divide by zero), with flag 1 +// array([inf, inf, inf]) // +// >>> cur_handler = np.geterrcall() +// >>> cur_handler is err_handler +// True // -// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on -// boolean ndarrays. // -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a & b -// array([False, False]) // -//go:linkname LogicalAnd py.logical_and -func LogicalAnd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +//go:linkname Geterrcall py.geterrcall +func Geterrcall() *py.Object // -// Test whether all array elements along a given axis evaluate to True. +// Insert values along the given axis before the given indices. // // Parameters // ---------- -// a : array_like -// Input array or object that can be converted to an array. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a logical AND reduction is performed. -// The default (``axis=None``) is to perform a logical AND over all -// the dimensions of the input array. `axis` may be negative, in -// which case it counts from the last to the first axis. If this -// is a tuple of ints, a reduction is performed on multiple -// axes, instead of a single axis or all the axes as before. -// out : ndarray, optional -// Alternate output array in which to place the result. -// It must have the same shape as the expected output and its -// type is preserved (e.g., if ``dtype(out)`` is float, the result -// will consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` -// for more details. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `all` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. +// arr : array_like +// Input array. +// obj : int, slice or sequence of ints +// Object that defines the index or indices before which `values` is +// inserted. // -// where : array_like of bool, optional -// Elements to include in checking for all `True` values. -// See `~numpy.ufunc.reduce` for details. +// .. versionadded:: 1.8.0 // -// .. versionadded:: 1.20.0 +// Support for multiple insertions when `obj` is a single scalar or a +// sequence with one element (similar to calling insert multiple +// times). +// values : array_like +// Values to insert into `arr`. If the type of `values` is different +// from that of `arr`, `values` is converted to the type of `arr`. +// `values` should be shaped so that ``arr[...,obj,...] = values`` +// is legal. +// axis : int, optional +// Axis along which to insert `values`. If `axis` is None then `arr` +// is flattened first. // // Returns // ------- -// all : ndarray, bool -// A new boolean or array is returned unless `out` is specified, -// in which case a reference to `out` is returned. +// out : ndarray +// A copy of `arr` with `values` inserted. Note that `insert` +// does not occur in-place: a new array is returned. If +// `axis` is None, `out` is a flattened array. // // See Also // -------- -// ndarray.all : equivalent method -// -// any : Test whether any element along a given axis evaluates to True. +// append : Append elements at the end of an array. +// concatenate : Join a sequence of arrays along an existing axis. +// delete : Delete elements from an array. // // Notes // ----- -// Not a Number (NaN), positive infinity and negative infinity -// evaluate to `True` because these are not equal to zero. -// -// .. versionchanged:: 2.0 -// Before NumPy 2.0, ``all`` did not return booleans for object dtype -// input arrays. -// This behavior is still available via ``np.logical_and.reduce``. +// 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 // -------- -// >>> import numpy as np -// >>> np.all([[True,False],[True,True]]) -// False +// >>> a = np.array([[1, 1], [2, 2], [3, 3]]) +// >>> a +// array([[1, 1], +// [2, 2], +// [3, 3]]) +// >>> np.insert(a, 1, 5) +// array([1, 5, 1, ..., 2, 3, 3]) +// >>> np.insert(a, 1, 5, axis=1) +// array([[1, 5, 1], +// [2, 5, 2], +// [3, 5, 3]]) // -// >>> np.all([[True,False],[True,True]], axis=0) -// array([ True, False]) +// Difference between sequence and scalars: // -// >>> np.all([-1, 4, 5]) +// >>> np.insert(a, [1], [[1],[2],[3]], axis=1) +// array([[1, 1, 1], +// [2, 2, 2], +// [3, 3, 3]]) +// >>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1), +// ... np.insert(a, [1], [[1],[2],[3]], axis=1)) // True // -// >>> np.all([1.0, np.nan]) -// True +// >>> b = a.flatten() +// >>> b +// array([1, 1, 2, 2, 3, 3]) +// >>> np.insert(b, [2, 2], [5, 6]) +// array([1, 1, 5, ..., 2, 3, 3]) // -// >>> np.all([[True, True], [False, True]], where=[[True], [False]]) -// True +// >>> np.insert(b, slice(2, 4), [5, 6]) +// array([1, 1, 5, ..., 2, 3, 3]) // -// >>> o=np.array(False) -// >>> z=np.all([-1, 4, 5], out=o) -// >>> id(z), id(o), z -// (28293632, 28293632, array(True)) # may vary +// >>> np.insert(b, [2, 2], [7.13, False]) # type casting +// array([1, 1, 7, ..., 2, 3, 3]) // +// >>> x = np.arange(8).reshape(2, 4) +// >>> idx = (1, 3) +// >>> np.insert(x, idx, 999, axis=1) +// array([[ 0, 999, 1, 2, 999, 3], +// [ 4, 999, 5, 6, 999, 7]]) // // -//go:linkname All py.all -func All(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object) *py.Object -// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Compute the truth value of NOT x element-wise. +//go:linkname Insert py.insert +func Insert(arr *py.Object, obj *py.Object, values *py.Object, axis *py.Object) *py.Object // -// Parameters -// ---------- -// x : array_like -// Logical NOT is applied to the elements of `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// An array with ones at and below the given diagonal and zeros elsewhere. // -// Returns -// ------- -// y : bool or ndarray of bool -// Boolean result with the same shape as `x` of the NOT operation -// on elements of `x`. -// This is a scalar if `x` is a scalar. +// Parameters +// ---------- +// N : int +// Number of rows in the array. +// M : int, optional +// Number of columns in the array. +// By default, `M` is taken equal to `N`. +// k : int, optional +// The sub-diagonal at and below which the array is filled. +// `k` = 0 is the main diagonal, while `k` < 0 is below it, +// and `k` > 0 is above. The default is 0. +// dtype : dtype, optional +// Data type of the returned array. The default is float. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. // -// See Also -// -------- -// logical_and, logical_or, logical_xor +// .. versionadded:: 1.20.0 // -// Examples -// -------- -// >>> import numpy as np -// >>> np.logical_not(3) -// False -// >>> np.logical_not([True, False, 0, 1]) -// array([False, True, True, False]) +// Returns +// ------- +// tri : ndarray of shape (N, M) +// Array with its lower triangle filled with ones and zero elsewhere; +// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. // -// >>> x = np.arange(5) -// >>> np.logical_not(x<3) -// array([False, False, False, True, True]) +// Examples +// -------- +// >>> np.tri(3, 5, 2, dtype=int) +// array([[1, 1, 1, 0, 0], +// [1, 1, 1, 1, 0], +// [1, 1, 1, 1, 1]]) +// +// >>> np.tri(3, 5, -1) +// array([[0., 0., 0., 0., 0.], +// [1., 0., 0., 0., 0.], +// [1., 1., 0., 0., 0.]]) +// +// +// +//go:linkname Tri py.tri +func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object +// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname LogicalNot py.logical_not -func LogicalNot(x *py.Object, out *py.Object) *py.Object -// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Compute the Heaviside step function. // -// Compute hyperbolic tangent element-wise. +// The Heaviside step function is defined as:: // -// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. +// 0 if x1 < 0 +// heaviside(x1, x2) = x2 if x1 == 0 +// 1 if x1 > 0 +// +// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. // // Parameters // ---------- -// x : array_like -// Input array. +// x1 : array_like +// Input values. +// x2 : array_like +// The value of the function when x1 is 0. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -20695,263 +20172,378 @@ func LogicalNot(x *py.Object, out *py.Object) *py.Object // // Returns // ------- -// y : ndarray -// The corresponding hyperbolic tangent values. -// This is a scalar if `x` is a scalar. +// out : ndarray or scalar +// The output array, element-wise Heaviside step function of `x1`. +// This is a scalar if both `x1` and `x2` are scalars. // // Notes // ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) +// .. versionadded:: 1.13.0 // // References // ---------- -// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// https://personal.math.ubc.ca/~cbm/aands/page_83.htm -// -// .. [2] Wikipedia, "Hyperbolic function", -// https://en.wikipedia.org/wiki/Hyperbolic_function +// .. Wikipedia, "Heaviside step function", +// https://en.wikipedia.org/wiki/Heaviside_step_function // // Examples // -------- -// >>> import numpy as np -// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) -// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) +// >>> np.heaviside([-1.5, 0, 2.0], 0.5) +// array([ 0. , 0.5, 1. ]) +// >>> np.heaviside([-1.5, 0, 2.0], 1) +// array([ 0., 1., 1.]) // -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.tanh([0.1], out1) -// >>> out2 is out1 -// True +//go:linkname Heaviside py.heaviside +func Heaviside(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// Return the current print options. // -//go:linkname Tanh py.tanh -func Tanh(x *py.Object, out *py.Object) *py.Object +// Returns +// ------- +// print_opts : dict +// Dictionary of current print options with keys +// +// - precision : int +// - threshold : int +// - edgeitems : int +// - linewidth : int +// - suppress : bool +// - nanstr : str +// - infstr : str +// - formatter : dict of callables +// - sign : str +// +// For a full description of these options, see `set_printoptions`. +// +// See Also +// -------- +// set_printoptions, printoptions, set_string_function // -// Compute tensor dot product along specified axes. // -// Given two tensors, `a` and `b`, and an array_like object containing -// two array_like objects, ``(a_axes, b_axes)``, sum the products of -// `a`'s and `b`'s elements (components) over the axes specified by -// ``a_axes`` and ``b_axes``. The third argument can be a single non-negative -// integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions -// of `a` and the first ``N`` dimensions of `b` are summed over. +// +//go:linkname GetPrintoptions py.get_printoptions +func GetPrintoptions() *py.Object +// +// Compute the q-th quantile of the data along the specified axis. +// +// .. versionadded:: 1.15.0 // // Parameters // ---------- -// a, b : array_like -// Tensors to "dot". +// a : array_like of real numbers +// Input array or object that can be converted to an array. +// q : array_like of float +// Probability or sequence of probabilities for the quantiles to compute. +// Values must be between 0 and 1 inclusive. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the quantiles are computed. The default is +// to compute the quantile(s) along a flattened version of the array. +// out : ndarray, optional +// Alternative output array in which to place the result. It must have +// the same shape and buffer length as the expected output, but the +// type (of the output) will be cast if necessary. +// overwrite_input : bool, optional +// If True, then allow the input array `a` to be modified by +// intermediate calculations, to save memory. In this case, the +// contents of the input `a` after this function completes is +// undefined. +// method : str, optional +// This parameter specifies the method to use for estimating the +// quantile. There are many different methods, some unique to NumPy. +// See the notes for explanation. The options sorted by their R type +// as summarized in the H&F paper [1]_ are: // -// axes : int or (2,) array_like -// * integer_like -// If an int N, sum over the last N axes of `a` and the first N axes -// of `b` in order. The sizes of the corresponding axes must match. -// * (2,) array_like -// Or, a list of axes to be summed over, first sequence applying to `a`, -// second to `b`. Both elements array_like must be of the same length. +// 1. 'inverted_cdf' +// 2. 'averaged_inverted_cdf' +// 3. 'closest_observation' +// 4. 'interpolated_inverted_cdf' +// 5. 'hazen' +// 6. 'weibull' +// 7. 'linear' (default) +// 8. 'median_unbiased' +// 9. 'normal_unbiased' +// +// The first three methods are discontinuous. NumPy further defines the +// following discontinuous variations of the default 'linear' (7.) option: +// +// * 'lower' +// * 'higher', +// * 'midpoint' +// * 'nearest' +// +// .. versionchanged:: 1.22.0 +// This argument was previously called "interpolation" and only +// offered the "linear" default and last four options. +// +// 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 array `a`. +// +// interpolation : str, optional +// Deprecated name for the method keyword argument. +// +// .. deprecated:: 1.22.0 // // Returns // ------- -// output : ndarray -// The tensor dot product of the input. +// quantile : scalar or ndarray +// If `q` is a single probability and `axis=None`, then the result +// is a scalar. If multiple probabilies levels are given, first axis of +// the result corresponds to the quantiles. The other axes are +// the axes that remain after the reduction of `a`. If the input +// contains integers or floats smaller than ``float64``, the output +// data-type is ``float64``. Otherwise, the output data-type is the +// same as that of the input. If `out` is specified, that array is +// returned instead. // // See Also // -------- -// dot, einsum +// mean +// percentile : equivalent to quantile, but with q in the range [0, 100]. +// median : equivalent to ``quantile(..., 0.5)`` +// nanquantile // // Notes // ----- -// Three common use cases are: -// * ``axes = 0`` : tensor product :math:`a\otimes b` -// * ``axes = 1`` : tensor dot product :math:`a\cdot b` -// * ``axes = 2`` : (default) tensor double contraction :math:`a:b` +// 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: // -// When `axes` is integer_like, the sequence of axes for evaluation -// will be: from the -Nth axis to the -1th axis in `a`, -// and from the 0th axis to (N-1)th axis in `b`. -// For example, ``axes = 2`` is the equal to -// ``axes = [[-2, -1], [0, 1]]``. -// When N-1 is smaller than 0, or when -N is larger than -1, -// the element of `a` and `b` are defined as the `axes`. +// .. math:: +// i + g = q * ( n - alpha - beta + 1 ) + alpha // -// When there is more than one axis to sum over - and they are not the last -// (first) axes of `a` (`b`) - the argument `axes` should consist of -// two sequences of the same length, with the first axis to sum over given -// first in both sequences, the second axis second, and so forth. -// The calculation can be referred to ``numpy.einsum``. +// The different methods then work as follows // -// The shape of the result consists of the non-contracted axes of the -// first tensor, followed by the non-contracted axes of the second. +// inverted_cdf: +// method 1 of H&F [1]_. +// This method gives discontinuous results: // -// Examples -// -------- -// An example on integer_like: +// * if g > 0 ; then take j +// * if g = 0 ; then take i // -// >>> a_0 = np.array([[1, 2], [3, 4]]) -// >>> b_0 = np.array([[5, 6], [7, 8]]) -// >>> c_0 = np.tensordot(a_0, b_0, axes=0) -// >>> c_0.shape -// (2, 2, 2, 2) -// >>> c_0 -// array([[[[ 5, 6], -// [ 7, 8]], -// [[10, 12], -// [14, 16]]], -// [[[15, 18], -// [21, 24]], -// [[20, 24], -// [28, 32]]]]) +// averaged_inverted_cdf: +// method 2 of H&F [1]_. +// This method gives discontinuous results: // -// An example on array_like: +// * if g > 0 ; then take j +// * if g = 0 ; then average between bounds // -// >>> a = np.arange(60.).reshape(3,4,5) -// >>> b = np.arange(24.).reshape(4,3,2) -// >>> c = np.tensordot(a,b, axes=([1,0],[0,1])) -// >>> c.shape -// (5, 2) -// >>> c -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) +// closest_observation: +// method 3 of H&F [1]_. +// This method gives discontinuous results: // -// A slower but equivalent way of computing the same... +// * 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 // -// >>> d = np.zeros((5,2)) -// >>> for i in range(5): -// ... for j in range(2): -// ... for k in range(3): -// ... for n in range(4): -// ... d[i,j] += a[k,n,i] * b[n,k,j] -// >>> c == d -// array([[ True, True], -// [ True, True], -// [ True, True], -// [ True, True], -// [ True, True]]) +// interpolated_inverted_cdf: +// method 4 of H&F [1]_. +// This method gives continuous results using: // -// An extended example taking advantage of the overloading of + and \*: +// * alpha = 0 +// * beta = 1 // -// >>> a = np.array(range(1, 9)) -// >>> a.shape = (2, 2, 2) -// >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object) -// >>> A.shape = (2, 2) -// >>> a; A -// array([[[1, 2], -// [3, 4]], -// [[5, 6], -// [7, 8]]]) -// array([['a', 'b'], -// ['c', 'd']], dtype=object) +// hazen: +// method 5 of H&F [1]_. +// This method gives continuous results using: // -// >>> np.tensordot(a, A) # third argument default is 2 for double-contraction -// array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object) +// * alpha = 1/2 +// * beta = 1/2 +// +// weibull: +// method 6 of H&F [1]_. +// This method gives continuous results using: +// +// * alpha = 0 +// * beta = 0 +// +// linear: +// method 7 of H&F [1]_. +// This method gives continuous results using: +// +// * alpha = 1 +// * beta = 1 +// +// median_unbiased: +// method 8 of H&F [1]_. +// This method is probably the best method if the sample +// distribution function is unknown (see reference). +// This method gives continuous results using: +// +// * alpha = 1/3 +// * beta = 1/3 +// +// normal_unbiased: +// 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 gives continuous results using: +// +// * alpha = 3/8 +// * beta = 3/8 +// +// lower: +// NumPy method kept for backwards compatibility. +// Takes ``i`` as the interpolation point. +// +// higher: +// NumPy method kept for backwards compatibility. +// Takes ``j`` as the interpolation point. +// +// nearest: +// NumPy method kept for backwards compatibility. +// Takes ``i`` or ``j``, whichever is nearest. +// +// midpoint: +// NumPy method kept for backwards compatibility. +// Uses ``(i + j) / 2``. +// +// Examples +// -------- +// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) +// >>> a +// array([[10, 7, 4], +// [ 3, 2, 1]]) +// >>> np.quantile(a, 0.5) +// 3.5 +// >>> np.quantile(a, 0.5, axis=0) +// array([6.5, 4.5, 2.5]) +// >>> np.quantile(a, 0.5, axis=1) +// array([7., 2.]) +// >>> np.quantile(a, 0.5, axis=1, keepdims=True) +// array([[7.], +// [2.]]) +// >>> m = np.quantile(a, 0.5, axis=0) +// >>> out = np.zeros_like(m) +// >>> np.quantile(a, 0.5, axis=0, out=out) +// array([6.5, 4.5, 2.5]) +// >>> m +// array([6.5, 4.5, 2.5]) +// >>> b = a.copy() +// >>> np.quantile(b, 0.5, axis=1, overwrite_input=True) +// array([7., 2.]) +// >>> assert not np.all(a == b) +// +// See also `numpy.percentile` for a visualization of most methods. +// +// References +// ---------- +// .. [1] R. J. Hyndman and Y. Fan, +// "Sample quantiles in statistical packages," +// The American Statistician, 50(4), pp. 361-365, 1996 +// +// +// +//go:linkname Quantile py.quantile +func Quantile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object // -// >>> np.tensordot(a, A, 1) -// array([[['acc', 'bdd'], -// ['aaacccc', 'bbbdddd']], -// [['aaaaacccccc', 'bbbbbdddddd'], -// ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object) +// Protected string evaluation. // -// >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.) -// array([[[[['a', 'b'], -// ['c', 'd']], -// ... +// Evaluate a string containing a Python literal expression without +// allowing the execution of arbitrary non-literal code. // -// >>> np.tensordot(a, A, (0, 1)) -// array([[['abbbbb', 'cddddd'], -// ['aabbbbbb', 'ccdddddd']], -// [['aaabbbbbbb', 'cccddddddd'], -// ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object) +// .. warning:: // -// >>> np.tensordot(a, A, (2, 1)) -// array([[['abb', 'cdd'], -// ['aaabbbb', 'cccdddd']], -// [['aaaaabbbbbb', 'cccccdddddd'], -// ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object) +// 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. // -// >>> np.tensordot(a, A, ((0, 1), (0, 1))) -// array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object) +// Parameters +// ---------- +// source : str +// The string to evaluate. // -// >>> np.tensordot(a, A, ((2, 1), (1, 0))) -// array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object) +// Returns +// ------- +// obj : object +// The result of evaluating `source`. // +// Raises +// ------ +// SyntaxError +// If the code has invalid Python syntax, or if it contains +// non-literal code. // +// Examples +// -------- +// >>> np.safe_eval('1') +// 1 +// >>> np.safe_eval('[1, 2, 3]') +// [1, 2, 3] +// >>> np.safe_eval('{"foo": ("bar", 10.0)}') +// {'foo': ('bar', 10.0)} // -//go:linkname Tensordot py.tensordot -func Tensordot(a *py.Object, b *py.Object, axes *py.Object) *py.Object -// vecmat(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, axes, axis]) +// >>> np.safe_eval('import os') +// Traceback (most recent call last): +// ... +// SyntaxError: invalid syntax // -// Vector-matrix dot product of two arrays. +// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') +// Traceback (most recent call last): +// ... +// ValueError: malformed node or string: <_ast.Call object at 0x...> // -// Given a vector (or stack of vector) :math:`\mathbf{v}` in ``x1`` and -// a matrix (or stack of matrices) :math:`\mathbf{A}` in ``x2``, the -// vector-matrix product is defined as: // -// .. math:: -// \mathbf{b} \cdot \mathbf{A} = \sum_{i=0}^{n-1} \overline{v_i}A_{ij} // -// where the sum is over the last dimension of ``x1`` and the one-but-last -// dimensions in ``x2`` (unless `axes` is specified) and where -// :math:`\overline{v_i}` denotes the complex conjugate if :math:`v` -// is complex and the identity otherwise. (For a non-conjugated vector-matrix -// product, use ``np.matvec(x2.mT, x1)``.) +//go:linkname SafeEval py.safe_eval +func SafeEval(source *py.Object) *py.Object // -// .. versionadded:: 2.2.0 +// Find the set difference of two arrays. // -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays, scalars not allowed. -// out : ndarray, optional -// A location into which the result is stored. If provided, it must have -// the broadcasted shape of ``x1`` and ``x2`` with the summation axis -// removed. If not provided or None, a freshly-allocated array is used. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Return the unique values in `ar1` that are not in `ar2`. // -// Returns -// ------- -// y : ndarray -// The vector-matrix product of the inputs. +// Parameters +// ---------- +// ar1 : array_like +// Input array. +// ar2 : array_like +// Input comparison array. +// assume_unique : bool +// If True, the input arrays are both assumed to be unique, which +// can speed up the calculation. Default is False. // -// Raises -// ------ -// ValueError -// If the last dimensions of ``x1`` and the one-but-last dimension of -// ``x2`` are not the same size. +// Returns +// ------- +// setdiff1d : ndarray +// 1D array of values in `ar1` that are not in `ar2`. The result +// is sorted when `assume_unique=False`, but otherwise only sorted +// if the input is sorted. // -// If a scalar value is passed in. +// See Also +// -------- +// numpy.lib.arraysetops : Module with a number of other functions for +// performing set operations on arrays. // -// See Also -// -------- -// vecdot : Vector-vector product. -// matvec : Matrix-vector product. -// matmul : Matrix-matrix product. -// einsum : Einstein summation convention. +// Examples +// -------- +// >>> a = np.array([1, 2, 3, 2, 4, 1]) +// >>> b = np.array([3, 4, 5, 6]) +// >>> np.setdiff1d(a, b) +// array([1, 2]) // -// Examples -// -------- -// Project a vector along X and Y. // -// >>> v = np.array([0., 4., 2.]) -// >>> a = np.array([[1., 0., 0.], -// ... [0., 1., 0.], -// ... [0., 0., 0.]]) -// >>> np.vecmat(v, a) -// array([ 0., 4., 0.]) // -//go:linkname Vecmat py.vecmat -func Vecmat(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +//go:linkname Setdiff1d py.setdiff1d +func Setdiff1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object) *py.Object // // Calculates ``element in test_elements``, broadcasting over `element` only. // Returns a boolean array of the same shape as `element` that is True @@ -20980,15 +20572,15 @@ func Vecmat(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // // * If 'sort', will use a mergesort-based approach. This will have // a memory usage of roughly 6 times the sum of the sizes of -// `element` and `test_elements`, not accounting for size of dtypes. +// `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 `element` plus the max-min value of `test_elements`. -// `assume_unique` has no effect when the 'table' option is used. +// 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 `element` and `test_elements`, +// 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, @@ -21001,8 +20593,15 @@ func Vecmat(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // Has the same shape as `element`. The values `element[isin]` // are in `test_elements`. // +// See Also +// -------- +// in1d : Flattened version of this function. +// numpy.lib.arraysetops : Module with a number of other functions for +// performing set operations on arrays. +// // Notes // ----- +// // `isin` is an element-wise function version of the python keyword `in`. // ``isin(a, b)`` is roughly equivalent to // ``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences. @@ -21016,15 +20615,15 @@ func Vecmat(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // // Using ``kind='table'`` tends to be faster than `kind='sort'` if the // following relationship is true: -// ``log10(len(test_elements)) > -// (log10(max(test_elements)-min(test_elements)) - 2.27) / 0.927``, +// ``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 // -------- -// >>> import numpy as np // >>> element = 2*np.arange(4).reshape((2, 2)) // >>> element // array([[0, 2], @@ -21044,1557 +20643,1447 @@ func Vecmat(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // // The test can also be inverted: // -// >>> mask = np.isin(element, test_elements, invert=True) -// >>> mask -// array([[ True, False], -// [False, True]]) -// >>> element[mask] -// array([0, 6]) +// >>> mask = np.isin(element, test_elements, invert=True) +// >>> mask +// array([[ True, False], +// [False, True]]) +// >>> element[mask] +// array([0, 6]) +// +// Because of how `array` handles sets, the following does not +// work as expected: +// +// >>> test_set = {1, 2, 4, 8} +// >>> np.isin(element, test_set) +// array([[False, False], +// [False, False]]) +// +// Casting the set to a list gives the expected result: +// +// >>> np.isin(element, list(test_set)) +// array([[False, True], +// [ True, False]]) +// +// +//go:linkname Isin py.isin +func Isin(element *py.Object, testElements *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object +// +// Save an array to a text file. +// +// Parameters +// ---------- +// fname : filename or file handle +// If the filename ends in ``.gz``, the file is automatically saved in +// compressed gzip format. `loadtxt` understands gzipped files +// transparently. +// X : 1D or 2D array_like +// Data to be saved to a text file. +// fmt : str or sequence of strs, optional +// A single format (%10.5f), a sequence of formats, or a +// multi-format string, e.g. 'Iteration %d -- %10.5f', in which +// case `delimiter` is ignored. For complex `X`, the legal options +// for `fmt` are: +// +// * a single specifier, `fmt='%.4e'`, resulting in numbers formatted +// like `' (%s+%sj)' % (fmt, fmt)` +// * a full string specifying every real and imaginary part, e.g. +// `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns +// * a list of specifiers, one per column - in this case, the real +// and imaginary part must have separate specifiers, +// e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns +// delimiter : str, optional +// String or character separating columns. +// newline : str, optional +// String or character separating lines. +// +// .. versionadded:: 1.5.0 +// header : str, optional +// String that will be written at the beginning of the file. +// +// .. versionadded:: 1.7.0 +// footer : str, optional +// String that will be written at the end of the file. +// +// .. versionadded:: 1.7.0 +// comments : str, optional +// String that will be prepended to the ``header`` and ``footer`` strings, +// to mark them as comments. Default: '# ', as expected by e.g. +// ``numpy.loadtxt``. +// +// .. versionadded:: 1.7.0 +// encoding : {None, str}, optional +// Encoding used to encode the outputfile. Does not apply to output +// streams. If the encoding is something other than 'bytes' or 'latin1' +// you will not be able to load the file in NumPy versions < 1.14. Default +// is 'latin1'. +// +// .. versionadded:: 1.14.0 +// +// +// See Also +// -------- +// save : Save an array to a binary file in NumPy ``.npy`` format +// savez : Save several arrays into an uncompressed ``.npz`` archive +// savez_compressed : Save several arrays into a compressed ``.npz`` archive +// +// Notes +// ----- +// Further explanation of the `fmt` parameter +// (``%[flag]width[.precision]specifier``): +// +// flags: +// ``-`` : left justify +// +// ``+`` : Forces to precede result with + or -. +// +// ``0`` : Left pad the number with zeros instead of space (see width). +// +// width: +// Minimum number of characters to be printed. The value is not truncated +// if it has more characters. +// +// precision: +// - For integer specifiers (eg. ``d,i,o,x``), the minimum number of +// digits. +// - For ``e, E`` and ``f`` specifiers, the number of digits to print +// after the decimal point. +// - For ``g`` and ``G``, the maximum number of significant digits. +// - For ``s``, the maximum number of characters. +// +// specifiers: +// ``c`` : character +// +// ``d`` or ``i`` : signed decimal integer +// +// ``e`` or ``E`` : scientific notation with ``e`` or ``E``. +// +// ``f`` : decimal floating point +// +// ``g,G`` : use the shorter of ``e,E`` or ``f`` +// +// ``o`` : signed octal +// +// ``s`` : string of characters +// +// ``u`` : unsigned decimal integer +// +// ``x,X`` : unsigned hexadecimal integer +// +// This explanation of ``fmt`` is not complete, for an exhaustive +// specification see [1]_. +// +// References +// ---------- +// .. [1] `Format Specification Mini-Language +// `_, +// Python Documentation. +// +// Examples +// -------- +// >>> x = y = z = np.arange(0.0,5.0,1.0) +// >>> np.savetxt('test.out', x, delimiter=',') # X is an array +// >>> np.savetxt('test.out', (x,y,z)) # x,y,z equal sized 1D arrays +// >>> np.savetxt('test.out', x, fmt='%1.4e') # use exponential notation +// +// +// +//go:linkname Savetxt py.savetxt +func Savetxt(fname *py.Object, X *py.Object, fmt *py.Object, delimiter *py.Object, newline *py.Object, header *py.Object, footer *py.Object, comments *py.Object, encoding *py.Object) *py.Object +// +// unpackbits(a, /, axis=None, count=None, bitorder='big') +// +// Unpacks elements of a uint8 array into a binary-valued output array. +// +// Each element of `a` represents a bit-field that should be unpacked +// into a binary-valued output array. The shape of the output array is +// either 1-D (if `axis` is ``None``) or the same shape as the input +// array with unpacking done along the axis specified. +// +// Parameters +// ---------- +// a : ndarray, uint8 type +// Input array. +// axis : int, optional +// The dimension over which bit-unpacking is done. +// ``None`` implies unpacking the flattened array. +// count : int or None, optional +// The number of elements to unpack along `axis`, provided as a way +// of undoing the effect of packing a size that is not a multiple +// of eight. A non-negative number means to only unpack `count` +// bits. A negative number means to trim off that many bits from +// the end. ``None`` means to unpack the entire array (the +// default). Counts larger than the available number of bits will +// add zero padding to the output. Negative counts must not +// exceed the available number of bits. +// +// .. versionadded:: 1.17.0 // -// Because of how `array` handles sets, the following does not -// work as expected: +// bitorder : {'big', 'little'}, optional +// The order of the returned bits. 'big' will mimic bin(val), +// ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse +// the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``. +// Defaults to 'big'. // -// >>> test_set = {1, 2, 4, 8} -// >>> np.isin(element, test_set) -// array([[False, False], -// [False, False]]) +// .. versionadded:: 1.17.0 // -// Casting the set to a list gives the expected result: +// Returns +// ------- +// unpacked : ndarray, uint8 type +// The elements are binary-valued (0 or 1). // -// >>> np.isin(element, list(test_set)) -// array([[False, True], -// [ True, False]]) +// See Also +// -------- +// packbits : Packs the elements of a binary-valued array into bits in +// a uint8 array. // +// Examples +// -------- +// >>> a = np.array([[2], [7], [23]], dtype=np.uint8) +// >>> a +// array([[ 2], +// [ 7], +// [23]], dtype=uint8) +// >>> b = np.unpackbits(a, axis=1) +// >>> b +// array([[0, 0, 0, 0, 0, 0, 1, 0], +// [0, 0, 0, 0, 0, 1, 1, 1], +// [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8) +// >>> c = np.unpackbits(a, axis=1, count=-3) +// >>> c +// array([[0, 0, 0, 0, 0], +// [0, 0, 0, 0, 0], +// [0, 0, 0, 1, 0]], dtype=uint8) // -//go:linkname Isin py.isin -func Isin(element *py.Object, testElements *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object +// >>> p = np.packbits(b, axis=0) +// >>> np.unpackbits(p, axis=0) +// array([[0, 0, 0, 0, 0, 0, 1, 0], +// [0, 0, 0, 0, 0, 1, 1, 1], +// [0, 0, 0, 1, 0, 1, 1, 1], +// [0, 0, 0, 0, 0, 0, 0, 0], +// [0, 0, 0, 0, 0, 0, 0, 0], +// [0, 0, 0, 0, 0, 0, 0, 0], +// [0, 0, 0, 0, 0, 0, 0, 0], +// [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8) +// >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0])) +// True // -// Clip (limit) the values in an array. // -// Given an interval, values outside the interval are clipped to -// the interval edges. For example, if an interval of ``[0, 1]`` -// is specified, values smaller than 0 become 0, and values larger -// than 1 become 1. // -// Equivalent to but faster than ``np.minimum(a_max, np.maximum(a, a_min))``. +//go:linkname Unpackbits py.unpackbits +func Unpackbits(a *py.Object, axis *py.Object, count *py.Object, bitorder *py.Object) *py.Object // -// No check is performed to ensure ``a_min < a_max``. +// Return a sorted copy of an array. // // Parameters // ---------- // a : array_like -// Array containing elements to clip. -// a_min, a_max : array_like or None -// Minimum and maximum value. If ``None``, clipping is not performed on -// the corresponding edge. If both ``a_min`` and ``a_max`` are ``None``, -// the elements of the returned array stay the same. Both are broadcasted -// against ``a``. -// out : ndarray, optional -// The results will be placed in this array. It may be the input -// array for in-place clipping. `out` must be of the right shape -// to hold the output. Its type is preserved. -// min, max : array_like or None -// Array API compatible alternatives for ``a_min`` and ``a_max`` -// arguments. Either ``a_min`` and ``a_max`` or ``min`` and ``max`` -// can be passed at the same time. Default: ``None``. +// Array to be sorted. +// axis : int or None, optional +// Axis along which to sort. If None, the array is flattened before +// sorting. The default is -1, which sorts along the last axis. +// kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional +// Sorting algorithm. The default is 'quicksort'. Note that both 'stable' +// and 'mergesort' use timsort or radix sort under the covers and, in general, +// the actual implementation will vary with data type. The 'mergesort' option +// is retained for backwards compatibility. // -// .. versionadded:: 2.1.0 -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// .. versionchanged:: 1.15.0. +// The 'stable' option was added. +// +// order : str or list of str, optional +// When `a` is an array with fields defined, this argument specifies +// which fields to compare first, second, etc. A single field can +// be specified as a string, and not all fields need be specified, +// but unspecified fields will still be used, in the order in which +// they come up in the dtype, to break ties. // // Returns // ------- -// clipped_array : ndarray -// An array with the elements of `a`, but where values -// < `a_min` are replaced with `a_min`, and those > `a_max` -// with `a_max`. +// sorted_array : ndarray +// Array of the same type and shape as `a`. // // See Also // -------- -// :ref:`ufuncs-output-type` +// ndarray.sort : Method to sort an array in-place. +// argsort : Indirect sort. +// lexsort : Indirect stable sort on multiple keys. +// searchsorted : Find elements in a sorted array. +// partition : Partial sort. // // Notes // ----- -// When `a_min` is greater than `a_max`, `clip` returns an -// array in which all values are equal to `a_max`, -// as shown in the second example. +// The various sorting algorithms are characterized by their average speed, +// worst case performance, work space size, and whether they are stable. A +// stable sort keeps items with the same key in the same relative +// order. The four algorithms implemented in NumPy have the following +// properties: // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.arange(10) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.clip(a, 1, 8) -// array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) -// >>> np.clip(a, 8, 1) -// array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) -// >>> np.clip(a, 3, 6, out=a) -// array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) -// >>> a -// array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) -// >>> a = np.arange(10) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) -// array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8]) +// =========== ======= ============= ============ ======== +// kind speed worst case work space stable +// =========== ======= ============= ============ ======== +// 'quicksort' 1 O(n^2) 0 no +// 'heapsort' 3 O(n*log(n)) 0 no +// 'mergesort' 2 O(n*log(n)) ~n/2 yes +// 'timsort' 2 O(n*log(n)) ~n/2 yes +// =========== ======= ============= ============ ======== // +// .. note:: The datatype determines which of 'mergesort' or 'timsort' +// is actually used, even if 'mergesort' is specified. User selection +// at a finer scale is not currently available. // +// All the sort algorithms make temporary copies of the data when +// sorting along any but the last axis. Consequently, sorting along +// the last axis is faster and uses less space than sorting along +// any other axis. // -//go:linkname Clip py.clip -func Clip(a *py.Object, aMin *py.Object, aMax *py.Object, out *py.Object) *py.Object -// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// The sort order for complex numbers is lexicographic. If both the real +// and imaginary parts are non-nan then the order is determined by the +// real parts except when they are equal, in which case the order is +// determined by the imaginary parts. // -// Returns x1 * 2**x2, element-wise. +// Previous to numpy 1.4.0 sorting real and complex arrays containing nan +// values led to undefined behaviour. In numpy versions >= 1.4.0 nan +// values are sorted to the end. The extended sort order is: // -// The mantissas `x1` and twos exponents `x2` are used to construct -// floating point numbers ``x1 * 2**x2``. +// * Real: [R, nan] +// * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj] // -// Parameters -// ---------- -// x1 : array_like -// Array of multipliers. -// x2 : array_like, int -// Array of twos exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// where R is a non-nan real value. Complex values with the same nan +// placements are sorted according to the non-nan part if it exists. +// Non-nan values are sorted as before. // -// Returns -// ------- -// y : ndarray or scalar -// The result of ``x1 * 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. +// .. versionadded:: 1.12.0 // -// See Also -// -------- -// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. +// quicksort has been changed to `introsort `_. +// When sorting does not make enough progress it switches to +// `heapsort `_. +// This implementation makes quicksort O(n*log(n)) in the worst case. // -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. +// 'stable' automatically chooses the best stable sorting algorithm +// for the data type being sorted. +// It, along with 'mergesort' is currently mapped to +// `timsort `_ +// or `radix sort `_ +// depending on the data type. +// API forward compatibility currently limits the +// ability to select the implementation and it is hardwired for the different +// data types. // -// `ldexp` is useful as the inverse of `frexp`, if used by itself it is -// more clear to simply use the expression ``x1 * 2**x2``. +// .. versionadded:: 1.17.0 // -// Examples -// -------- -// >>> import numpy as np -// >>> np.ldexp(5, np.arange(4)) -// array([ 5., 10., 20., 40.], dtype=float16) +// Timsort is added for better performance on already or nearly +// sorted data. On random data timsort is almost identical to +// mergesort. It is now used for stable sort while quicksort is still the +// default sort if none is chosen. For timsort details, refer to +// `CPython listsort.txt `_. +// 'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is an +// O(n) sort instead of O(n log n). // -// >>> x = np.arange(6) -// >>> np.ldexp(*np.frexp(x)) -// array([ 0., 1., 2., 3., 4., 5.]) +// .. versionchanged:: 1.18.0 +// +// NaT now sorts to the end of arrays for consistency with NaN. +// +// Examples +// -------- +// >>> a = np.array([[1,4],[3,1]]) +// >>> np.sort(a) # sort along the last axis +// array([[1, 4], +// [1, 3]]) +// >>> np.sort(a, axis=None) # sort the flattened array +// array([1, 1, 3, 4]) +// >>> np.sort(a, axis=0) # sort along the first axis +// array([[1, 1], +// [3, 4]]) +// +// Use the `order` keyword to specify a field to use when sorting a +// structured array: +// +// >>> dtype = [('name', 'S10'), ('height', float), ('age', int)] +// >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38), +// ... ('Galahad', 1.7, 38)] +// >>> a = np.array(values, dtype=dtype) # create a structured array +// >>> np.sort(a, order='height') # doctest: +SKIP +// array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41), +// ('Lancelot', 1.8999999999999999, 38)], +// dtype=[('name', '|S10'), ('height', '>> np.sort(a, order=['age', 'height']) # doctest: +SKIP +// array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38), +// ('Arthur', 1.8, 41)], +// dtype=[('name', '|S10'), ('height', '>> y = np.linspace(start, stop, num=num, endpoint=endpoint) -// ... # doctest: +SKIP -// >>> power(base, y).astype(dtype) -// ... # doctest: +SKIP +// Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors +// when using the `axes` keyword argument. // // Examples // -------- -// >>> import numpy as np -// >>> np.logspace(2.0, 3.0, num=4) -// array([ 100. , 215.443469 , 464.15888336, 1000. ]) -// >>> np.logspace(2.0, 3.0, num=4, endpoint=False) -// array([100. , 177.827941 , 316.22776602, 562.34132519]) -// >>> np.logspace(2.0, 3.0, num=4, base=2.0) -// array([4. , 5.0396842 , 6.34960421, 8. ]) -// >>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1) -// array([[ 4. , 5.0396842 , 6.34960421, 8. ], -// [ 9. , 12.98024613, 18.72075441, 27. ]]) +// >>> a = np.array([[1, 2], [3, 4]]) +// >>> a +// array([[1, 2], +// [3, 4]]) +// >>> np.transpose(a) +// array([[1, 3], +// [2, 4]]) // -// Graphical illustration: +// >>> a = np.array([1, 2, 3, 4]) +// >>> a +// array([1, 2, 3, 4]) +// >>> np.transpose(a) +// array([1, 2, 3, 4]) // -// >>> import matplotlib.pyplot as plt -// >>> N = 10 -// >>> x1 = np.logspace(0.1, 1, N, endpoint=True) -// >>> x2 = np.logspace(0.1, 1, N, endpoint=False) -// >>> y = np.zeros(N) -// >>> plt.plot(x1, y, 'o') -// [] -// >>> plt.plot(x2, y + 0.5, 'o') -// [] -// >>> plt.ylim([-0.5, 1]) -// (-0.5, 1) -// >>> plt.show() +// >>> a = np.ones((1, 2, 3)) +// >>> np.transpose(a, (1, 0, 2)).shape +// (2, 1, 3) +// +// >>> a = np.ones((2, 3, 4, 5)) +// >>> np.transpose(a).shape +// (5, 4, 3, 2) // // // -//go:linkname Logspace py.logspace -func Logspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, base *py.Object, dtype *py.Object, axis *py.Object) *py.Object +//go:linkname Transpose py.transpose +func Transpose(a *py.Object, axes *py.Object) *py.Object // -// Return the Bartlett window. +// Roll the specified axis backwards, until it lies in a given position. // -// The Bartlett window is very similar to a triangular window, except -// that the end points are at zero. It is often used in signal -// processing for tapering a signal, without generating too much -// ripple in the frequency domain. +// This function continues to be supported for backward compatibility, but you +// should prefer `moveaxis`. The `moveaxis` function was added in NumPy +// 1.11. // // Parameters // ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. +// a : ndarray +// Input array. +// axis : int +// The axis to be rolled. The positions of the other axes do not +// change relative to one another. +// start : int, optional +// When ``start <= axis``, the axis is rolled back until it lies in +// this position. When ``start > axis``, the axis is rolled until it +// lies before this position. The default, 0, results in a "complete" +// roll. The following table describes how negative values of ``start`` +// are interpreted: +// +// .. table:: +// :align: left +// +// +-------------------+----------------------+ +// | ``start`` | Normalized ``start`` | +// +===================+======================+ +// | ``-(arr.ndim+1)`` | raise ``AxisError`` | +// +-------------------+----------------------+ +// | ``-arr.ndim`` | 0 | +// +-------------------+----------------------+ +// | |vdots| | |vdots| | +// +-------------------+----------------------+ +// | ``-1`` | ``arr.ndim-1`` | +// +-------------------+----------------------+ +// | ``0`` | ``0`` | +// +-------------------+----------------------+ +// | |vdots| | |vdots| | +// +-------------------+----------------------+ +// | ``arr.ndim`` | ``arr.ndim`` | +// +-------------------+----------------------+ +// | ``arr.ndim + 1`` | raise ``AxisError`` | +// +-------------------+----------------------+ +// +// .. |vdots| unicode:: U+22EE .. Vertical Ellipsis // // Returns // ------- -// out : array -// The triangular window, with the maximum value normalized to one -// (the value one appears only if the number of samples is odd), with -// the first and last samples equal to zero. +// res : ndarray +// For NumPy >= 1.10.0 a view of `a` is always returned. For earlier +// NumPy versions a view of `a` is returned only if the order of the +// axes is changed, otherwise the input array is returned. // // See Also // -------- -// blackman, hamming, hanning, kaiser -// -// Notes -// ----- -// The Bartlett window is defined as -// -// .. math:: w(n) = \frac{2}{M-1} \left( -// \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 window is the product of two sinc functions. Note the excellent -// discussion in Kanasewich [2]_. -// -// References -// ---------- -// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", -// Biometrika 37, 1-16, 1950. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 109-110. -// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal -// Processing", Prentice-Hall, 1999, pp. 468-471. -// .. [4] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 429. +// moveaxis : Move array axes to new positions. +// roll : Roll the elements of an array by a number of positions along a +// given axis. // // Examples // -------- -// >>> import numpy as np -// >>> import matplotlib.pyplot as plt -// >>> np.bartlett(12) -// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary -// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, -// 0.18181818, 0. ]) -// -// Plot the window and its frequency response (requires SciPy and matplotlib). -// -// .. plot:: -// :include-source: -// -// import matplotlib.pyplot as plt -// from numpy.fft import fft, fftshift -// window = np.bartlett(51) -// plt.plot(window) -// plt.title("Bartlett window") -// plt.ylabel("Amplitude") -// plt.xlabel("Sample") -// plt.show() -// plt.figure() -// A = fft(window, 2048) / 25.5 -// mag = np.abs(fftshift(A)) -// freq = np.linspace(-0.5, 0.5, len(A)) -// with np.errstate(divide='ignore', invalid='ignore'): -// response = 20 * np.log10(mag) -// response = np.clip(response, -100, 100) -// plt.plot(freq, response) -// plt.title("Frequency response of Bartlett window") -// plt.ylabel("Magnitude [dB]") -// plt.xlabel("Normalized frequency [cycles per sample]") -// plt.axis('tight') -// plt.show() -// -// +// >>> a = np.ones((3,4,5,6)) +// >>> np.rollaxis(a, 3, 1).shape +// (3, 6, 4, 5) +// >>> np.rollaxis(a, 2).shape +// (5, 3, 4, 6) +// >>> np.rollaxis(a, 1, 4).shape +// (3, 5, 6, 4) // -//go:linkname Bartlett py.bartlett -func Bartlett(M *py.Object) *py.Object // -// Return the gradient of an N-dimensional array. // -// The gradient is computed using second order accurate central differences -// in the interior points and either first or second order accurate one-sides -// (forward or backwards) differences at the boundaries. -// The returned gradient hence has the same shape as the input array. +//go:linkname Rollaxis py.rollaxis +func Rollaxis(a *py.Object, axis *py.Object, start *py.Object) *py.Object // -// Parameters -// ---------- -// f : array_like -// An N-dimensional array containing samples of a scalar function. -// varargs : list of scalar or array, optional -// Spacing between f values. Default unitary spacing for all dimensions. -// Spacing can be specified using: +// Returns a boolean array where two arrays are element-wise equal within a +// tolerance. // -// 1. single scalar to specify a sample distance for all dimensions. -// 2. N scalars to specify a constant sample distance for each dimension. -// i.e. `dx`, `dy`, `dz`, ... -// 3. N arrays to specify the coordinates of the values along each -// dimension of F. The length of the array must match the size of -// the corresponding dimension -// 4. Any combination of N scalars/arrays with the meaning of 2. and 3. +// The tolerance values are positive, typically very small numbers. The +// relative difference (`rtol` * abs(`b`)) and the absolute difference +// `atol` are added together to compare against the absolute difference +// between `a` and `b`. // -// If `axis` is given, the number of varargs must equal the number of axes -// specified in the axis parameter. -// Default: 1. (see Examples below). +// .. warning:: The default `atol` is not appropriate for comparing numbers +// that are much smaller than one (see Notes). // -// edge_order : {1, 2}, optional -// Gradient is calculated using N-th order accurate differences -// at the boundaries. Default: 1. -// axis : None or int or tuple of ints, optional -// Gradient is calculated only along the given axis or axes -// The default (axis = None) is to calculate the gradient for all the axes -// of the input array. axis may be negative, in which case it counts from -// the last to the first axis. +// Parameters +// ---------- +// a, b : array_like +// Input arrays to compare. +// rtol : float +// The relative tolerance parameter (see Notes). +// atol : float +// The absolute tolerance parameter (see Notes). +// equal_nan : bool +// Whether to compare NaN's as equal. If True, NaN's in `a` will be +// considered equal to NaN's in `b` in the output array. // // Returns // ------- -// gradient : ndarray or tuple of ndarray -// A tuple of ndarrays (or a single ndarray if there is only one -// dimension) corresponding to the derivatives of f with respect -// to each dimension. Each derivative has the same shape as f. +// y : array_like +// Returns a boolean array of where `a` and `b` are equal within the +// given tolerance. If both `a` and `b` are scalars, returns a single +// boolean value. // -// Examples +// See Also // -------- -// >>> import numpy as np -// >>> f = np.array([1, 2, 4, 7, 11, 16]) -// >>> np.gradient(f) -// array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) -// >>> np.gradient(f, 2) -// array([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ]) +// allclose +// math.isclose // -// Spacing can be also specified with an array that represents the coordinates -// of the values F along the dimensions. -// For instance a uniform spacing: +// Notes +// ----- +// .. versionadded:: 1.7.0 // -// >>> x = np.arange(f.size) -// >>> np.gradient(f, x) -// array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) +// For finite values, isclose uses the following equation to test whether +// two floating point values are equivalent. // -// Or a non uniform one: +// absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`)) // -// >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.]) -// >>> np.gradient(f, x) -// array([1. , 3. , 3.5, 6.7, 6.9, 2.5]) +// Unlike the built-in `math.isclose`, the above equation is not symmetric +// in `a` and `b` -- it assumes `b` is the reference value -- so that +// `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore, +// the default value of atol is not zero, and is used to determine what +// small values should be considered close to zero. The default value is +// appropriate for expected values of order unity: if the expected values +// are significantly smaller than one, it can result in false positives. +// `atol` should be carefully selected for the use case at hand. A zero value +// for `atol` will result in `False` if either `a` or `b` is zero. // -// For two dimensional arrays, the return will be two arrays ordered by -// axis. In this example the first array stands for the gradient in -// rows and the second one in columns direction: +// `isclose` is not defined for non-numeric data types. +// `bool` is considered a numeric data-type for this purpose. // -// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]])) -// (array([[ 2., 2., -1.], -// [ 2., 2., -1.]]), -// array([[1. , 2.5, 4. ], -// [1. , 1. , 1. ]])) +// Examples +// -------- +// >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8]) +// array([ True, False]) +// >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9]) +// array([ True, True]) +// >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9]) +// array([False, True]) +// >>> np.isclose([1.0, np.nan], [1.0, np.nan]) +// array([ True, False]) +// >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) +// array([ True, True]) +// >>> np.isclose([1e-8, 1e-7], [0.0, 0.0]) +// array([ True, False]) +// >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0) +// array([False, False]) +// >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0]) +// array([ True, True]) +// >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0) +// array([False, True]) // -// In this example the spacing is also specified: -// uniform for axis=0 and non uniform for axis=1 // -// >>> dx = 2. -// >>> y = [1., 1.5, 3.5] -// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]), dx, y) -// (array([[ 1. , 1. , -0.5], -// [ 1. , 1. , -0.5]]), -// array([[2. , 2. , 2. ], -// [2. , 1.7, 0.5]])) +//go:linkname Isclose py.isclose +func Isclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object // -// It is possible to specify how boundaries are treated using `edge_order` +// Returns the indices of the minimum values along an axis. // -// >>> x = np.array([0, 1, 2, 3, 4]) -// >>> f = x**2 -// >>> np.gradient(f, edge_order=1) -// array([1., 2., 4., 6., 7.]) -// >>> np.gradient(f, edge_order=2) -// array([0., 2., 4., 6., 8.]) +// Parameters +// ---------- +// a : array_like +// Input array. +// axis : int, optional +// By default, the index is into the flattened array, otherwise +// along the specified axis. +// out : array, optional +// If provided, the result will be inserted into this array. It should +// be of the appropriate shape and dtype. +// 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 array. // -// The `axis` keyword can be used to specify a subset of axes of which the -// gradient is calculated +// .. versionadded:: 1.22.0 // -// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]), axis=0) -// array([[ 2., 2., -1.], -// [ 2., 2., -1.]]) +// Returns +// ------- +// index_array : ndarray of ints +// Array of indices into the array. It has the same shape as `a.shape` +// with the dimension along `axis` removed. If `keepdims` is set to True, +// then the size of `axis` will be 1 with the resulting array having same +// shape as `a.shape`. // -// The `varargs` argument defines the spacing between sample points in the -// input array. It can take two forms: -// -// 1. An array, specifying coordinates, which may be unevenly spaced: -// -// >>> x = np.array([0., 2., 3., 6., 8.]) -// >>> y = x ** 2 -// >>> np.gradient(y, x, edge_order=2) -// array([ 0., 4., 6., 12., 16.]) -// -// 2. A scalar, representing the fixed sample distance: -// -// >>> dx = 2 -// >>> x = np.array([0., 2., 4., 6., 8.]) -// >>> y = x ** 2 -// >>> np.gradient(y, dx, edge_order=2) -// array([ 0., 4., 8., 12., 16.]) -// -// It's possible to provide different data for spacing along each dimension. -// The number of arguments must match the number of dimensions in the input -// data. -// -// >>> dx = 2 -// >>> dy = 3 -// >>> x = np.arange(0, 6, dx) -// >>> y = np.arange(0, 9, dy) -// >>> xs, ys = np.meshgrid(x, y) -// >>> zs = xs + 2 * ys -// >>> np.gradient(zs, dy, dx) # Passing two scalars -// (array([[2., 2., 2.], -// [2., 2., 2.], -// [2., 2., 2.]]), -// array([[1., 1., 1.], -// [1., 1., 1.], -// [1., 1., 1.]])) -// -// Mixing scalars and arrays is also allowed: -// -// >>> np.gradient(zs, y, dx) # Passing one array and one scalar -// (array([[2., 2., 2.], -// [2., 2., 2.], -// [2., 2., 2.]]), -// array([[1., 1., 1.], -// [1., 1., 1.], -// [1., 1., 1.]])) +// See Also +// -------- +// ndarray.argmin, argmax +// amin : The minimum value along a given axis. +// unravel_index : Convert a flat index into an index tuple. +// take_along_axis : Apply ``np.expand_dims(index_array, axis)`` +// from argmin to an array as if by calling min. // // Notes // ----- -// Assuming that :math:`f\in C^{3}` (i.e., :math:`f` has at least 3 continuous -// derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we -// minimize the "consistency error" :math:`\eta_{i}` between the true gradient -// and its estimate from a linear combination of the neighboring grid-points: +// In case of multiple occurrences of the minimum values, the indices +// corresponding to the first occurrence are returned. // -// .. math:: +// Examples +// -------- +// >>> a = np.arange(6).reshape(2,3) + 10 +// >>> a +// array([[10, 11, 12], +// [13, 14, 15]]) +// >>> np.argmin(a) +// 0 +// >>> np.argmin(a, axis=0) +// array([0, 0, 0]) +// >>> np.argmin(a, axis=1) +// array([0, 0]) // -// \eta_{i} = f_{i}^{\left(1\right)} - -// \left[ \alpha f\left(x_{i}\right) + -// \beta f\left(x_{i} + h_{d}\right) + -// \gamma f\left(x_{i}-h_{s}\right) -// \right] +// Indices of the minimum elements of a N-dimensional array: // -// By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})` -// with their Taylor series expansion, this translates into solving -// the following the linear system: +// >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape) +// >>> ind +// (0, 0) +// >>> a[ind] +// 10 // -// .. math:: +// >>> b = np.arange(6) + 10 +// >>> b[4] = 10 +// >>> b +// array([10, 11, 12, 13, 10, 15]) +// >>> np.argmin(b) # Only the first occurrence is returned. +// 0 // -// \left\{ -// \begin{array}{r} -// \alpha+\beta+\gamma=0 \\ -// \beta h_{d}-\gamma h_{s}=1 \\ -// \beta h_{d}^{2}+\gamma h_{s}^{2}=0 -// \end{array} -// \right. +// >>> x = np.array([[4,2,3], [1,0,3]]) +// >>> index_array = np.argmin(x, axis=-1) +// >>> # Same as np.amin(x, axis=-1, keepdims=True) +// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) +// array([[2], +// [0]]) +// >>> # Same as np.amax(x, axis=-1) +// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) +// array([2, 0]) // -// The resulting approximation of :math:`f_{i}^{(1)}` is the following: +// Setting `keepdims` to `True`, // -// .. math:: +// >>> x = np.arange(24).reshape((2, 3, 4)) +// >>> res = np.argmin(x, axis=1, keepdims=True) +// >>> res.shape +// (2, 1, 4) // -// \hat f_{i}^{(1)} = -// \frac{ -// h_{s}^{2}f\left(x_{i} + h_{d}\right) -// + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right) -// - h_{d}^{2}f\left(x_{i}-h_{s}\right)} -// { h_{s}h_{d}\left(h_{d} + h_{s}\right)} -// + \mathcal{O}\left(\frac{h_{d}h_{s}^{2} -// + h_{s}h_{d}^{2}}{h_{d} -// + h_{s}}\right) // -// It is worth noting that if :math:`h_{s}=h_{d}` -// (i.e., data are evenly spaced) -// we find the standard second order approximation: +//go:linkname Argmin py.argmin +func Argmin(a *py.Object, axis *py.Object, out *py.Object) *py.Object // -// .. math:: +// Round an array to the given number of decimals. // -// \hat f_{i}^{(1)}= -// \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h} -// + \mathcal{O}\left(h^{2}\right) +// `around` is an alias of `~numpy.round`. // -// With a similar procedure the forward/backward approximations used for -// boundaries can be derived. +// See Also +// -------- +// ndarray.round : equivalent method +// round : alias for this function +// ceil, fix, floor, rint, trunc // -// References -// ---------- -// .. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics -// (Texts in Applied Mathematics). New York: Springer. -// .. [2] Durran D. R. (1999) Numerical Methods for Wave Equations -// in Geophysical Fluid Dynamics. New York: Springer. -// .. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on -// Arbitrarily Spaced Grids, -// Mathematics of Computation 51, no. 184 : 699-706. -// `PDF `_. // // -//go:linkname Gradient py.gradient -func Gradient(f *py.Object, __llgo_va_list ...interface{}) *py.Object +//go:linkname Around py.around +func Around(a *py.Object, decimals *py.Object, out *py.Object) *py.Object +// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Compute the absolute values element-wise. +// +// This function returns the absolute values (positive magnitude) of the +// data in `x`. Complex values are not handled, use `absolute` to find the +// absolute values of complex data. +// +// Parameters +// ---------- +// x : array_like +// The array of numbers for which the absolute values are required. If +// `x` is a scalar, the result `y` will also be a scalar. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray or scalar +// The absolute values of `x`, the returned values are always floats. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// absolute : Absolute values including `complex` types. +// +// Examples +// -------- +// >>> np.fabs(-1) +// 1.0 +// >>> np.fabs([-1.2, 1.2]) +// array([ 1.2, 1.2]) // -// Compute the median along the specified axis. +//go:linkname Fabs py.fabs +func Fabs(x *py.Object, out *py.Object) *py.Object +// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Returns the median of the array elements. +// Returns the element-wise remainder of division. // -// Parameters -// ---------- -// a : array_like -// Input array or object that can be converted to an array. -// axis : {int, sequence of int, None}, optional -// Axis or axes along which the medians are computed. The default, -// axis=None, will compute the median along a flattened version of -// the array. If a sequence of axes, the array is first flattened -// along the given axes, then the median is computed along the -// resulting flattened axis. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow use of memory of input array `a` for -// calculations. The input array will be modified by the call to -// `median`. This will save memory when you do not need to preserve -// the contents of the input array. Treat the input as undefined, -// but it will probably be fully or partially sorted. Default is -// False. If `overwrite_input` is ``True`` and `a` is not already an -// `ndarray`, an error will be raised. -// 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 `arr`. +// Computes the remainder complementary to the `floor_divide` function. It is +// equivalent to the Python modulus operator``x1 % x2`` and has the same sign +// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` +// is ``mod``. // -// Returns -// ------- -// median : ndarray -// A new array holding the result. If the input contains integers -// or floats smaller than ``float64``, then the output data-type is -// ``np.float64``. Otherwise, the data-type of the output is the -// same as that of the input. If `out` is specified, that array is -// returned instead. +// .. warning:: // -// See Also -// -------- -// mean, percentile +// This should not be confused with: // -// Notes -// ----- -// Given a vector ``V`` of length ``N``, the median of ``V`` is the -// middle value of a sorted copy of ``V``, ``V_sorted`` - i -// e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the -// two middle values of ``V_sorted`` when ``N`` is even. +// * Python 3.7's `math.remainder` and C's ``remainder``, which +// computes the IEEE remainder, which are the complement to +// ``round(x1 / x2)``. +// * The MATLAB ``rem`` function and or the C ``%`` operator which is the +// complement to ``int(x1 / x2)``. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) -// >>> a -// array([[10, 7, 4], -// [ 3, 2, 1]]) -// >>> np.median(a) -// np.float64(3.5) -// >>> np.median(a, axis=0) -// array([6.5, 4.5, 2.5]) -// >>> np.median(a, axis=1) -// array([7., 2.]) -// >>> np.median(a, axis=(0, 1)) -// np.float64(3.5) -// >>> m = np.median(a, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.median(a, axis=0, out=m) -// array([6.5, 4.5, 2.5]) -// >>> m -// array([6.5, 4.5, 2.5]) -// >>> b = a.copy() -// >>> np.median(b, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a==b) -// >>> b = a.copy() -// >>> np.median(b, axis=None, overwrite_input=True) -// np.float64(3.5) -// >>> assert not np.all(a==b) +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // +// Returns +// ------- +// y : ndarray +// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. +// This is a scalar if both `x1` and `x2` are scalars. // +// See Also +// -------- +// floor_divide : Equivalent of Python ``//`` operator. +// divmod : Simultaneous floor division and remainder. +// fmod : Equivalent of the MATLAB ``rem`` function. +// divide, floor // -//go:linkname Median py.median -func Median(a *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, keepdims *py.Object) *py.Object +// Notes +// ----- +// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) +// integers. +// ``mod`` is an alias of ``remainder``. // -// Change elements of an array based on conditional and input values. +// Examples +// -------- +// >>> np.remainder([4, 7], [2, 3]) +// array([0, 1]) +// >>> np.remainder(np.arange(7), 5) +// array([0, 1, 2, 3, 4, 0, 1]) // -// Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that -// `place` uses the first N elements of `vals`, where N is the number of -// True values in `mask`, while `copyto` uses the elements where `mask` -// is True. +// The ``%`` operator can be used as a shorthand for ``np.remainder`` on +// ndarrays. // -// Note that `extract` does the exact opposite of `place`. +// >>> x1 = np.arange(7) +// >>> x1 % 5 +// array([0, 1, 2, 3, 4, 0, 1]) +// +//go:linkname Mod py.mod +func Mod(__llgo_va_list ...interface{}) *py.Object +// asfortranarray(a, dtype=None, *, like=None) +// +// Return an array (ndim >= 1) laid out in Fortran order in memory. // // Parameters // ---------- -// arr : ndarray -// Array to put data into. -// mask : array_like -// Boolean mask array. Must have the same size as `a`. -// vals : 1-D sequence -// Values to put into `a`. Only the first N elements are used, where -// N is the number of True values in `mask`. If `vals` is smaller -// than N, it will be repeated, and if elements of `a` are to be masked, -// this sequence must be non-empty. +// a : array_like +// Input array. +// dtype : str or dtype object, optional +// By default, the data-type is inferred from the input data. +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// The input `a` in Fortran, or column-major, order. // // See Also // -------- -// copyto, put, take, extract +// ascontiguousarray : Convert input to a contiguous (C order) array. +// asanyarray : Convert input to an ndarray with either row or +// column-major memory order. +// require : Return an ndarray that satisfies requirements. +// ndarray.flags : Information about the memory layout of the array. // // Examples // -------- -// >>> import numpy as np -// >>> arr = np.arange(6).reshape(2, 3) -// >>> np.place(arr, arr>2, [44, 55]) -// >>> arr -// array([[ 0, 1, 2], -// [44, 55, 44]]) -// -// -// -//go:linkname Place py.place -func Place(arr *py.Object, mask *py.Object, vals *py.Object) *py.Object -// -// Compute the q-th quantile of the data along the specified axis. +// Starting with a C-contiguous array: // -// Parameters -// ---------- -// a : array_like of real numbers -// Input array or object that can be converted to an array. -// q : array_like of float -// Probability or sequence of probabilities of the quantiles to compute. -// Values must be between 0 and 1 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the quantiles are computed. The default is -// to compute the quantile(s) along a flattened version of the array. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape and buffer length as the expected output, but the -// type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by -// intermediate calculations, to save memory. In this case, the -// contents of the input `a` after this function completes is -// undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// quantile. There are many different methods, some unique to NumPy. -// The recommended options, numbered as they appear in [1]_, are: +// >>> x = np.ones((2, 3), order='C') +// >>> x.flags['C_CONTIGUOUS'] +// True // -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' +// Calling ``asfortranarray`` makes a Fortran-contiguous copy: // -// The first three methods are discontinuous. For backward compatibility -// with previous versions of NumPy, the following discontinuous variations -// of the default 'linear' (7.) option are available: +// >>> y = np.asfortranarray(x) +// >>> y.flags['F_CONTIGUOUS'] +// True +// >>> np.may_share_memory(x, y) +// False // -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' +// Now, starting with a Fortran-contiguous array: // -// See Notes for details. +// >>> x = np.ones((2, 3), order='F') +// >>> x.flags['F_CONTIGUOUS'] +// True // -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. +// Then, calling ``asfortranarray`` returns the same object: // -// 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 array `a`. +// >>> y = np.asfortranarray(x) +// >>> x is y +// True // -// weights : array_like, optional -// An array of weights associated with the values in `a`. Each value in -// `a` contributes to the quantile according to its associated weight. -// The weights array can either be 1-D (in which case its length must be -// the size of `a` along the given axis) or of the same shape as `a`. -// If `weights=None`, then all data in `a` are assumed to have a -// weight equal to one. -// Only `method="inverted_cdf"` supports weights. -// See the notes for more details. +// Note: This function returns an array with at least one-dimension (1-d) +// so it will not preserve 0-d arrays. // -// .. versionadded:: 2.0.0 +//go:linkname Asfortranarray py.asfortranarray +func Asfortranarray(a *py.Object, dtype *py.Object) *py.Object // -// interpolation : str, optional -// Deprecated name for the method keyword argument. +// Return the number of dimensions of an array. // -// .. deprecated:: 1.22.0 +// Parameters +// ---------- +// a : array_like +// Input array. If it is not already an ndarray, a conversion is +// attempted. // // Returns // ------- -// quantile : scalar or ndarray -// If `q` is a single probability and `axis=None`, then the result -// is a scalar. If multiple probability levels are given, first axis -// of the result corresponds to the quantiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the -// same as that of the input. If `out` is specified, that array is -// returned instead. +// number_of_dimensions : int +// The number of dimensions in `a`. Scalars are zero-dimensional. // // See Also // -------- -// mean -// percentile : equivalent to quantile, but with q in the range [0, 100]. -// median : equivalent to ``quantile(..., 0.5)`` -// nanquantile -// -// Notes -// ----- -// Given a sample `a` from an underlying distribution, `quantile` provides a -// nonparametric estimate of the inverse cumulative distribution function. -// -// By default, this is done by interpolating between adjacent elements in -// ``y``, a sorted copy of `a`:: -// -// (1-g)*y[j] + g*y[j+1] -// -// where the index ``j`` and coefficient ``g`` are the integral and -// fractional components of ``q * (n-1)``, and ``n`` is the number of -// elements in the sample. -// -// This is a special case of Equation 1 of H&F [1]_. More generally, -// -// - ``j = (q*n + m - 1) // 1``, and -// - ``g = (q*n + m - 1) % 1``, -// -// where ``m`` may be defined according to several different conventions. -// The preferred convention may be selected using the ``method`` parameter: -// -// =============================== =============== =============== -// ``method`` number in H&F ``m`` -// =============================== =============== =============== -// ``interpolated_inverted_cdf`` 4 ``0`` -// ``hazen`` 5 ``1/2`` -// ``weibull`` 6 ``q`` -// ``linear`` (default) 7 ``1 - q`` -// ``median_unbiased`` 8 ``q/3 + 1/3`` -// ``normal_unbiased`` 9 ``q/4 + 3/8`` -// =============================== =============== =============== -// -// Note that indices ``j`` and ``j + 1`` are clipped to the range ``0`` to -// ``n - 1`` when the results of the formula would be outside the allowed -// range of non-negative indices. The ``- 1`` in the formulas for ``j`` and -// ``g`` accounts for Python's 0-based indexing. -// -// The table above includes only the estimators from H&F that are continuous -// functions of probability `q` (estimators 4-9). NumPy also provides the -// three discontinuous estimators from H&F (estimators 1-3), where ``j`` is -// defined as above, ``m`` is defined as follows, and ``g`` is a function -// of the real-valued ``index = q*n + m - 1`` and ``j``. -// -// 1. ``inverted_cdf``: ``m = 0`` and ``g = int(index - j > 0)`` -// 2. ``averaged_inverted_cdf``: ``m = 0`` and -// ``g = (1 + int(index - j > 0)) / 2`` -// 3. ``closest_observation``: ``m = -1/2`` and -// ``g = 1 - int((index == j) & (j%2 == 1))`` -// -// For backward compatibility with previous versions of NumPy, `quantile` -// provides four additional discontinuous estimators. Like -// ``method='linear'``, all have ``m = 1 - q`` so that ``j = q*(n-1) // 1``, -// but ``g`` is defined as follows. -// -// - ``lower``: ``g = 0`` -// - ``midpoint``: ``g = 0.5`` -// - ``higher``: ``g = 1`` -// - ``nearest``: ``g = (q*(n-1) % 1) > 0.5`` -// -// **Weighted quantiles:** -// More formally, the quantile at probability level :math:`q` of a cumulative -// distribution function :math:`F(y)=P(Y \leq y)` with probability measure -// :math:`P` is defined as any number :math:`x` that fulfills the -// *coverage conditions* -// -// .. math:: P(Y < x) \leq q \quad\text{and}\quad P(Y \leq x) \geq q -// -// with random variable :math:`Y\sim P`. -// Sample quantiles, the result of `quantile`, provide nonparametric -// estimation of the underlying population counterparts, represented by the -// unknown :math:`F`, given a data vector `a` of length ``n``. -// -// Some of the estimators above arise when one considers :math:`F` as the -// empirical distribution function of the data, i.e. -// :math:`F(y) = \frac{1}{n} \sum_i 1_{a_i \leq y}`. -// Then, different methods correspond to different choices of :math:`x` that -// fulfill the above coverage conditions. Methods that follow this approach -// are ``inverted_cdf`` and ``averaged_inverted_cdf``. -// -// For weighted quantiles, the coverage conditions still hold. The -// empirical cumulative distribution is simply replaced by its weighted -// version, i.e. -// :math:`P(Y \leq t) = \frac{1}{\sum_i w_i} \sum_i w_i 1_{x_i \leq t}`. -// Only ``method="inverted_cdf"`` supports weights. +// ndarray.ndim : equivalent method +// shape : dimensions of array +// ndarray.shape : dimensions of array // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) -// >>> a -// array([[10, 7, 4], -// [ 3, 2, 1]]) -// >>> np.quantile(a, 0.5) -// 3.5 -// >>> np.quantile(a, 0.5, axis=0) -// array([6.5, 4.5, 2.5]) -// >>> np.quantile(a, 0.5, axis=1) -// array([7., 2.]) -// >>> np.quantile(a, 0.5, axis=1, keepdims=True) -// array([[7.], -// [2.]]) -// >>> m = np.quantile(a, 0.5, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.quantile(a, 0.5, axis=0, out=out) -// array([6.5, 4.5, 2.5]) -// >>> m -// array([6.5, 4.5, 2.5]) -// >>> b = a.copy() -// >>> np.quantile(b, 0.5, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a == b) -// -// See also `numpy.percentile` for a visualization of most methods. -// -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 +// >>> np.ndim([[1,2,3],[4,5,6]]) +// 2 +// >>> np.ndim(np.array([[1,2,3],[4,5,6]])) +// 2 +// >>> np.ndim(1) +// 0 // // // -//go:linkname Quantile py.quantile -func Quantile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object +//go:linkname Ndim py.ndim +func Ndim(a *py.Object) *py.Object +// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Returns the indices of the maximum values along an axis. +// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` // -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// By default, the index is into the flattened array, otherwise -// along the specified axis. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. -// 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 array. +// Parameters +// ---------- +// x1, x2 : array_like, int +// Arrays of values. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // -// .. versionadded:: 1.22.0 +// Returns +// ------- +// y : ndarray or scalar +// The lowest common multiple of the absolute value of the inputs +// This is a scalar if both `x1` and `x2` are scalars. // -// Returns -// ------- -// index_array : ndarray of ints -// Array of indices into the array. It has the same shape as ``a.shape`` -// with the dimension along `axis` removed. If `keepdims` is set to True, -// then the size of `axis` will be 1 with the resulting array having same -// shape as ``a.shape``. +// See Also +// -------- +// gcd : The greatest common divisor // -// See Also -// -------- -// ndarray.argmax, argmin -// amax : The maximum value along a given axis. -// unravel_index : Convert a flat index into an index tuple. -// take_along_axis : Apply ``np.expand_dims(index_array, axis)`` -// from argmax to an array as if by calling max. +// Examples +// -------- +// >>> np.lcm(12, 20) +// 60 +// >>> np.lcm.reduce([3, 12, 20]) +// 60 +// >>> np.lcm.reduce([40, 12, 20]) +// 120 +// >>> np.lcm(np.arange(6), 20) +// array([ 0, 20, 20, 60, 20, 20]) // -// Notes -// ----- -// In case of multiple occurrences of the maximum values, the indices -// corresponding to the first occurrence are returned. +//go:linkname Lcm py.lcm +func Lcm(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.arange(6).reshape(2,3) + 10 -// >>> a -// array([[10, 11, 12], -// [13, 14, 15]]) -// >>> np.argmax(a) -// 5 -// >>> np.argmax(a, axis=0) -// array([1, 1, 1]) -// >>> np.argmax(a, axis=1) -// array([2, 2]) +// Return the reciprocal of the argument, element-wise. // -// Indexes of the maximal elements of a N-dimensional array: +// Calculates ``1/x``. // -// >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape) -// >>> ind -// (1, 2) -// >>> a[ind] -// 15 +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> b = np.arange(6) -// >>> b[1] = 5 -// >>> b -// array([0, 5, 2, 3, 4, 5]) -// >>> np.argmax(b) # Only the first occurrence is returned. -// 1 +// Returns +// ------- +// y : ndarray +// Return array. +// This is a scalar if `x` is a scalar. // -// >>> x = np.array([[4,2,3], [1,0,3]]) -// >>> index_array = np.argmax(x, axis=-1) -// >>> # Same as np.amax(x, axis=-1, keepdims=True) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) -// array([[4], -// [3]]) -// >>> # Same as np.amax(x, axis=-1) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), -// ... axis=-1).squeeze(axis=-1) -// array([4, 3]) +// Notes +// ----- +// .. note:: +// This function is not designed to work with integers. // -// Setting `keepdims` to `True`, +// For integer arguments with absolute value larger than 1 the result is +// always zero because of the way Python handles integer division. For +// integer zero the result is an overflow. // -// >>> x = np.arange(24).reshape((2, 3, 4)) -// >>> res = np.argmax(x, axis=1, keepdims=True) -// >>> res.shape -// (2, 1, 4) +// Examples +// -------- +// >>> np.reciprocal(2.) +// 0.5 +// >>> np.reciprocal([1, 2., 3.33]) +// array([ 1. , 0.5 , 0.3003003]) // +//go:linkname Reciprocal py.reciprocal +func Reciprocal(x *py.Object, out *py.Object) *py.Object // -//go:linkname Argmax py.argmax -func Argmax(a *py.Object, axis *py.Object, out *py.Object) *py.Object +// Integrate along the given axis using the composite trapezoidal rule. // -// Return an array representing the indices of a grid. +// If `x` is provided, the integration happens in sequence along its +// elements - they are not sorted. // -// Compute an array where the subarrays contain index values 0, 1, ... -// varying only along the corresponding axis. +// Integrate `y` (`x`) along each 1d slice on the given axis, compute +// :math:`\int y(x) dx`. +// When `x` is specified, this integrates along the parametric curve, +// computing :math:`\int_t y(t) dt = +// \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`. // // Parameters // ---------- -// dimensions : sequence of ints -// The shape of the grid. -// dtype : dtype, optional -// Data type of the result. -// sparse : boolean, optional -// Return a sparse representation of the grid instead of a dense -// representation. Default is False. -// -// Returns -// ------- -// grid : one ndarray or tuple of ndarrays -// If sparse is False: -// Returns one array of grid indices, -// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. -// If sparse is True: -// Returns a tuple of arrays, with -// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with -// dimensions[i] in the ith place +// y : array_like +// Input array to integrate. +// x : array_like, optional +// The sample points corresponding to the `y` values. If `x` is None, +// the sample points are assumed to be evenly spaced `dx` apart. The +// default is None. +// dx : scalar, optional +// The spacing between sample points when `x` is None. The default is 1. +// axis : int, optional +// The axis along which to integrate. +// +// 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. // // See Also // -------- -// mgrid, ogrid, meshgrid +// sum, cumsum // // Notes // ----- -// The output shape in the dense case is obtained by prepending the number -// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` -// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is -// ``(N, r0, ..., rN-1)``. +// Image [2]_ illustrates trapezoidal rule -- y-axis locations of points +// will be taken from `y` array, by default x-axis distances between +// points will be 1.0, alternatively they can be provided with `x` array +// or with `dx` scalar. Return value will be equal to combined area under +// the red lines. // -// The subarrays ``grid[k]`` contains the N-D array of indices along the -// ``k-th`` axis. Explicitly:: // -// grid[k, i0, i1, ..., iN-1] = ik +// References +// ---------- +// .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule +// +// .. [2] Illustration image: +// https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png // // Examples // -------- -// >>> import numpy as np -// >>> grid = np.indices((2, 3)) -// >>> grid.shape -// (2, 2, 3) -// >>> grid[0] # row indices -// array([[0, 0, 0], -// [1, 1, 1]]) -// >>> grid[1] # column indices -// array([[0, 1, 2], -// [0, 1, 2]]) +// Use the trapezoidal rule on evenly spaced points: // -// The indices can be used as an index into an array. +// >>> np.trapz([1, 2, 3]) +// 4.0 // -// >>> x = np.arange(20).reshape(5, 4) -// >>> row, col = np.indices((2, 3)) -// >>> x[row, col] -// array([[0, 1, 2], -// [4, 5, 6]]) +// The spacing between sample points can be selected by either the +// ``x`` or ``dx`` arguments: // -// Note that it would be more straightforward in the above example to -// extract the required elements directly with ``x[:2, :3]``. +// >>> np.trapz([1, 2, 3], x=[4, 6, 8]) +// 8.0 +// >>> np.trapz([1, 2, 3], dx=2) +// 8.0 // -// If sparse is set to true, the grid will be returned in a sparse -// representation. +// Using a decreasing ``x`` corresponds to integrating in reverse: // -// >>> i, j = np.indices((2, 3), sparse=True) -// >>> i.shape -// (2, 1) -// >>> j.shape -// (1, 3) -// >>> i # row indices -// array([[0], -// [1]]) -// >>> j # column indices -// array([[0, 1, 2]]) +// >>> np.trapz([1, 2, 3], x=[8, 6, 4]) +// -8.0 // +// More generally ``x`` is used to integrate along a parametric curve. We can +// estimate the integral :math:`\int_0^1 x^2 = 1/3` using: // +// >>> x = np.linspace(0, 1, num=50) +// >>> y = x**2 +// >>> np.trapz(y, x) +// 0.33340274885464394 // -//go:linkname Indices py.indices -func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object +// Or estimate the area of a circle, noting we repeat the sample which closes +// the curve: // -// Return an ndarray of the provided type that satisfies requirements. +// >>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True) +// >>> np.trapz(np.cos(theta), x=np.sin(theta)) +// 3.141571941375841 // -// This function is useful to be sure that an array with the correct flags -// is returned for passing to compiled code (perhaps through ctypes). +// ``np.trapz`` can be applied along a specified axis to do multiple +// computations in one call: // -// Parameters -// ---------- -// a : array_like -// The object to be converted to a type-and-requirement-satisfying array. -// dtype : data-type -// 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 sequence of str -// The requirements list can be any of the following +// >>> a = np.arange(6).reshape(2, 3) +// >>> a +// array([[0, 1, 2], +// [3, 4, 5]]) +// >>> np.trapz(a, axis=0) +// array([1.5, 2.5, 3.5]) +// >>> np.trapz(a, axis=1) +// array([2., 8.]) // -// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array -// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array -// * 'ALIGNED' ('A') - ensure a data-type aligned array -// * 'WRITEABLE' ('W') - ensure a writable array -// * 'OWNDATA' ('O') - ensure an array that owns its own data -// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. // -// .. versionadded:: 1.20.0 +//go:linkname Trapz py.trapz +func Trapz(y *py.Object, x *py.Object, dx *py.Object, axis *py.Object) *py.Object +// +// Reverse the order of elements along axis 1 (left/right). +// +// For a 2-D array, this flips the entries in each row in the left/right +// direction. Columns are preserved, but appear in a different order than +// before. +// +// Parameters +// ---------- +// m : array_like +// Input array, must be at least 2-D. // // Returns // ------- -// out : ndarray -// Array with specified requirements and type if given. +// f : ndarray +// A view of `m` with the columns reversed. Since a view +// is returned, this operation is :math:`\mathcal O(1)`. // // See Also // -------- -// asarray : Convert input to an ndarray. -// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// ndarray.flags : Information about the memory layout of the array. +// flipud : Flip array in the up/down direction. +// flip : Flip array in one or more dimensions. +// rot90 : Rotate array counterclockwise. // // Notes // ----- -// The returned array will be guaranteed to have the listed requirements -// by making a copy if needed. +// Equivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``. +// Requires the array to be at least 2-D. // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(6).reshape(2,3) -// >>> x.flags -// C_CONTIGUOUS : True -// F_CONTIGUOUS : False -// OWNDATA : False -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False +// >>> A = np.diag([1.,2.,3.]) +// >>> A +// array([[1., 0., 0.], +// [0., 2., 0.], +// [0., 0., 3.]]) +// >>> np.fliplr(A) +// array([[0., 0., 1.], +// [0., 2., 0.], +// [3., 0., 0.]]) // -// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) -// >>> y.flags -// C_CONTIGUOUS : False -// F_CONTIGUOUS : True -// OWNDATA : True -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False +// >>> A = np.random.randn(2,3,5) +// >>> np.all(np.fliplr(A) == A[:,::-1,...]) +// True // // // -//go:linkname Require py.require -func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object +//go:linkname Fliplr py.fliplr +func Fliplr(m *py.Object) *py.Object // -// Return the Kaiser window. +// Issues a DeprecationWarning, adds warning to `old_name`'s +// docstring, rebinds ``old_name.__name__`` and returns the new +// function object. // -// The Kaiser window is a taper formed by using a Bessel function. +// This function may also be used as a decorator. // // Parameters // ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// beta : float -// Shape parameter for window. +// func : function +// The function to be deprecated. +// old_name : str, optional +// The name of the function to be deprecated. Default is None, in +// which case the name of `func` is used. +// new_name : str, optional +// The new name for the function. Default is None, in which case the +// deprecation message is that `old_name` is deprecated. If given, the +// deprecation message is that `old_name` is deprecated and `new_name` +// should be used instead. +// message : str, optional +// Additional explanation of the deprecation. Displayed in the +// docstring after the warning. // // Returns // ------- -// out : array -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). +// old_func : function +// The deprecated function. // -// See Also +// Examples // -------- -// bartlett, blackman, hamming, hanning -// -// Notes -// ----- -// The Kaiser window is defined as -// -// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} -// \right)/I_0(\beta) +// Note that ``olduint`` returns a value after printing Deprecation +// Warning: // -// with +// >>> olduint = np.deprecate(np.uint) +// DeprecationWarning: `uint64` is deprecated! # may vary +// >>> olduint(6) +// 6 // -// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, // -// where :math:`I_0` is the modified zeroth-order Bessel function. // -// The Kaiser was named for Jim Kaiser, who discovered a simple -// approximation to the DPSS window based on Bessel functions. The Kaiser -// window is a very good approximation to the Digital Prolate Spheroidal -// Sequence, or Slepian window, which is the transform which maximizes the -// energy in the main lobe of the window relative to total energy. +//go:linkname Deprecate py.deprecate +func Deprecate(__llgo_va_list ...interface{}) *py.Object // -// The Kaiser can approximate many other windows by varying the beta -// parameter. +// Find the intersection of two arrays. // -// ==== ======================= -// beta Window shape -// ==== ======================= -// 0 Rectangular -// 5 Similar to a Hamming -// 6 Similar to a Hanning -// 8.6 Similar to a Blackman -// ==== ======================= +// Return the sorted, unique values that are in both of the input arrays. // -// A beta value of 14 is probably a good starting point. Note that as beta -// gets large, the window narrows, and so the number of samples needs to be -// large enough to sample the increasingly narrow spike, otherwise NaNs will -// get returned. +// Parameters +// ---------- +// ar1, ar2 : array_like +// Input arrays. Will be flattened if not already 1D. +// assume_unique : bool +// If True, the input arrays are both assumed to be unique, which +// can speed up the calculation. If True but ``ar1`` or ``ar2`` are not +// unique, incorrect results and out-of-bounds indices could result. +// Default is False. +// return_indices : bool +// If True, the indices which correspond to the intersection of the two +// arrays are returned. The first instance of a value is used if there are +// multiple. Default is False. // -// Most references to the Kaiser window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. +// .. versionadded:: 1.15.0 // -// References -// ---------- -// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by -// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. -// John Wiley and Sons, New York, (1966). -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 177-178. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function +// Returns +// ------- +// intersect1d : ndarray +// Sorted 1D array of common and unique elements. +// comm1 : ndarray +// The indices of the first occurrences of the common values in `ar1`. +// Only provided if `return_indices` is True. +// comm2 : ndarray +// The indices of the first occurrences of the common values in `ar2`. +// Only provided if `return_indices` is True. +// +// +// See Also +// -------- +// numpy.lib.arraysetops : Module with a number of other functions for +// performing set operations on arrays. // // Examples // -------- -// >>> import numpy as np -// >>> import matplotlib.pyplot as plt -// >>> np.kaiser(12, 14) -// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary -// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, -// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, -// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) +// >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1]) +// array([1, 3]) +// +// To intersect more than two arrays, use functools.reduce: +// +// >>> from functools import reduce +// >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) +// array([3]) // +// To return the indices of the values common to the input arrays +// along with the intersected values: // -// Plot the window and the frequency response. +// >>> x = np.array([1, 1, 2, 3, 4]) +// >>> y = np.array([2, 1, 4, 6]) +// >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True) +// >>> x_ind, y_ind +// (array([0, 2, 4]), array([1, 0, 2])) +// >>> xy, x[x_ind], y[y_ind] +// (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4])) // -// .. plot:: -// :include-source: // -// import matplotlib.pyplot as plt -// from numpy.fft import fft, fftshift -// window = np.kaiser(51, 14) -// plt.plot(window) -// plt.title("Kaiser window") -// plt.ylabel("Amplitude") -// plt.xlabel("Sample") -// plt.show() // -// plt.figure() -// A = fft(window, 2048) / 25.5 -// mag = np.abs(fftshift(A)) -// freq = np.linspace(-0.5, 0.5, len(A)) -// response = 20 * np.log10(mag) -// response = np.clip(response, -100, 100) -// plt.plot(freq, response) -// plt.title("Frequency response of Kaiser window") -// plt.ylabel("Magnitude [dB]") -// plt.xlabel("Normalized frequency [cycles per sample]") -// plt.axis('tight') -// plt.show() +//go:linkname Intersect1d py.intersect1d +func Intersect1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, returnIndices *py.Object) *py.Object // +// min_scalar_type(a, /) // +// For scalar ``a``, returns the data type with the smallest size +// and smallest scalar kind which can hold its value. For non-scalar +// array ``a``, returns the vector's dtype unmodified. // -//go:linkname Kaiser py.kaiser -func Kaiser(M *py.Object, beta *py.Object) *py.Object -// Remove values along a dimension which are zero along all other. +// Floating point values are not demoted to integers, +// and complex values are not demoted to floats. // // Parameters // ---------- -// filt : array_like -// Input array. -// trim : {"fb", "f", "b"}, optional -// A string with 'f' representing trim from front and 'b' to trim from -// back. By default, zeros are trimmed on both sides. -// Front and back refer to the edges of a dimension, with "front" referring -// to the side with the lowest index 0, and "back" referring to the highest -// index (or index -1). -// axis : int or sequence, optional -// If None, `filt` is cropped such that the smallest bounding box is -// returned that still contains all values which are not zero. -// If an axis is specified, `filt` will be sliced in that dimension only -// on the sides specified by `trim`. The remaining area will be the -// smallest that still contains all values wich are not zero. -// -// .. versionadded:: 2.2.0 +// a : scalar or array_like +// The value whose minimal data type is to be found. // // Returns // ------- -// trimmed : ndarray or sequence -// The result of trimming the input. The number of dimensions and the -// input data type are preserved. +// out : dtype +// The minimal data type. // // Notes // ----- -// For all-zero arrays, the first axis is trimmed first. +// .. versionadded:: 1.6.0 // -// Examples +// See Also // -------- -// >>> import numpy as np -// >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0)) -// >>> np.trim_zeros(a) -// array([1, 2, 3, 0, 2, 1]) -// -// >>> np.trim_zeros(a, trim='b') -// array([0, 0, 0, ..., 0, 2, 1]) +// result_type, promote_types, dtype, can_cast // -// Multiple dimensions are supported. +// Examples +// -------- +// >>> np.min_scalar_type(10) +// dtype('uint8') // -// >>> b = np.array([[0, 0, 2, 3, 0, 0], -// ... [0, 1, 0, 3, 0, 0], -// ... [0, 0, 0, 0, 0, 0]]) -// >>> np.trim_zeros(b) -// array([[0, 2, 3], -// [1, 0, 3]]) +// >>> np.min_scalar_type(-260) +// dtype('int16') // -// >>> np.trim_zeros(b, axis=-1) -// array([[0, 2, 3], -// [1, 0, 3], -// [0, 0, 0]]) +// >>> np.min_scalar_type(3.1) +// dtype('float16') // -// The input data type is preserved, list/tuple in means list/tuple out. +// >>> np.min_scalar_type(1e50) +// dtype('float64') // -// >>> np.trim_zeros([0, 1, 2, 0]) -// [1, 2] +// >>> np.min_scalar_type(np.arange(4,dtype='f8')) +// dtype('float64') // // // -//go:linkname TrimZeros py.trim_zeros -func TrimZeros(filt *py.Object, trim *py.Object, axis *py.Object) *py.Object +//go:linkname MinScalarType py.min_scalar_type +func MinScalarType(a *py.Object) *py.Object // -// Compute the multidimensional histogram of some data. +// Return the indices of the elements that are non-zero. // -// Parameters -// ---------- -// sample : (N, D) array, or (N, D) array_like -// The data to be histogrammed. +// Returns a tuple of arrays, one for each dimension of `a`, +// containing the indices of the non-zero elements in that +// dimension. The values in `a` are always tested and returned in +// row-major, C-style order. // -// Note the unusual interpretation of sample when an array_like: +// To group the indices by element, rather than dimension, use `argwhere`, +// which returns a row for each non-zero element. // -// * When an array, each row is a coordinate in a D-dimensional space - -// such as ``histogramdd(np.array([p1, p2, p3]))``. -// * When an array_like, each element is the list of values for single -// coordinate - such as ``histogramdd((X, Y, Z))``. +// .. note:: // -// The first form should be preferred. +// When called on a zero-d array or scalar, ``nonzero(a)`` is treated +// as ``nonzero(atleast_1d(a))``. // -// bins : sequence or int, optional -// The bin specification: +// .. deprecated:: 1.17.0 // -// * A sequence of arrays describing the monotonically increasing bin -// edges along each dimension. -// * The number of bins for each dimension (nx, ny, ... =bins) -// * The number of bins for all dimensions (nx=ny=...=bins). +// Use `atleast_1d` explicitly if this behavior is deliberate. // -// range : sequence, optional -// A sequence of length D, each an optional (lower, upper) tuple giving -// the outer bin edges to be used if the edges are not given explicitly in -// `bins`. -// An entry of None in the sequence results in the minimum and maximum -// values being used for the corresponding dimension. -// The default, None, is equivalent to passing a tuple of D None values. -// density : bool, optional -// 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``. -// 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 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. +// Parameters +// ---------- +// a : array_like +// Input array. // // Returns // ------- -// H : ndarray -// The multidimensional histogram of sample x. See density and weights -// for the different possible semantics. -// edges : tuple of ndarrays -// A tuple of D arrays describing the bin edges for each dimension. +// tuple_of_arrays : tuple +// Indices of elements that are non-zero. // // See Also // -------- -// histogram: 1-D histogram -// histogram2d: 2-D histogram +// flatnonzero : +// Return indices that are non-zero in the flattened version of the input +// array. +// ndarray.nonzero : +// Equivalent ndarray method. +// count_nonzero : +// Counts the number of non-zero elements in the input array. +// +// Notes +// ----- +// While the nonzero values can be obtained with ``a[nonzero(a)]``, it is +// recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which +// will correctly handle 0-d arrays. // // Examples // -------- -// >>> import numpy as np -// >>> rng = np.random.default_rng() -// >>> r = rng.normal(size=(100,3)) -// >>> H, edges = np.histogramdd(r, bins = (5, 8, 4)) -// >>> H.shape, edges[0].size, edges[1].size, edges[2].size -// ((5, 8, 4), 6, 9, 5) -// -// -// -//go:linkname Histogramdd py.histogramdd -func Histogramdd(sample *py.Object, bins *py.Object, range_ *py.Object, density *py.Object, weights *py.Object) *py.Object -// -// Compute the arithmetic mean along the specified axis, ignoring NaNs. -// -// Returns the average of the array elements. The average is taken over -// the flattened array by default, otherwise over the specified axis. -// `float64` intermediate and return values are used for integer inputs. +// >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]]) +// >>> x +// array([[3, 0, 0], +// [0, 4, 0], +// [5, 6, 0]]) +// >>> np.nonzero(x) +// (array([0, 1, 2, 2]), array([0, 1, 0, 1])) // -// For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised. +// >>> x[np.nonzero(x)] +// array([3, 4, 5, 6]) +// >>> np.transpose(np.nonzero(x)) +// array([[0, 0], +// [1, 1], +// [2, 0], +// [2, 1]]) // -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose mean is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the means are computed. The default is to compute -// the mean of the flattened array. -// dtype : data-type, optional -// Type to use in computing the mean. For integer inputs, the default -// is `float64`; for inexact inputs, it is the same as the input -// dtype. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. -// See :ref:`ufuncs-output-type` for more details. -// 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`. +// A common use for ``nonzero`` is to find the indices of an array, where +// a condition is True. Given an array `a`, the condition `a` > 3 is a +// boolean array and since False is interpreted as 0, np.nonzero(a > 3) +// yields the indices of the `a` where the condition is true. // -// If the value is anything but the default, then -// `keepdims` will be passed through to the `mean` or `sum` methods -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// where : array_like of bool, optional -// Elements to include in the mean. See `~numpy.ufunc.reduce` for details. +// >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) +// >>> a > 3 +// array([[False, False, False], +// [ True, True, True], +// [ True, True, True]]) +// >>> np.nonzero(a > 3) +// (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) // -// .. versionadded:: 1.22.0 +// Using this result to index `a` is equivalent to using the mask directly: // -// Returns -// ------- -// m : ndarray, see dtype parameter above -// If `out=None`, returns a new array containing the mean values, -// otherwise a reference to the output array is returned. Nan is -// returned for slices that contain only NaNs. +// >>> a[np.nonzero(a > 3)] +// array([4, 5, 6, 7, 8, 9]) +// >>> a[a > 3] # prefer this spelling +// array([4, 5, 6, 7, 8, 9]) // -// See Also -// -------- -// average : Weighted average -// mean : Arithmetic mean taken while not ignoring NaNs -// var, nanvar +// ``nonzero`` can also be called as a method of the array. // -// Notes -// ----- -// The arithmetic mean is the sum of the non-NaN elements along the axis -// divided by the number of non-NaN elements. +// >>> (a > 3).nonzero() +// (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) // -// Note that for floating-point input, the mean is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for `float32`. Specifying a -// higher-precision accumulator using the `dtype` keyword can alleviate -// this issue. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1, np.nan], [3, 4]]) -// >>> np.nanmean(a) -// 2.6666666666666665 -// >>> np.nanmean(a, axis=0) -// array([2., 4.]) -// >>> np.nanmean(a, axis=1) -// array([1., 3.5]) # may vary // +//go:linkname Nonzero py.nonzero +func Nonzero(a *py.Object) *py.Object // +// Compute the median along the specified axis, while ignoring NaNs. // -//go:linkname Nanmean py.nanmean -func Nanmean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object) *py.Object +// Returns the median of the array elements. // -// Compute the qth quantile of the data along the specified axis, -// while ignoring nan values. -// Returns the qth quantile(s) of the array elements. +// .. versionadded:: 1.9.0 // // Parameters // ---------- // a : array_like -// Input array or object that can be converted to an array, containing -// nan values to be ignored -// q : array_like of float -// Probability or sequence of probabilities for the quantiles to compute. -// Values must be between 0 and 1 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the quantiles are computed. The -// default is to compute the quantile(s) along a flattened -// version of the array. +// Input array or object that can be converted to an array. +// axis : {int, sequence of int, None}, optional +// Axis or axes along which the medians are computed. The default +// is to compute the median along a flattened version of the array. +// A sequence of axes is supported since version 1.9.0. // out : ndarray, optional // Alternative output array in which to place the result. It must // have the same shape and buffer length as the expected output, // but the type (of the output) will be cast if necessary. // overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by intermediate -// calculations, to save memory. In this case, the contents of the input -// `a` after this function completes is undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// quantile. There are many different methods, some unique to NumPy. -// See the notes for explanation. The options sorted by their R type -// as summarized in the H&F paper [1]_ are: -// -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' -// -// The first three methods are discontinuous. NumPy further defines the -// following discontinuous variations of the default 'linear' (7.) option: -// -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' -// -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. -// +// If True, then allow use of memory of input array `a` for +// calculations. The input array will be modified by the call to +// `median`. This will save memory when you do not need to preserve +// the contents of the input array. Treat the input as undefined, +// but it will probably be fully or partially sorted. Default is +// False. If `overwrite_input` is ``True`` and `a` is not already an +// `ndarray`, an error will be raised. // 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 array `a`. +// 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`. // // If this is anything but the default value it will be passed // through (in the special case of an empty array) to the @@ -22602,839 +22091,654 @@ func Nanmean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ke // a sub-class and `mean` does not have the kwarg `keepdims` this // will raise a RuntimeError. // -// weights : array_like, optional -// An array of weights associated with the values in `a`. Each value in -// `a` contributes to the quantile according to its associated weight. -// The weights array can either be 1-D (in which case its length must be -// the size of `a` along the given axis) or of the same shape as `a`. -// If `weights=None`, then all data in `a` are assumed to have a -// weight equal to one. -// Only `method="inverted_cdf"` supports weights. -// -// .. versionadded:: 2.0.0 -// -// interpolation : str, optional -// Deprecated name for the method keyword argument. -// -// .. deprecated:: 1.22.0 -// // Returns // ------- -// quantile : scalar or ndarray -// If `q` is a single probability and `axis=None`, then the result -// is a scalar. If multiple probability levels are given, first axis of -// the result corresponds to the quantiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the +// median : ndarray +// A new array holding the result. If the input contains integers +// or floats smaller than ``float64``, then the output data-type is +// ``np.float64``. Otherwise, the data-type of the output is the // same as that of the input. If `out` is specified, that array is // returned instead. // // See Also // -------- -// quantile -// nanmean, nanmedian -// nanmedian : equivalent to ``nanquantile(..., 0.5)`` -// nanpercentile : same as nanquantile, but with q in the range [0, 100]. +// mean, median, percentile // // Notes // ----- -// The behavior of `numpy.nanquantile` is the same as that of -// `numpy.quantile` (ignoring nan values). -// For more information, please see `numpy.quantile`. +// Given a vector ``V`` of length ``N``, the median of ``V`` is the +// middle value of a sorted copy of ``V``, ``V_sorted`` - i.e., +// ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two +// middle values of ``V_sorted`` when ``N`` is even. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[10., 7., 4.], [3., 2., 1.]]) -// >>> a[0][1] = np.nan +// >>> a = np.array([[10.0, 7, 4], [3, 2, 1]]) +// >>> a[0, 1] = np.nan // >>> a -// array([[10., nan, 4.], -// [ 3., 2., 1.]]) -// >>> np.quantile(a, 0.5) -// np.float64(nan) -// >>> np.nanquantile(a, 0.5) +// array([[10., nan, 4.], +// [ 3., 2., 1.]]) +// >>> np.median(a) +// nan +// >>> np.nanmedian(a) // 3.0 -// >>> np.nanquantile(a, 0.5, axis=0) -// array([6.5, 2. , 2.5]) -// >>> np.nanquantile(a, 0.5, axis=1, keepdims=True) -// array([[7.], -// [2.]]) -// >>> m = np.nanquantile(a, 0.5, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.nanquantile(a, 0.5, axis=0, out=out) +// >>> np.nanmedian(a, axis=0) // array([6.5, 2. , 2.5]) -// >>> m -// array([6.5, 2. , 2.5]) +// >>> np.median(a, axis=1) +// array([nan, 2.]) // >>> b = a.copy() -// >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True) -// array([7., 2.]) +// >>> np.nanmedian(b, axis=1, overwrite_input=True) +// array([7., 2.]) +// >>> assert not np.all(a==b) +// >>> b = a.copy() +// >>> np.nanmedian(b, axis=None, overwrite_input=True) +// 3.0 // >>> assert not np.all(a==b) // -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 -// -// -// -//go:linkname Nanquantile py.nanquantile -func Nanquantile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object -// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// First array elements raised to powers from second array, element-wise. // -// Raise each base in `x1` to the positionally-corresponding power in -// `x2`. `x1` and `x2` must be broadcastable to the same shape. // -// An integer type raised to a negative integer power will raise a -// ``ValueError``. +//go:linkname Nanmedian py.nanmedian +func Nanmedian(a *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, keepdims *py.Object) *py.Object +// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). +// Return the element-wise square of the input. // // Parameters // ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// float_power : power function that promotes integers to float -// -// Examples -// -------- -// >>> import numpy as np -// -// Cube each element in an array. -// -// >>> x1 = np.arange(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.power(x1, 3) -// array([ 0, 1, 8, 27, 64, 125]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.power(x1, x2) -// array([[ 0, 1, 8, 27, 16, 5], -// [ 0, 1, 8, 27, 16, 5]]) -// -// The ``**`` operator can be used as a shorthand for ``np.power`` on -// ndarrays. -// -// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) -// >>> x1 = np.arange(6) -// >>> x1 ** x2 -// array([ 0, 1, 8, 27, 16, 5]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1.0, -4.0]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname Power py.power -func Power(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// vdot(a, b, /) -// -// Return the dot product of two vectors. -// -// The `vdot` function handles complex numbers differently than `dot`: -// if the first argument is complex, it is replaced by its complex conjugate -// in the dot product calculation. `vdot` also handles multidimensional -// arrays differently than `dot`: it does not perform a matrix product, but -// flattens the arguments to 1-D arrays before taking a vector dot product. -// -// Consequently, when the arguments are 2-D arrays of the same shape, this -// function effectively returns their -// `Frobenius inner product `_ -// (also known as the *trace inner product* or the *standard inner product* -// on a vector space of matrices). -// -// Parameters -// ---------- -// a : array_like -// If `a` is complex the complex conjugate is taken before calculation -// of the dot product. -// b : array_like -// Second argument to the dot product. -// -// Returns -// ------- -// output : ndarray -// Dot product of `a` and `b`. Can be an int, float, or -// complex depending on the types of `a` and `b`. +// x : array_like +// Input data. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// See Also -// -------- -// dot : Return the dot product without using the complex conjugate of the -// first argument. +// Returns +// ------- +// out : ndarray or scalar +// Element-wise `x*x`, of the same shape and dtype as `x`. +// This is a scalar if `x` is a scalar. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([1+2j,3+4j]) -// >>> b = np.array([5+6j,7+8j]) -// >>> np.vdot(a, b) -// (70-8j) -// >>> np.vdot(b, a) -// (70+8j) +// See Also +// -------- +// numpy.linalg.matrix_power +// sqrt +// power // -// Note that higher-dimensional arrays are flattened! +// Examples +// -------- +// >>> np.square([-1j, 1]) +// array([-1.-0.j, 1.+0.j]) // -// >>> a = np.array([[1, 4], [5, 6]]) -// >>> b = np.array([[4, 1], [2, 2]]) -// >>> np.vdot(a, b) -// 30 -// >>> np.vdot(b, a) -// 30 -// >>> 1*4 + 4*1 + 5*2 + 6*2 -// 30 +//go:linkname Square py.square +func Square(x *py.Object, out *py.Object) *py.Object // +// Construct an open mesh from multiple sequences. // +// This function takes N 1-D sequences and returns N outputs with N +// dimensions each, such that the shape is 1 in all but one dimension +// and the dimension with the non-unit shape value cycles through all +// N dimensions. // -//go:linkname Vdot py.vdot -func Vdot(a *py.Object, b *py.Object) *py.Object -// Convert the input to an array, checking for NaNs or Infs. +// Using `ix_` one can quickly construct index arrays that will index +// the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array +// ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``. // // Parameters // ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes lists, lists of tuples, tuples, tuples of tuples, tuples -// of lists and ndarrays. Success requires no NaNs or Infs. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'C'. +// args : 1-D sequences +// Each sequence should be of integer or boolean type. +// Boolean sequences will be interpreted as boolean masks for the +// corresponding dimension (equivalent to passing in +// ``np.nonzero(boolean_sequence)``). // // Returns // ------- -// out : ndarray -// Array interpretation of `a`. No copy is performed if the input -// is already an ndarray. If `a` is a subclass of ndarray, a base -// class ndarray is returned. -// -// Raises -// ------ -// ValueError -// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). +// out : tuple of ndarrays +// N arrays with N dimensions each, with N the number of input +// sequences. Together these arrays form an open mesh. // // See Also // -------- -// asarray : Create and array. -// asanyarray : Similar function which passes through subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. +// ogrid, mgrid, meshgrid // // Examples // -------- -// >>> import numpy as np +// >>> a = np.arange(10).reshape(2, 5) +// >>> a +// array([[0, 1, 2, 3, 4], +// [5, 6, 7, 8, 9]]) +// >>> ixgrid = np.ix_([0, 1], [2, 4]) +// >>> ixgrid +// (array([[0], +// [1]]), array([[2, 4]])) +// >>> ixgrid[0].shape, ixgrid[1].shape +// ((2, 1), (1, 2)) +// >>> a[ixgrid] +// array([[2, 4], +// [7, 9]]) // -// Convert a list into an array. If all elements are finite, then -// ``asarray_chkfinite`` is identical to ``asarray``. +// >>> ixgrid = np.ix_([True, True], [2, 4]) +// >>> a[ixgrid] +// array([[2, 4], +// [7, 9]]) +// >>> ixgrid = np.ix_([True, True], [False, False, True, False, True]) +// >>> a[ixgrid] +// array([[2, 4], +// [7, 9]]) // -// >>> a = [1, 2] -// >>> np.asarray_chkfinite(a, dtype=float) -// array([1., 2.]) // -// Raises ValueError if array_like contains Nans or Infs. // -// >>> a = [1, 2, np.inf] -// >>> try: -// ... np.asarray_chkfinite(a) -// ... except ValueError: -// ... print('ValueError') -// ... -// ValueError +//go:linkname Ix_ py.ix_ +func Ix_(__llgo_va_list ...interface{}) *py.Object // +// Return the normalized sinc function. // +// 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. // -//go:linkname AsarrayChkfinite py.asarray_chkfinite -func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object +// .. note:: // -// Return the maximum of an array or maximum along an axis, ignoring any -// NaNs. When all-NaN slices are encountered a ``RuntimeWarning`` is -// raised and NaN is returned for that slice. +// 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. // // Parameters // ---------- -// a : array_like -// Array containing numbers whose maximum is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the maximum is computed. The default is to compute -// the maximum of the flattened array. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. -// 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`. -// If the value is anything but the default, then -// `keepdims` will be passed through to the `max` method -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// initial : scalar, optional -// The minimum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to compare for the maximum. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.22.0 +// x : ndarray +// Array (possibly multi-dimensional) of values for which to calculate +// ``sinc(x)``. // // Returns // ------- -// nanmax : ndarray -// An array with the same shape as `a`, with the specified axis removed. -// If `a` is a 0-d array, or if axis is None, an ndarray scalar is -// returned. The same dtype as `a` is returned. -// -// See Also -// -------- -// nanmin : -// The minimum value of an array along a given axis, ignoring any NaNs. -// amax : -// The maximum value of an array along a given axis, propagating any NaNs. -// fmax : -// Element-wise maximum of two arrays, ignoring any NaNs. -// maximum : -// Element-wise maximum of two arrays, propagating any NaNs. -// isnan : -// Shows which elements are Not a Number (NaN). -// isfinite: -// Shows which elements are neither NaN nor infinity. -// -// amin, fmin, minimum +// out : ndarray +// ``sinc(x)``, which has the same shape as the input. // // Notes // ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// Positive infinity is treated as a very large number and negative -// infinity is treated as a very small (i.e. negative) number. +// The name sinc is short for "sine cardinal" or "sinus cardinalis". // -// If the input has a integer type the function is equivalent to np.max. +// The sinc function is used in various signal processing applications, +// including in anti-aliasing, in the construction of a Lanczos resampling +// filter, and in interpolation. +// +// For bandlimited interpolation of discrete-time signals, the ideal +// interpolation kernel is proportional to the sinc function. +// +// References +// ---------- +// .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web +// Resource. http://mathworld.wolfram.com/SincFunction.html +// .. [2] Wikipedia, "Sinc function", +// https://en.wikipedia.org/wiki/Sinc_function // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nanmax(a) -// 3.0 -// >>> np.nanmax(a, axis=0) -// array([3., 2.]) -// >>> np.nanmax(a, axis=1) -// array([2., 3.]) +// >>> import matplotlib.pyplot as plt +// >>> x = np.linspace(-4, 4, 41) +// >>> np.sinc(x) +// array([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary +// -8.90384387e-02, -5.84680802e-02, 3.89804309e-17, +// 6.68206631e-02, 1.16434881e-01, 1.26137788e-01, +// 8.50444803e-02, -3.89804309e-17, -1.03943254e-01, +// -1.89206682e-01, -2.16236208e-01, -1.55914881e-01, +// 3.89804309e-17, 2.33872321e-01, 5.04551152e-01, +// 7.56826729e-01, 9.35489284e-01, 1.00000000e+00, +// 9.35489284e-01, 7.56826729e-01, 5.04551152e-01, +// 2.33872321e-01, 3.89804309e-17, -1.55914881e-01, +// -2.16236208e-01, -1.89206682e-01, -1.03943254e-01, +// -3.89804309e-17, 8.50444803e-02, 1.26137788e-01, +// 1.16434881e-01, 6.68206631e-02, 3.89804309e-17, +// -5.84680802e-02, -8.90384387e-02, -8.40918587e-02, +// -4.92362781e-02, -3.89804309e-17]) +// +// >>> plt.plot(x, np.sinc(x)) +// [] +// >>> plt.title("Sinc Function") +// Text(0.5, 1.0, 'Sinc Function') +// >>> plt.ylabel("Amplitude") +// Text(0, 0.5, 'Amplitude') +// >>> plt.xlabel("X") +// Text(0.5, 0, 'X') +// >>> plt.show() // -// When positive infinity and negative infinity are present: // -// >>> np.nanmax([1, 2, np.nan, -np.inf]) -// 2.0 -// >>> np.nanmax([1, 2, np.nan, np.inf]) -// inf // +//go:linkname Sinc py.sinc +func Sinc(x *py.Object) *py.Object // +// Return the roots of a polynomial with coefficients given in p. // -//go:linkname Nanmax py.nanmax -func Nanmax(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. // -// Compute the qth percentile of the data along the specified axis, -// while ignoring nan values. +// The values in the rank-1 array `p` are coefficients of a polynomial. +// If the length of `p` is n+1 then the polynomial is described by:: // -// Returns the qth percentile(s) of the array elements. +// p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n] // // Parameters // ---------- -// a : array_like -// Input array or object that can be converted to an array, containing -// nan values to be ignored. -// q : array_like of float -// Percentile or sequence of percentiles to compute, which must be -// between 0 and 100 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the percentiles are computed. The default -// is to compute the percentile(s) along a flattened version of the -// array. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape and buffer length as the expected output, but the -// type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by -// intermediate calculations, to save memory. In this case, the -// contents of the input `a` after this function completes is -// undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// percentile. There are many different methods, some unique to NumPy. -// See the notes for explanation. The options sorted by their R type -// as summarized in the H&F paper [1]_ are: +// p : array_like +// Rank-1 array of polynomial coefficients. // -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' +// Returns +// ------- +// out : ndarray +// An array containing the roots of the polynomial. // -// The first three methods are discontinuous. NumPy further defines the -// following discontinuous variations of the default 'linear' (7.) option: +// Raises +// ------ +// ValueError +// When `p` cannot be converted to a rank-1 array. // -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' +// See also +// -------- +// poly : Find the coefficients of a polynomial with a given sequence +// of roots. +// polyval : Compute polynomial values. +// polyfit : Least squares polynomial fit. +// poly1d : A one-dimensional polynomial class. // -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. +// Notes +// ----- +// The algorithm relies on computing the eigenvalues of the +// companion matrix [1]_. // -// 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 array `a`. +// References +// ---------- +// .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*. Cambridge, UK: +// Cambridge University Press, 1999, pp. 146-7. // -// If this is anything but the default value it will be passed -// through (in the special case of an empty array) to the -// `mean` function of the underlying array. If the array is -// a sub-class and `mean` does not have the kwarg `keepdims` this -// will raise a RuntimeError. +// Examples +// -------- +// >>> coeff = [3.2, 2, 1] +// >>> np.roots(coeff) +// array([-0.3125+0.46351241j, -0.3125-0.46351241j]) // -// weights : array_like, optional -// An array of weights associated with the values in `a`. Each value in -// `a` contributes to the percentile according to its associated weight. -// The weights array can either be 1-D (in which case its length must be -// the size of `a` along the given axis) or of the same shape as `a`. -// If `weights=None`, then all data in `a` are assumed to have a -// weight equal to one. -// Only `method="inverted_cdf"` supports weights. // -// .. versionadded:: 2.0.0 // -// interpolation : str, optional -// Deprecated name for the method keyword argument. +//go:linkname Roots py.roots +func Roots(p *py.Object) *py.Object +// nested_iters(op, axes, flags=None, op_flags=None, op_dtypes=None, order="K", casting="safe", buffersize=0) // -// .. deprecated:: 1.22.0 +// Create nditers for use in nested loops +// +// Create a tuple of `nditer` objects which iterate in nested loops over +// different axes of the op argument. The first iterator is used in the +// outermost loop, the last in the innermost loop. Advancing one will change +// the subsequent iterators to point at its new element. +// +// Parameters +// ---------- +// op : ndarray or sequence of array_like +// The array(s) to iterate over. +// +// axes : list of list of int +// Each item is used as an "op_axes" argument to an nditer +// +// flags, op_flags, op_dtypes, order, casting, buffersize (optional) +// See `nditer` parameters of the same name // // Returns // ------- -// percentile : scalar or ndarray -// If `q` is a single percentile and `axis=None`, then the result -// is a scalar. If multiple percentiles are given, first axis of -// the result corresponds to the percentiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the -// same as that of the input. If `out` is specified, that array is -// returned instead. +// iters : tuple of nditer +// An nditer for each item in `axes`, outermost first // // See Also // -------- -// nanmean -// nanmedian : equivalent to ``nanpercentile(..., 50)`` -// percentile, median, mean -// nanquantile : equivalent to nanpercentile, except q in range [0, 1]. -// -// Notes -// ----- -// The behavior of `numpy.nanpercentile` with percentage `q` is that of -// `numpy.quantile` with argument ``q/100`` (ignoring nan values). -// For more information, please see `numpy.quantile`. +// nditer // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[10., 7., 4.], [3., 2., 1.]]) -// >>> a[0][1] = np.nan -// >>> a -// array([[10., nan, 4.], -// [ 3., 2., 1.]]) -// >>> np.percentile(a, 50) -// np.float64(nan) -// >>> np.nanpercentile(a, 50) -// 3.0 -// >>> np.nanpercentile(a, 50, axis=0) -// array([6.5, 2. , 2.5]) -// >>> np.nanpercentile(a, 50, axis=1, keepdims=True) -// array([[7.], -// [2.]]) -// >>> m = np.nanpercentile(a, 50, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.nanpercentile(a, 50, axis=0, out=out) -// array([6.5, 2. , 2.5]) -// >>> m -// array([6.5, 2. , 2.5]) -// -// >>> b = a.copy() -// >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a==b) -// -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 // +// Basic usage. Note how y is the "flattened" version of +// [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified +// the first iter's axes as [1] // +// >>> a = np.arange(12).reshape(2, 3, 2) +// >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=["multi_index"]) +// >>> for x in i: +// ... print(i.multi_index) +// ... for y in j: +// ... print('', j.multi_index, y) +// (0,) +// (0, 0) 0 +// (0, 1) 1 +// (1, 0) 6 +// (1, 1) 7 +// (1,) +// (0, 0) 2 +// (0, 1) 3 +// (1, 0) 8 +// (1, 1) 9 +// (2,) +// (0, 0) 4 +// (0, 1) 5 +// (1, 0) 10 +// (1, 1) 11 // -//go:linkname Nanpercentile py.nanpercentile -func Nanpercentile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object -// -// Compute the variance along the specified axis, while ignoring NaNs. -// -// Returns the variance of the array elements, a measure of the spread of -// a distribution. The variance is computed for the flattened array by -// default, otherwise over the specified axis. +//go:linkname NestedIters py.nested_iters +func NestedIters(op *py.Object, axes *py.Object, flags *py.Object, opFlags *py.Object, opDtypes *py.Object, order *py.Object, casting *py.Object, buffersize *py.Object) *py.Object +// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// For all-NaN slices or slices with zero degrees of freedom, NaN is -// returned and a `RuntimeWarning` is raised. +// Inverse hyperbolic tangent element-wise. // -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose variance is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the variance is computed. The default is to compute -// the variance of the flattened array. -// dtype : data-type, optional -// Type to use in computing the variance. For arrays of integer type -// the default is `float64`; for arrays of float types it is the same as -// the array type. -// out : ndarray, optional -// Alternate output array in which to place the result. It must have -// the same shape as the expected output, but the type is cast if -// necessary. -// ddof : {int, float}, optional -// "Delta Degrees of Freedom": the divisor used in the calculation is -// ``N - ddof``, where ``N`` represents the number of non-NaN -// elements. By default `ddof` is zero. -// 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`. -// where : array_like of bool, optional -// Elements to include in the variance. See `~numpy.ufunc.reduce` for -// details. +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// .. versionadded:: 1.22.0 +// Returns +// ------- +// out : ndarray or scalar +// Array of the same shape as `x`. +// This is a scalar if `x` is a scalar. // -// mean : array_like, optional -// Provide the mean to prevent its recalculation. The mean should have -// a shape as if it was calculated with ``keepdims=True``. -// The axis for the calculation of the mean should be the same as used in -// the call to this var function. +// See Also +// -------- +// emath.arctanh // -// .. versionadded:: 2.0.0 +// Notes +// ----- +// `arctanh` is a multivalued function: for each `x` there are infinitely +// many numbers `z` such that ``tanh(z) = x``. The convention is to return +// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. // -// correction : {int, float}, optional -// Array API compatible name for the ``ddof`` parameter. Only one of them -// can be provided at the same time. +// For real-valued input data types, `arctanh` always returns real output. +// For each value that cannot be expressed as a real number or infinity, +// it yields ``nan`` and sets the `invalid` floating point error flag. // -// .. versionadded:: 2.0.0 +// For complex-valued input, `arctanh` is a complex analytical function +// that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from +// above on the former and from below on the latter. // -// Returns -// ------- -// variance : ndarray, see dtype parameter above -// If `out` is None, return a new array containing the variance, -// otherwise return a reference to the output array. If ddof is >= the -// number of non-NaN elements in a slice or the slice contains only -// NaNs, then the result for that slice is NaN. +// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. // -// See Also -// -------- -// std : Standard deviation -// mean : Average -// var : Variance while not ignoring NaNs -// nanstd, nanmean -// :ref:`ufuncs-output-type` +// References +// ---------- +// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", +// 10th printing, 1964, pp. 86. +// https://personal.math.ubc.ca/~cbm/aands/page_86.htm +// .. [2] Wikipedia, "Inverse hyperbolic function", +// https://en.wikipedia.org/wiki/Arctanh // -// Notes -// ----- -// The variance is the average of the squared deviations from the mean, -// i.e., ``var = mean(abs(x - x.mean())**2)``. +// Examples +// -------- +// >>> np.arctanh([0, -0.5]) +// array([ 0. , -0.54930614]) // -// The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``. -// If, however, `ddof` is specified, the divisor ``N - ddof`` is used -// instead. In standard statistical practice, ``ddof=1`` provides an -// unbiased estimator of the variance of a hypothetical infinite -// population. ``ddof=0`` provides a maximum likelihood estimate of the -// variance for normally distributed variables. +//go:linkname Arctanh py.arctanh +func Arctanh(x *py.Object, out *py.Object) *py.Object +// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Note that for complex numbers, the absolute value is taken before -// squaring, so that the result is always real and nonnegative. +// Returns element-wise True where signbit is set (less than zero). // -// For floating-point input, the variance is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for `float32` (see example -// below). Specifying a higher-accuracy accumulator using the ``dtype`` -// keyword can alleviate this issue. +// Parameters +// ---------- +// x : array_like +// The input value(s). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// For this function to work on sub-classes of ndarray, they must define -// `sum` with the kwarg `keepdims` +// Returns +// ------- +// result : ndarray of bool +// Output array, or reference to `out` if that was supplied. +// This is a scalar if `x` is a scalar. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1, np.nan], [3, 4]]) -// >>> np.nanvar(a) -// 1.5555555555555554 -// >>> np.nanvar(a, axis=0) -// array([1., 0.]) -// >>> np.nanvar(a, axis=1) -// array([0., 0.25]) # may vary +// Examples +// -------- +// >>> np.signbit(-1.2) +// True +// >>> np.signbit(np.array([1, -2.3, 2.1])) +// array([False, True, False]) // +//go:linkname Signbit py.signbit +func Signbit(x *py.Object, out *py.Object) *py.Object // +// Change elements of an array based on conditional and input values. // -//go:linkname Nanvar py.nanvar -func Nanvar(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object +// Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that +// `place` uses the first N elements of `vals`, where N is the number of +// True values in `mask`, while `copyto` uses the elements where `mask` +// is True. // -// Split an array into multiple sub-arrays as views into `ary`. +// Note that `extract` does the exact opposite of `place`. // // Parameters // ---------- -// ary : ndarray -// Array to be divided into sub-arrays. -// indices_or_sections : int or 1-D array -// If `indices_or_sections` is an integer, N, the array will be divided -// into N equal arrays along `axis`. If such a split is not possible, -// an error is raised. -// -// If `indices_or_sections` is a 1-D array of sorted integers, the entries -// indicate where along `axis` the array is split. For example, -// ``[2, 3]`` would, for ``axis=0``, result in -// -// - ary[:2] -// - ary[2:3] -// - ary[3:] -// -// If an index exceeds the dimension of the array along `axis`, -// an empty sub-array is returned correspondingly. -// axis : int, optional -// The axis along which to split, default is 0. -// -// Returns -// ------- -// sub-arrays : list of ndarrays -// A list of sub-arrays as views into `ary`. -// -// Raises -// ------ -// ValueError -// If `indices_or_sections` is given as an integer, but -// a split does not result in equal division. +// arr : ndarray +// Array to put data into. +// mask : array_like +// Boolean mask array. Must have the same size as `a`. +// vals : 1-D sequence +// Values to put into `a`. Only the first N elements are used, where +// N is the number of True values in `mask`. If `vals` is smaller +// than N, it will be repeated, and if elements of `a` are to be masked, +// this sequence must be non-empty. // // See Also // -------- -// array_split : Split an array into multiple sub-arrays of equal or -// near-equal size. Does not raise an exception if -// an equal division cannot be made. -// hsplit : Split array into multiple sub-arrays horizontally (column-wise). -// vsplit : Split array into multiple sub-arrays vertically (row wise). -// dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// hstack : Stack arrays in sequence horizontally (column wise). -// vstack : Stack arrays in sequence vertically (row wise). -// dstack : Stack arrays in sequence depth wise (along third dimension). +// copyto, put, take, extract // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(9.0) -// >>> np.split(x, 3) -// [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])] -// -// >>> x = np.arange(8.0) -// >>> np.split(x, [3, 5, 6, 10]) -// [array([0., 1., 2.]), -// array([3., 4.]), -// array([5.]), -// array([6., 7.]), -// array([], dtype=float64)] -// -// +// >>> arr = np.arange(6).reshape(2, 3) +// >>> np.place(arr, arr>2, [44, 55]) +// >>> arr +// array([[ 0, 1, 2], +// [44, 55, 44]]) // -//go:linkname Split py.split -func Split(ary *py.Object, indicesOrSections *py.Object, axis *py.Object) *py.Object // -// Broadcast the input shapes into a single shape. // -// :ref:`Learn more about broadcasting here `. +//go:linkname Place py.place +func Place(arr *py.Object, mask *py.Object, vals *py.Object) *py.Object // -// .. versionadded:: 1.20.0 +// Returns True if the type of `element` is a scalar type. // // Parameters // ---------- -// *args : tuples of ints, or ints -// The shapes to be broadcast against each other. +// element : any +// Input argument, can be of any type and shape. // // Returns // ------- -// tuple -// Broadcasted shape. -// -// Raises -// ------ -// ValueError -// If the shapes are not compatible and cannot be broadcast according -// to NumPy's broadcasting rules. +// val : bool +// True if `element` is a scalar type, False if it is not. // // See Also // -------- -// broadcast -// broadcast_arrays -// broadcast_to +// ndim : Get the number of dimensions of an array +// +// Notes +// ----- +// If you need a stricter way to identify a *numerical* scalar, use +// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most +// non-numerical elements such as strings. +// +// In most cases ``np.ndim(x) == 0`` should be used instead of this function, +// as that will also return true for 0d arrays. This is how numpy overloads +// functions in the style of the ``dx`` arguments to `gradient` and the ``bins`` +// argument to `histogram`. Some key differences: +// +// +--------------------------------------+---------------+-------------------+ +// | x |``isscalar(x)``|``np.ndim(x) == 0``| +// +======================================+===============+===================+ +// | PEP 3141 numeric objects (including | ``True`` | ``True`` | +// | builtins) | | | +// +--------------------------------------+---------------+-------------------+ +// | builtin string and buffer objects | ``True`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other builtin objects, like | ``False`` | ``True`` | +// | `pathlib.Path`, `Exception`, | | | +// | the result of `re.compile` | | | +// +--------------------------------------+---------------+-------------------+ +// | third-party objects like | ``False`` | ``True`` | +// | `matplotlib.figure.Figure` | | | +// +--------------------------------------+---------------+-------------------+ +// | zero-dimensional numpy arrays | ``False`` | ``True`` | +// +--------------------------------------+---------------+-------------------+ +// | other numpy arrays | ``False`` | ``False`` | +// +--------------------------------------+---------------+-------------------+ +// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | +// | objects | | | +// +--------------------------------------+---------------+-------------------+ // // Examples // -------- -// >>> import numpy as np -// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) -// (3, 2) -// -// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) -// (5, 6, 7) +// >>> np.isscalar(3.1) +// True +// >>> np.isscalar(np.array(3.1)) +// False +// >>> np.isscalar([3.1]) +// False +// >>> np.isscalar(False) +// True +// >>> np.isscalar('numpy') +// True // +// NumPy supports PEP 3141 numbers: // -//go:linkname BroadcastShapes py.broadcast_shapes -func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object +// >>> from fractions import Fraction +// >>> np.isscalar(Fraction(5, 17)) +// True +// >>> from numbers import Number +// >>> np.isscalar(Number()) +// True // -// Return the minimum of an array or minimum along an axis. // -// `amin` is an alias of `~numpy.min`. // -// See Also -// -------- -// min : alias of this function -// ndarray.min : equivalent method +//go:linkname Isscalar py.isscalar +func Isscalar(element *py.Object) *py.Object +// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // +// Shift the bits of an integer to the left. // -//go:linkname Amin py.amin -func Amin(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. +// Since the internal representation of numbers is in binary format, this +// operation is equivalent to multiplying `x1` by ``2**x2``. // -// copyto(dst, src, casting='same_kind', where=True) +// Parameters +// ---------- +// x1 : array_like of integer type +// Input values. +// x2 : array_like of integer type +// Number of zeros to append to `x1`. Has to be non-negative. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// Copies values from one array to another, broadcasting as necessary. +// Returns +// ------- +// out : array of integer type +// Return `x1` with bits shifted `x2` times to the left. +// This is a scalar if both `x1` and `x2` are scalars. // -// Raises a TypeError if the `casting` rule is violated, and if -// `where` is provided, it selects which elements to copy. +// See Also +// -------- +// right_shift : Shift the bits of an integer to the right. +// binary_repr : Return the binary representation of the input number +// as a string. // -// Parameters -// ---------- -// dst : ndarray -// The array into which values are copied. -// src : array_like -// The array from which values are copied. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur when copying. +// Examples +// -------- +// >>> np.binary_repr(5) +// '101' +// >>> np.left_shift(5, 2) +// 20 +// >>> np.binary_repr(20) +// '10100' // -// * 'no' means the data types should not be cast at all. -// * 'equiv' means only byte-order changes are allowed. -// * 'safe' means only casts which can preserve values are allowed. -// * 'same_kind' means only safe casts or casts within a kind, -// like float64 to float32, are allowed. -// * 'unsafe' means any data conversions may be done. -// where : array_like of bool, optional -// 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. +// >>> np.left_shift(5, [1,2,3]) +// array([10, 20, 40]) // -// Examples -// -------- -// >>> import numpy as np -// >>> A = np.array([4, 5, 6]) -// >>> B = [1, 2, 3] -// >>> np.copyto(A, B) -// >>> A -// array([1, 2, 3]) +// Note that the dtype of the second argument may change the dtype of the +// result and can lead to unexpected results in some cases (see +// :ref:`Casting Rules `): // -// >>> 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]]) +// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 +// >>> print(a, type(a)) # Unexpected result due to upcasting +// 510 +// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) +// >>> print(b, type(b)) +// 254 // +// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on +// ndarrays. // +// >>> x1 = 5 +// >>> x2 = np.array([1, 2, 3]) +// >>> x1 << x2 +// array([10, 20, 40]) // -//go:linkname Copyto py.copyto -func Copyto(dst *py.Object, src *py.Object, casting *py.Object, where *py.Object) *py.Object -// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname LeftShift py.left_shift +func LeftShift(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Compute the truth value of x1 XOR x2, element-wise. +// Return (x1 != x2) element-wise. // // Parameters // ---------- // x1, x2 : array_like -// Logical XOR is applied to the elements of `x1` and `x2`. +// Input arrays. // If ``x1.shape != x2.shape``, they must be broadcastable to a common // shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional @@ -23455,654 +22759,680 @@ func Copyto(dst *py.Object, src *py.Object, casting *py.Object, where *py.Object // // Returns // ------- -// y : bool or ndarray of bool -// Boolean result of the logical XOR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. +// out : ndarray or scalar +// Output array, element-wise comparison of `x1` and `x2`. +// Typically of type bool, unless ``dtype=object`` is passed. // This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// logical_and, logical_or, logical_not, bitwise_xor +// equal, greater, greater_equal, less, less_equal // // Examples // -------- -// >>> import numpy as np -// >>> np.logical_xor(True, False) -// True -// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) -// array([False, True, True, False]) +// >>> np.not_equal([1.,2.], [1., 3.]) +// array([False, True]) +// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) +// array([[False, True], +// [False, True]]) // -// >>> x = np.arange(5) -// >>> np.logical_xor(x < 1, x > 3) -// array([ True, False, False, False, True]) +// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on +// ndarrays. // -// Simple example showing support of broadcasting +// >>> a = np.array([1., 2.]) +// >>> b = np.array([1., 3.]) +// >>> a != b +// array([False, True]) // -// >>> np.logical_xor(0, np.eye(2)) -// array([[ True, False], -// [False, True]]) +//go:linkname NotEqual py.not_equal +func NotEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// seterrobj(errobj, /) // -//go:linkname LogicalXor py.logical_xor -func LogicalXor(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -//go:linkname RightShift py.right_shift -func RightShift(__llgo_va_list ...interface{}) *py.Object +// Set the object that defines floating-point error handling. // -// Evenly round to the given number of decimals. +// The error object contains all information that defines the error handling +// behavior in NumPy. `seterrobj` is used internally by the other +// functions that set error handling behavior (`seterr`, `seterrcall`). // // Parameters // ---------- -// a : array_like -// Input data. -// decimals : int, optional -// Number of decimal places to round to (default: 0). If -// decimals is negative, it specifies the number of positions to -// the left of the decimal point. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output, but the type of the output -// values will be cast if necessary. See :ref:`ufuncs-output-type` -// for more details. +// errobj : list +// The error object, a list containing three elements: +// [internal numpy buffer size, error mask, error callback function]. // -// Returns -// ------- -// rounded_array : ndarray -// An array of the same type as `a`, containing the rounded values. -// Unless `out` was specified, a new array is created. A reference to -// the result is returned. +// The error mask is a single integer that holds the treatment information +// on all four floating point errors. The information for each error type +// is contained in three bits of the integer. If we print it in base 8, we +// can see what treatment is set for "invalid", "under", "over", and +// "divide" (in that order). The printed string can be interpreted with // -// The real and imaginary parts of complex numbers are rounded -// separately. The result of rounding a float is a float. +// * 0 : 'ignore' +// * 1 : 'warn' +// * 2 : 'raise' +// * 3 : 'call' +// * 4 : 'print' +// * 5 : 'log' // // See Also // -------- -// ndarray.round : equivalent method -// around : an alias for this function -// ceil, fix, floor, rint, trunc -// +// geterrobj, seterr, geterr, seterrcall, geterrcall +// getbufsize, setbufsize // // Notes // ----- -// 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. -// -// ``np.round`` uses a fast but sometimes inexact algorithm to round -// floating-point datatypes. For positive `decimals` it is equivalent to -// ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has -// error due to the inexact representation of decimal fractions in the IEEE -// floating point standard [1]_ and errors introduced when scaling by powers -// of ten. For instance, note the extra "1" in the following: -// -// >>> np.round(56294995342131.5, 3) -// 56294995342131.51 -// -// If your goal is to print such values with a fixed number of decimals, it is -// preferable to use numpy's float printing routines to limit the number of -// printed decimals: -// -// >>> np.format_float_positional(56294995342131.5, precision=3) -// '56294995342131.5' -// -// The float printing routines use an accurate but much more computationally -// demanding algorithm to compute the number of digits after the decimal -// point. -// -// Alternatively, Python's builtin `round` function uses a more accurate -// but slower algorithm for 64-bit floating point values: -// -// >>> round(56294995342131.5, 3) -// 56294995342131.5 -// >>> np.round(16.055, 2), round(16.055, 2) # equals 16.0549999999999997 -// (16.06, 16.05) -// -// -// References -// ---------- -// .. [1] "Lecture Notes on the Status of IEEE 754", William Kahan, -// https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF +// For complete documentation of the types of floating-point exceptions and +// treatment options, see `seterr`. // // Examples // -------- -// >>> import numpy as np -// >>> np.round([0.37, 1.64]) -// array([0., 2.]) -// >>> np.round([0.37, 1.64], decimals=1) -// array([0.4, 1.6]) -// >>> np.round([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value -// array([0., 2., 2., 4., 4.]) -// >>> np.round([1,2,3,11], decimals=1) # ndarray of ints is returned -// array([ 1, 2, 3, 11]) -// >>> np.round([1,2,3,11], decimals=-1) -// array([ 0, 0, 0, 10]) +// >>> old_errobj = np.geterrobj() # first get the defaults +// >>> old_errobj +// [8192, 521, None] // +// >>> def err_handler(type, flag): +// ... print("Floating point error (%s), with flag %s" % (type, flag)) +// ... +// >>> new_errobj = [20000, 12, err_handler] +// >>> np.seterrobj(new_errobj) +// >>> np.base_repr(12, 8) # int for divide=4 ('print') and over=1 ('warn') +// '14' +// >>> np.geterr() +// {'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'} +// >>> np.geterrcall() is err_handler +// True // +//go:linkname Seterrobj py.seterrobj +func Seterrobj(errobj *py.Object) *py.Object // -//go:linkname Round py.round -func Round(a *py.Object, decimals *py.Object, out *py.Object) *py.Object -// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Return the non-negative square-root of an array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// The values whose square-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Return the scalar dtype or NumPy equivalent of Python type of an object. // -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the positive -// square-root of each element in `x`. If any element in `x` is -// complex, a complex array is returned (and the square-roots of -// negative reals are calculated). If all of the elements in `x` -// are real, so is `y`, with negative elements returning ``nan``. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. +// Parameters +// ---------- +// rep : any +// The object of which the type is returned. +// default : any, optional +// If given, this is returned for objects whose types can not be +// determined. If not given, None is returned for those objects. // -// See Also -// -------- -// emath.sqrt -// A version which returns complex numbers when given negative reals. -// Note that 0.0 and -0.0 are handled differently for complex inputs. +// Returns +// ------- +// dtype : dtype or Python type +// The data type of `rep`. // -// Notes -// ----- -// *sqrt* has--consistent with common convention--as its branch cut the -// real "interval" [`-inf`, 0), and is continuous from above on it. -// A branch cut is a curve in the complex plane across which a given -// complex function fails to be continuous. +// See Also +// -------- +// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype // -// Examples -// -------- -// >>> import numpy as np -// >>> np.sqrt([1,4,9]) -// array([ 1., 2., 3.]) +// Examples +// -------- +// >>> np.obj2sctype(np.int32) +// +// >>> np.obj2sctype(np.array([1., 2.])) +// +// >>> np.obj2sctype(np.array([1.j])) +// // -// >>> np.sqrt([4, -1, -3+4J]) -// array([ 2.+0.j, 0.+1.j, 1.+2.j]) +// >>> np.obj2sctype(dict) +// +// >>> np.obj2sctype('string') // -// >>> np.sqrt([4, -1, np.inf]) -// array([ 2., nan, inf]) +// >>> np.obj2sctype(1, default=list) +// // -//go:linkname Sqrt py.sqrt -func Sqrt(x *py.Object, out *py.Object) *py.Object // -// where(condition, [x, y], /) // -// Return elements chosen from `x` or `y` depending on `condition`. +//go:linkname Obj2sctype py.obj2sctype +func Obj2sctype(rep *py.Object, Default *py.Object) *py.Object // -// .. note:: -// When only `condition` is provided, this function is a shorthand for -// ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be -// preferred, as it behaves correctly for subclasses. The rest of this -// documentation covers only the case where all three arguments are -// provided. +// einsum_path(subscripts, *operands, optimize='greedy') +// +// Evaluates the lowest cost contraction order for an einsum expression by +// considering the creation of intermediate arrays. // // Parameters // ---------- -// condition : array_like, bool -// Where True, yield `x`, otherwise yield `y`. -// x, y : array_like -// Values from which to choose. `x`, `y` and `condition` need to be -// broadcastable to some shape. +// subscripts : str +// Specifies the subscripts for summation. +// *operands : list of array_like +// These are the arrays for the operation. +// optimize : {bool, list, tuple, 'greedy', 'optimal'} +// Choose the type of path. If a tuple is provided, the second argument is +// assumed to be the maximum intermediate size created. If only a single +// argument is provided the largest input or output array size is used +// as a maximum intermediate size. +// +// * if a list is given that starts with ``einsum_path``, uses this as the +// contraction path +// * if False no optimization is taken +// * if True defaults to the 'greedy' algorithm +// * 'optimal' An algorithm that combinatorially explores all possible +// ways of contracting the listed tensors and chooses the least costly +// path. Scales exponentially with the number of terms in the +// contraction. +// * 'greedy' An algorithm that chooses the best pair contraction +// at each step. Effectively, this algorithm searches the largest inner, +// Hadamard, and then outer products at each step. Scales cubically with +// the number of terms in the contraction. Equivalent to the 'optimal' +// path for most contractions. +// +// Default is 'greedy'. // // Returns // ------- -// out : ndarray -// An array with elements from `x` where `condition` is True, and elements -// from `y` elsewhere. -// -// See Also -// -------- -// choose -// nonzero : The function that is called when x and y are omitted +// path : list of tuples +// A list representation of the einsum path. +// string_repr : str +// A printable representation of the einsum path. // // Notes // ----- -// If all the arrays are 1-D, `where` is equivalent to:: +// The resulting path indicates which terms of the input contraction should be +// contracted first, the result of this contraction is then appended to the +// end of the contraction list. This list can then be iterated over until all +// intermediate contractions are complete. // -// [xv if c else yv -// for c, xv, yv in zip(condition, x, y)] +// See Also +// -------- +// einsum, linalg.multi_dot // // Examples // -------- -// >>> import numpy as np -// >>> a = np.arange(10) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.where(a < 5, a, 10*a) -// array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90]) // -// This can be used on multidimensional arrays too: +// We can begin with a chain dot example. In this case, it is optimal to +// contract the ``b`` and ``c`` tensors first as represented by the first +// element of the path ``(1, 2)``. The resulting tensor is added to the end +// of the contraction and the remaining contraction ``(0, 1)`` is then +// completed. // -// >>> np.where([[True, False], [True, True]], -// ... [[1, 2], [3, 4]], -// ... [[9, 8], [7, 6]]) -// array([[1, 8], -// [3, 4]]) +// >>> np.random.seed(123) +// >>> a = np.random.rand(2, 2) +// >>> b = np.random.rand(2, 5) +// >>> c = np.random.rand(5, 2) +// >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy') +// >>> print(path_info[0]) +// ['einsum_path', (1, 2), (0, 1)] +// >>> print(path_info[1]) +// Complete contraction: ij,jk,kl->il # may vary +// Naive scaling: 4 +// Optimized scaling: 3 +// Naive FLOP count: 1.600e+02 +// Optimized FLOP count: 5.600e+01 +// Theoretical speedup: 2.857 +// Largest intermediate: 4.000e+00 elements +// ------------------------------------------------------------------------- +// scaling current remaining +// ------------------------------------------------------------------------- +// 3 kl,jk->jl ij,jl->il +// 3 jl,ij->il il->il // -// The shapes of x, y, and the condition are broadcast together: // -// >>> x, y = np.ogrid[:3, :4] -// >>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast -// array([[10, 0, 0, 0], -// [10, 11, 1, 1], -// [10, 11, 12, 2]]) +// A more complex index transformation example. // -// >>> a = np.array([[0, 1, 2], -// ... [0, 2, 4], -// ... [0, 3, 6]]) -// >>> np.where(a < 4, a, -1) # -1 is broadcast -// array([[ 0, 1, 2], -// [ 0, 2, -1], -// [ 0, 3, -1]]) +// >>> I = np.random.rand(10, 10, 10, 10) +// >>> C = np.random.rand(10, 10) +// >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C, +// ... optimize='greedy') +// +// >>> print(path_info[0]) +// ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)] +// >>> print(path_info[1]) +// Complete contraction: ea,fb,abcd,gc,hd->efgh # may vary +// Naive scaling: 8 +// Optimized scaling: 5 +// Naive FLOP count: 8.000e+08 +// Optimized FLOP count: 8.000e+05 +// Theoretical speedup: 1000.000 +// Largest intermediate: 1.000e+04 elements +// -------------------------------------------------------------------------- +// scaling current remaining +// -------------------------------------------------------------------------- +// 5 abcd,ea->bcde fb,gc,hd,bcde->efgh +// 5 bcde,fb->cdef gc,hd,cdef->efgh +// 5 cdef,gc->defg hd,defg->efgh +// 5 defg,hd->efgh efgh->efgh // // -//go:linkname Where py.where -func Where(condition *py.Object, x *py.Object, y *py.Object) *py.Object +//go:linkname EinsumPath py.einsum_path +func EinsumPath(__llgo_va_list ...interface{}) *py.Object // -// Evaluate a piecewise-defined function. +// Unwrap by taking the complement of large deltas with respect to the period. // -// Given a set of conditions and corresponding functions, evaluate each -// function on the input data wherever its condition is true. +// This unwraps a signal `p` by changing elements which have an absolute +// difference from their predecessor of more than ``max(discont, period/2)`` +// to their `period`-complementary values. +// +// For the default case where `period` is :math:`2\pi` and `discont` is +// :math:`\pi`, this unwraps a radian phase `p` such that adjacent differences +// are never greater than :math:`\pi` by adding :math:`2k\pi` for some +// integer :math:`k`. // // Parameters // ---------- -// x : ndarray or scalar -// The input domain. -// condlist : list of bool arrays or bool scalars -// Each boolean array corresponds to a function in `funclist`. Wherever -// `condlist[i]` is True, `funclist[i](x)` is used as the output value. -// -// Each boolean array in `condlist` selects a piece of `x`, -// and should therefore be of the same shape as `x`. +// p : array_like +// Input array. +// discont : float, optional +// Maximum discontinuity between values, default is ``period/2``. +// Values below ``period/2`` are treated as if they were ``period/2``. +// To have an effect different from the default, `discont` should be +// larger than ``period/2``. +// axis : int, optional +// Axis along which unwrap will operate, default is the last axis. +// period : float, optional +// Size of the range over which the input wraps. By default, it is +// ``2 pi``. // -// The length of `condlist` must correspond to that of `funclist`. -// If one extra function is given, i.e. if -// ``len(funclist) == len(condlist) + 1``, then that extra function -// is the default value, used wherever all conditions are false. -// funclist : list of callables, f(x,*args,**kw), or scalars -// Each function is evaluated over `x` wherever its corresponding -// condition is True. It should take a 1d array as input and give an 1d -// array or a scalar value as output. If, instead of a callable, -// a scalar is provided then a constant function (``lambda x: scalar``) is -// assumed. -// args : tuple, optional -// Any further arguments given to `piecewise` are passed to the functions -// upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then -// each function is called as ``f(x, 1, 'a')``. -// kw : dict, optional -// Keyword arguments used in calling `piecewise` are passed to the -// functions upon execution, i.e., if called -// ``piecewise(..., ..., alpha=1)``, then each function is called as -// ``f(x, alpha=1)``. +// .. versionadded:: 1.21.0 // // Returns // ------- // out : ndarray -// The output is the same shape and type as x and is found by -// calling the functions in `funclist` on the appropriate portions of `x`, -// as defined by the boolean arrays in `condlist`. Portions not covered -// by any condition have a default value of 0. +// Output array. +// +// See Also +// -------- +// rad2deg, deg2rad +// +// Notes +// ----- +// If the discontinuity in `p` is smaller than ``period/2``, +// but larger than `discont`, no unwrapping is done because taking +// the complement would only make the discontinuity larger. +// +// Examples +// -------- +// >>> phase = np.linspace(0, np.pi, num=5) +// >>> phase[3:] += np.pi +// >>> phase +// array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) # may vary +// >>> np.unwrap(phase) +// array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) # may vary +// >>> np.unwrap([0, 1, 2, -1, 0], period=4) +// array([0, 1, 2, 3, 4]) +// >>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6) +// array([1, 2, 3, 4, 5, 6, 7, 8, 9]) +// >>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4) +// array([2, 3, 4, 5, 6, 7, 8, 9]) +// >>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180 +// >>> np.unwrap(phase_deg, period=360) +// array([-180., -140., -100., -60., -20., 20., 60., 100., 140., +// 180., 220., 260., 300., 340., 380., 420., 460., 500., +// 540.]) // // -// See Also -// -------- -// choose, select, where +//go:linkname Unwrap py.unwrap +func Unwrap(p *py.Object, discont *py.Object, axis *py.Object) *py.Object // -// Notes -// ----- -// This is similar to choose or select, except that functions are -// evaluated on elements of `x` that satisfy the corresponding condition from -// `condlist`. +// Function to calculate only the edges of the bins used by the `histogram` +// function. // -// The result is:: +// Parameters +// ---------- +// a : array_like +// Input data. The histogram is computed over the flattened array. +// bins : int or sequence of scalars or str, optional +// If `bins` is an int, it defines the number of equal-width +// bins in the given range (10, by default). If `bins` is a +// sequence, it defines the bin edges, including the rightmost +// edge, allowing for non-uniform bin widths. // -// |-- -// |funclist[0](x[condlist[0]]) -// out = |funclist[1](x[condlist[1]]) -// |... -// |funclist[n2](x[condlist[n2]]) -// |-- +// If `bins` is a string from the list below, `histogram_bin_edges` will use +// the method chosen to calculate the optimal bin width and +// consequently the number of bins (see `Notes` for more detail on +// the estimators) from the data that falls within the requested +// range. While the bin width will be optimal for the actual data +// in the range, the number of bins will be computed to fill the +// entire range, including the empty portions. For visualisation, +// using the 'auto' option is suggested. Weighted data is not +// supported for automated bin size selection. // -// Examples -// -------- -// >>> import numpy as np +// 'auto' +// Maximum of the 'sturges' and 'fd' estimators. Provides good +// all around performance. // -// Define the signum function, which is -1 for ``x < 0`` and +1 for ``x >= 0``. +// 'fd' (Freedman Diaconis Estimator) +// Robust (resilient to outliers) estimator that takes into +// account data variability and data size. // -// >>> x = np.linspace(-2.5, 2.5, 6) -// >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1]) -// array([-1., -1., -1., 1., 1., 1.]) +// 'doane' +// An improved version of Sturges' estimator that works better +// with non-normal datasets. // -// Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for -// ``x >= 0``. +// 'scott' +// Less robust estimator that takes into account data variability +// and data size. // -// >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x]) -// array([2.5, 1.5, 0.5, 0.5, 1.5, 2.5]) +// 'stone' +// Estimator based on leave-one-out cross-validation estimate of +// the integrated squared error. Can be regarded as a generalization +// of Scott's rule. // -// Apply the same function to a scalar value. +// 'rice' +// Estimator does not take variability into account, only data +// size. Commonly overestimates number of bins required. // -// >>> y = -2 -// >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x]) -// array(2) +// 'sturges' +// R's default method, only accounts for data size. Only +// optimal for gaussian data and underestimates number of bins +// for large non-gaussian datasets. // +// 'sqrt' +// Square root (of data size) estimator, used by Excel and +// other programs for its speed and simplicity. // +// range : (float, float), optional +// The lower and upper range of the bins. If not provided, range +// is simply ``(a.min(), a.max())``. Values outside the range are +// ignored. The first element of the range must be less than or +// equal to the second. `range` affects the automatic bin +// 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. // -//go:linkname Piecewise py.piecewise -func Piecewise(x *py.Object, condlist *py.Object, funclist *py.Object, __llgo_va_list ...interface{}) *py.Object -//go:linkname Arccos py.arccos -func Arccos(__llgo_va_list ...interface{}) *py.Object -// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// 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 +// (instead of 1). This is currently not used by any of the bin estimators, +// but may be in the future. // -// Change the sign of x1 to that of x2, element-wise. +// Returns +// ------- +// bin_edges : array of dtype float +// The edges to pass into `histogram` // -// If `x2` is a scalar, its sign will be copied to all elements of `x1`. +// See Also +// -------- +// histogram // -// Parameters -// ---------- -// x1 : array_like -// Values to change the sign of. -// x2 : array_like -// The sign of `x2` is copied to `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// Notes +// ----- +// The methods to estimate the optimal number of bins are well founded +// in literature, and are inspired by the choices R provides for +// histogram visualisation. Note that having the number of bins +// proportional to :math:`n^{1/3}` is asymptotically optimal, which is +// why it appears in most estimators. These are simply plug-in methods +// that give good starting points for number of bins. In the equations +// 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 +// than what is returned by the estimators below. // -// Returns -// ------- -// out : ndarray or scalar -// The values of `x1` with the sign of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. +// 'auto' (maximum of the 'sturges' and 'fd' estimators) +// A compromise to get a good value. For small datasets the Sturges +// value will usually be chosen, while larger datasets will usually +// default to FD. Avoids the overly conservative behaviour of FD +// and Sturges for small and large datasets respectively. +// Switchover point is usually :math:`a.size \approx 1000`. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.copysign(1.3, -1) -// -1.3 -// >>> 1/np.copysign(0, 1) -// inf -// >>> 1/np.copysign(0, -1) -// -inf +// 'fd' (Freedman Diaconis Estimator) +// .. math:: h = 2 \frac{IQR}{n^{1/3}} // -// >>> np.copysign([-1, 0, 1], -1.1) -// array([-1., -0., -1.]) -// >>> np.copysign([-1, 0, 1], np.arange(3)-1) -// array([-1., 0., 1.]) +// The binwidth is proportional to the interquartile range (IQR) +// and inversely proportional to cube root of a.size. Can be too +// conservative for small datasets, but is quite good for large +// datasets. The IQR is very robust to outliers. // -//go:linkname Copysign py.copysign -func Copysign(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// datetime_data(dtype, /) +// 'scott' +// .. math:: h = \sigma \sqrt[3]{\frac{24 \sqrt{\pi}}{n}} // -// Get information about the step size of a date or time type. +// The binwidth is proportional to the standard deviation of the +// data and inversely proportional to cube root of ``x.size``. Can +// be too conservative for small datasets, but is quite good for +// large datasets. The standard deviation is not very robust to +// outliers. Values are very similar to the Freedman-Diaconis +// estimator in the absence of outliers. // -// The returned tuple can be passed as the second argument of `numpy.datetime64` and -// `numpy.timedelta64`. +// 'rice' +// .. math:: n_h = 2n^{1/3} // -// Parameters -// ---------- -// dtype : dtype -// The dtype object, which must be a `datetime64` or `timedelta64` type. +// The number of bins is only proportional to cube root of +// ``a.size``. It tends to overestimate the number of bins and it +// does not take into account data variability. // -// Returns -// ------- -// unit : str -// The :ref:`datetime unit ` on which this dtype -// is based. -// count : int -// The number of base units in a step. +// 'sturges' +// .. math:: n_h = \log _{2}(n) + 1 // -// Examples -// -------- -// >>> import numpy as np -// >>> dt_25s = np.dtype('timedelta64[25s]') -// >>> np.datetime_data(dt_25s) -// ('s', 25) -// >>> np.array(10, dt_25s).astype('timedelta64[s]') -// array(250, dtype='timedelta64[s]') +// The number of bins is the base 2 log of ``a.size``. This +// estimator assumes normality of data and is too conservative for +// larger, non-normal datasets. This is the default method in R's +// ``hist`` method. // -// The result can be used to construct a datetime that uses the same units -// as a timedelta +// 'doane' +// .. math:: n_h = 1 + \log_{2}(n) + +// \log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right) // -// >>> np.datetime64('2010', np.datetime_data(dt_25s)) -// np.datetime64('2010-01-01T00:00:00','25s') +// g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right] // -//go:linkname DatetimeData py.datetime_data -func DatetimeData(dtype *py.Object) *py.Object +// \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}} // -// Return the indices of the bins to which each value in input array belongs. +// An improved version of Sturges' formula that produces better +// estimates for non-normal datasets. This estimator attempts to +// account for the skew of the data. // -// ========= ============= ============================ -// `right` order of bins returned index `i` satisfies -// ========= ============= ============================ -// ``False`` increasing ``bins[i-1] <= x < bins[i]`` -// ``True`` increasing ``bins[i-1] < x <= bins[i]`` -// ``False`` decreasing ``bins[i-1] > x >= bins[i]`` -// ``True`` decreasing ``bins[i-1] >= x > bins[i]`` -// ========= ============= ============================ +// 'sqrt' +// .. math:: n_h = \sqrt n // -// If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is -// returned as appropriate. +// The simplest and fastest estimator. Only takes into account the +// data size. // -// Parameters -// ---------- -// x : array_like -// Input array to be binned. Prior to NumPy 1.10.0, this array had to -// be 1-dimensional, but can now have any shape. -// bins : array_like -// Array of bins. It has to be 1-dimensional and monotonic. -// right : bool, optional -// Indicating whether the intervals include the right or the left bin -// edge. Default behavior is (right==False) indicating that the interval -// does not include the right edge. The left bin end is open in this -// case, i.e., bins[i-1] <= x < bins[i] is the default behavior for -// monotonically increasing bins. +// Examples +// -------- +// >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]) +// >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1)) +// array([0. , 0.25, 0.5 , 0.75, 1. ]) +// >>> np.histogram_bin_edges(arr, bins=2) +// array([0. , 2.5, 5. ]) +// +// For consistency with histogram, an array of pre-computed bins is +// passed through unmodified: // -// Returns -// ------- -// indices : ndarray of ints -// Output array of indices, of same shape as `x`. +// >>> np.histogram_bin_edges(arr, [1, 2]) +// array([1, 2]) // -// Raises -// ------ -// ValueError -// If `bins` is not monotonic. -// TypeError -// If the type of the input is complex. +// This function allows one set of bins to be computed, and reused across +// multiple histograms: // -// See Also -// -------- -// bincount, histogram, unique, searchsorted +// >>> shared_bins = np.histogram_bin_edges(arr, bins='auto') +// >>> shared_bins +// array([0., 1., 2., 3., 4., 5.]) // -// Notes -// ----- -// If values in `x` are such that they fall outside the bin range, -// attempting to index `bins` with the indices that `digitize` returns -// will result in an IndexError. +// >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1]) +// >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins) +// >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins) // -// .. versionadded:: 1.10.0 +// >>> hist_0; hist_1 +// array([1, 1, 0, 1, 0]) +// array([2, 0, 1, 1, 2]) // -// `numpy.digitize` is implemented in terms of `numpy.searchsorted`. -// This means that a binary search is used to bin the values, which scales -// much better for larger number of bins than the previous linear search. -// It also removes the requirement for the input array to be 1-dimensional. +// Which gives more easily comparable results than using separate bins for +// each histogram: // -// For monotonically *increasing* `bins`, the following are equivalent:: +// >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto') +// >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto') +// >>> hist_0; hist_1 +// array([1, 1, 1]) +// array([2, 1, 1, 2]) +// >>> bins_0; bins_1 +// array([0., 1., 2., 3.]) +// array([0. , 1.25, 2.5 , 3.75, 5. ]) // -// np.digitize(x, bins, right=True) -// np.searchsorted(bins, x, side='left') // -// Note that as the order of the arguments are reversed, the side must be too. -// The `searchsorted` call is marginally faster, as it does not do any -// monotonicity checks. Perhaps more importantly, it supports all dtypes. // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([0.2, 6.4, 3.0, 1.6]) -// >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0]) -// >>> inds = np.digitize(x, bins) -// >>> inds -// array([1, 4, 3, 2]) -// >>> for n in range(x.size): -// ... print(bins[inds[n]-1], "<=", x[n], "<", bins[inds[n]]) -// ... -// 0.0 <= 0.2 < 1.0 -// 4.0 <= 6.4 < 10.0 -// 2.5 <= 3.0 < 4.0 -// 1.0 <= 1.6 < 2.5 +//go:linkname HistogramBinEdges py.histogram_bin_edges +func HistogramBinEdges(a *py.Object, bins *py.Object, Range *py.Object, weights *py.Object) *py.Object // -// >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.]) -// >>> bins = np.array([0, 5, 10, 15, 20]) -// >>> np.digitize(x,bins,right=True) -// array([1, 2, 3, 4, 4]) -// >>> np.digitize(x,bins,right=False) -// array([1, 3, 3, 4, 5]) +// shares_memory(a, b, /, max_work=None) // +// Determine if two arrays share memory. // -//go:linkname Digitize py.digitize -func Digitize(x *py.Object, bins *py.Object, right *py.Object) *py.Object +// .. warning:: // -// Return an array drawn from elements in choicelist, depending on conditions. +// This function can be exponentially slow for some inputs, unless +// `max_work` is set to a finite number or ``MAY_SHARE_BOUNDS``. +// If in doubt, use `numpy.may_share_memory` instead. // // Parameters // ---------- -// condlist : list of bool ndarrays -// The list of conditions which determine from which array in `choicelist` -// the output elements are taken. When multiple conditions are satisfied, -// the first one encountered in `condlist` is used. -// choicelist : list of ndarrays -// The list of arrays from which the output elements are taken. It has -// to be of the same length as `condlist`. -// default : scalar, optional -// The element inserted in `output` when all conditions evaluate to False. +// a, b : ndarray +// Input arrays +// max_work : int, optional +// Effort to spend on solving the overlap problem (maximum number +// of candidate solutions to consider). The following special +// values are recognized: +// +// max_work=MAY_SHARE_EXACT (default) +// The problem is solved exactly. In this case, the function returns +// True only if there is an element shared between the arrays. Finding +// the exact solution may take extremely long in some cases. +// max_work=MAY_SHARE_BOUNDS +// Only the memory bounds of a and b are checked. +// +// Raises +// ------ +// numpy.exceptions.TooHardError +// Exceeded max_work. // // Returns // ------- -// output : ndarray -// The output at position m is the m-th element of the array in -// `choicelist` where the m-th element of the corresponding array in -// `condlist` is True. +// out : bool // // See Also // -------- -// where : Return elements from one of two arrays depending on condition. -// take, choose, compress, diag, diagonal +// may_share_memory // // Examples // -------- -// >>> import numpy as np +// >>> x = np.array([1, 2, 3, 4]) +// >>> np.shares_memory(x, np.array([5, 6, 7])) +// False +// >>> np.shares_memory(x[::2], x) +// True +// >>> np.shares_memory(x[::2], x[1::2]) +// False // -// Beginning with an array of integers from 0 to 5 (inclusive), -// elements less than ``3`` are negated, elements greater than ``3`` -// are squared, and elements not meeting either of these conditions -// (exactly ``3``) are replaced with a `default` value of ``42``. +// Checking whether two arrays share memory is NP-complete, and +// runtime may increase exponentially in the number of +// dimensions. Hence, `max_work` should generally be set to a finite +// number, as it is possible to construct examples that take +// extremely long to run: // -// >>> x = np.arange(6) -// >>> condlist = [x<3, x>3] -// >>> choicelist = [-x, x**2] -// >>> np.select(condlist, choicelist, 42) -// array([ 0, -1, -2, 42, 16, 25]) +// >>> from numpy.lib.stride_tricks import as_strided +// >>> x = np.zeros([192163377], dtype=np.int8) +// >>> x1 = as_strided(x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049)) +// >>> x2 = as_strided(x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1)) +// >>> np.shares_memory(x1, x2, max_work=1000) +// Traceback (most recent call last): +// ... +// numpy.exceptions.TooHardError: Exceeded max_work // -// When multiple conditions are satisfied, the first one encountered in -// `condlist` is used. +// Running ``np.shares_memory(x1, x2)`` without `max_work` set takes +// around 1 minute for this case. It is possible to find problems +// that take still significantly longer. // -// >>> condlist = [x<=4, x>3] -// >>> choicelist = [x, x**2] -// >>> np.select(condlist, choicelist, 55) -// array([ 0, 1, 2, 3, 4, 25]) // // +//go:linkname SharesMemory py.shares_memory +func SharesMemory(a *py.Object, b *py.Object, maxWork *py.Object) *py.Object // -//go:linkname Select py.select -func Select(condlist *py.Object, choicelist *py.Object, default_ *py.Object) *py.Object +// Return evenly spaced numbers over a specified interval. // -// Returns the quotient and remainder of polynomial division. +// Returns `num` evenly spaced samples, calculated over the +// interval [`start`, `stop`]. // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. +// The endpoint of the interval can optionally be excluded. // -// The input arrays are the coefficients (including any coefficients -// equal to zero) of the "numerator" (dividend) and "denominator" -// (divisor) polynomials, respectively. +// .. versionchanged:: 1.16.0 +// Non-scalar `start` and `stop` are now supported. +// +// .. versionchanged:: 1.20.0 +// Values are rounded towards ``-inf`` instead of ``0`` when an +// integer ``dtype`` is specified. The old behavior can +// still be obtained with ``np.linspace(start, stop, num).astype(int)`` // // Parameters // ---------- -// u : array_like or poly1d -// Dividend polynomial's coefficients. +// start : array_like +// The starting value of the sequence. +// stop : array_like +// The end value of the sequence, unless `endpoint` is set to False. +// In that case, the sequence consists of all but the last of ``num + 1`` +// evenly spaced samples, so that `stop` is excluded. Note that the step +// size changes when `endpoint` is False. +// num : int, optional +// Number of samples to generate. Default is 50. Must be non-negative. +// endpoint : bool, optional +// If True, `stop` is the last sample. Otherwise, it is not included. +// Default is True. +// retstep : bool, optional +// If True, return (`samples`, `step`), where `step` is the spacing +// between samples. +// dtype : dtype, optional +// The type of the output array. If `dtype` is not given, the data type +// is inferred from `start` and `stop`. The inferred dtype will never be +// an integer; `float` is chosen even if the arguments would produce an +// array of integers. // -// v : array_like or poly1d -// Divisor polynomial's coefficients. +// .. versionadded:: 1.9.0 +// +// axis : int, optional +// The axis in the result to store the samples. Relevant only if start +// or stop are array-like. By default (0), the samples will be along a +// new axis inserted at the beginning. Use -1 to get an axis at the end. +// +// .. versionadded:: 1.16.0 // // Returns // ------- -// q : ndarray -// Coefficients, including those equal to zero, of the quotient. -// r : ndarray -// Coefficients, including those equal to zero, of the remainder. +// samples : ndarray +// There are `num` equally spaced samples in the closed interval +// ``[start, stop]`` or the half-open interval ``[start, stop)`` +// (depending on whether `endpoint` is True or False). +// step : float, optional +// Only returned if `retstep` is True +// +// Size of spacing between samples. +// // // See Also // -------- -// poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub -// polyval -// -// Notes -// ----- -// Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need -// not equal `v.ndim`. In other words, all four possible combinations - -// ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``, -// ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work. +// arange : Similar to `linspace`, but uses a step size (instead of the +// number of samples). +// geomspace : Similar to `linspace`, but with numbers spaced evenly on a log +// scale (a geometric progression). +// logspace : Similar to `geomspace`, but with the end points specified as +// logarithms. +// :ref:`how-to-partition` // // Examples // -------- +// >>> np.linspace(2.0, 3.0, num=5) +// array([2. , 2.25, 2.5 , 2.75, 3. ]) +// >>> np.linspace(2.0, 3.0, num=5, endpoint=False) +// array([2. , 2.2, 2.4, 2.6, 2.8]) +// >>> np.linspace(2.0, 3.0, num=5, retstep=True) +// (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) // -// .. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25 -// -// >>> import numpy as np +// Graphical illustration: // -// >>> x = np.array([3.0, 5.0, 2.0]) -// >>> y = np.array([2.0, 1.0]) -// >>> np.polydiv(x, y) -// (array([1.5 , 1.75]), array([0.25])) +// >>> import matplotlib.pyplot as plt +// >>> N = 8 +// >>> y = np.zeros(N) +// >>> x1 = np.linspace(0, 10, N, endpoint=True) +// >>> x2 = np.linspace(0, 10, N, endpoint=False) +// >>> plt.plot(x1, y, 'o') +// [] +// >>> plt.plot(x2, y + 0.5, 'o') +// [] +// >>> plt.ylim([-0.5, 1]) +// (-0.5, 1) +// >>> plt.show() // // // -//go:linkname Polydiv py.polydiv -func Polydiv(__llgo_va_list ...interface{}) *py.Object +//go:linkname Linspace py.linspace +func Linspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, retstep *py.Object, dtype *py.Object, axis *py.Object) *py.Object // -// Evaluate a polynomial at specific values. +// Find the product of two polynomials. // // .. note:: // This forms part of the old polynomial API. Since version 1.4, the @@ -24110,211 +23440,206 @@ func Polydiv(__llgo_va_list ...interface{}) *py.Object // A summary of the differences can be found in the // :doc:`transition guide `. // -// If `p` is of length N, this function returns the value:: -// -// p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1] -// -// If `x` is a sequence, then ``p(x)`` is returned for each element of ``x``. -// If `x` is another polynomial then the composite polynomial ``p(x(t))`` -// is returned. +// Finds the polynomial resulting from the multiplication of the two input +// polynomials. Each input must be either a poly1d object or a 1D sequence +// of polynomial coefficients, from highest to lowest degree. // // Parameters // ---------- -// p : array_like or poly1d object -// 1D array of polynomial coefficients (including coefficients equal -// to zero) from highest degree to the constant term, or an -// instance of poly1d. -// x : array_like or poly1d object -// A number, an array of numbers, or an instance of poly1d, at -// which to evaluate `p`. +// a1, a2 : array_like or poly1d object +// Input polynomials. // // Returns // ------- -// values : ndarray or poly1d -// If `x` is a poly1d instance, the result is the composition of the two -// polynomials, i.e., `x` is "substituted" in `p` and the simplified -// result is returned. In addition, the type of `x` - array_like or -// poly1d - governs the type of the output: `x` array_like => `values` -// array_like, `x` a poly1d object => `values` is also. +// out : ndarray or poly1d object +// The polynomial resulting from the multiplication of the inputs. If +// either inputs is a poly1d object, then the output is also a poly1d +// object. Otherwise, it is a 1D array of polynomial coefficients from +// highest to lowest degree. // // See Also // -------- -// poly1d: A polynomial class. -// -// Notes -// ----- -// Horner's scheme [1]_ is used to evaluate the polynomial. Even so, -// for polynomials of high degree the values may be inaccurate due to -// rounding errors. Use carefully. -// -// If `x` is a subtype of `ndarray` the return value will be of the same type. -// -// References -// ---------- -// .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng. -// trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand -// Reinhold Co., 1985, pg. 720. +// poly1d : A one-dimensional polynomial class. +// poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval +// convolve : Array convolution. Same output as polymul, but has parameter +// for overlap mode. // // Examples // -------- -// >>> import numpy as np -// >>> np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1 -// 76 -// >>> np.polyval([3,0,1], np.poly1d(5)) -// poly1d([76]) -// >>> np.polyval(np.poly1d([3,0,1]), 5) -// 76 -// >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5)) -// poly1d([76]) +// >>> np.polymul([1, 2, 3], [9, 5, 1]) +// array([ 9, 23, 38, 17, 3]) +// +// Using poly1d objects: +// +// >>> p1 = np.poly1d([1, 2, 3]) +// >>> p2 = np.poly1d([9, 5, 1]) +// >>> print(p1) +// 2 +// 1 x + 2 x + 3 +// >>> print(p2) +// 2 +// 9 x + 5 x + 1 +// >>> print(np.polymul(p1, p2)) +// 4 3 2 +// 9 x + 23 x + 38 x + 17 x + 3 // // // -//go:linkname Polyval py.polyval -func Polyval(p *py.Object, x *py.Object) *py.Object +//go:linkname Polymul py.polymul +func Polymul(a1 *py.Object, a2 *py.Object) *py.Object // -// Split an array into multiple sub-arrays. +// Print information about various resources in the system +// including available intrinsic support and BLAS/LAPACK library +// in use // -// Please refer to the ``split`` documentation. The only difference -// between these functions is that ``array_split`` allows -// `indices_or_sections` to be an integer that does *not* equally -// divide the axis. For an array of length l that should be split -// into n sections, it returns l % n sub-arrays of size l//n + 1 -// and the rest of size l//n. +// .. versionadded:: 1.24.0 // // See Also // -------- -// split : Split array into multiple sub-arrays of equal size. -// -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.arange(8.0) -// >>> np.array_split(x, 3) -// [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])] +// show_config : Show libraries in the system on which NumPy was built. // -// >>> x = np.arange(9) -// >>> np.array_split(x, 4) -// [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])] +// Notes +// ----- +// 1. Information is derived with the help of `threadpoolctl `_ +// library if available. +// 2. SIMD related information is derived from ``__cpu_features__``, +// ``__cpu_baseline__`` and ``__cpu_dispatch__`` // // // -//go:linkname ArraySplit py.array_split -func ArraySplit(ary *py.Object, indicesOrSections *py.Object, axis *py.Object) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname ShowRuntime py.show_runtime +func ShowRuntime() *py.Object // -// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// Construct an array from an index array and a list of arrays to choose from. // -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. +// First of all, if confused or uncertain, definitely look at the Examples - +// in its full generality, this function is less simple than it might +// seem from the following code description (below ndi = +// `numpy.lib.index_tricks`): // -// For signed integer inputs, the bit-wise NOT of the absolute value is -// returned. In a two's-complement system, this operation effectively flips -// all the bits, resulting in a representation that corresponds to the -// negative of the input plus one. This is the most common method of -// representing signed integers on computers [1]_. A N-bit two's-complement -// system can represent every integer in the range :math:`-2^{N-1}` to -// :math:`+2^{N-1}-1`. +// ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``. // -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// But this omits some subtleties. Here is a fully general summary: // -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. +// Given an "index" array (`a`) of integers and a sequence of ``n`` arrays +// (`choices`), `a` and each choice array are first broadcast, as necessary, +// to arrays of a common shape; calling these *Ba* and *Bchoices[i], i = +// 0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape`` +// for each ``i``. Then, a new array with shape ``Ba.shape`` is created as +// follows: // -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. +// * if ``mode='raise'`` (the default), then, first of all, each element of +// ``a`` (and thus ``Ba``) must be in the range ``[0, n-1]``; now, suppose +// that ``i`` (in that range) is the value at the ``(j0, j1, ..., jm)`` +// position in ``Ba`` - then the value at the same position in the new array +// is the value in ``Bchoices[i]`` at that same position; // -// Notes -// ----- -// ``numpy.bitwise_not`` is an alias for `invert`: +// * if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed) +// integer; modular arithmetic is used to map integers outside the range +// `[0, n-1]` back into that range; and then the new array is constructed +// as above; // -// >>> np.bitwise_not is np.invert -// True +// * if ``mode='clip'``, values in `a` (and thus ``Ba``) may be any (signed) +// integer; negative integers are mapped to 0; values greater than ``n-1`` +// are mapped to ``n-1``; and then the new array is constructed as above. // -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement +// Parameters +// ---------- +// a : int array +// This array must contain integers in ``[0, n-1]``, where ``n`` is the +// number of choices, unless ``mode=wrap`` or ``mode=clip``, in which +// cases any integers are permissible. +// choices : sequence of arrays +// Choice arrays. `a` and all of the choices must be broadcastable to the +// same shape. If `choices` is itself an array (not recommended), then +// its outermost dimension (i.e., the one corresponding to +// ``choices.shape[0]``) is taken as defining the "sequence". +// out : array, optional +// If provided, the result will be inserted into this array. It should +// be of the appropriate shape and dtype. Note that `out` is always +// buffered if ``mode='raise'``; use other modes for better performance. +// mode : {'raise' (default), 'wrap', 'clip'}, optional +// Specifies how indices outside ``[0, n-1]`` will be treated: // -// Examples -// -------- -// >>> import numpy as np +// * 'raise' : an exception is raised +// * 'wrap' : value becomes value mod ``n`` +// * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1 // -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: +// Returns +// ------- +// merged_array : array +// The merged result. // -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// np.uint8(242) -// >>> np.binary_repr(x, width=8) -// '11110010' +// Raises +// ------ +// ValueError: shape mismatch +// If `a` and each choice array are not all broadcastable to the same +// shape. // -// The result depends on the bit-width: +// See Also +// -------- +// ndarray.choose : equivalent method +// numpy.take_along_axis : Preferable if `choices` is an array // -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// np.uint16(65522) -// >>> np.binary_repr(x, width=16) -// '1111111111110010' +// Notes +// ----- +// To reduce the chance of misinterpretation, even though the following +// "abuse" is nominally supported, `choices` should neither be, nor be +// thought of as, a single array, i.e., the outermost sequence-like container +// should be either a list or a tuple. // -// When using signed integer types, the result is the bit-wise NOT of -// the unsigned type, interpreted as a signed integer: +// Examples +// -------- // -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' +// >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], +// ... [20, 21, 22, 23], [30, 31, 32, 33]] +// >>> np.choose([2, 3, 1, 0], choices +// ... # the first element of the result will be the first element of the +// ... # third (2+1) "array" in choices, namely, 20; the second element +// ... # will be the second element of the fourth (3+1) choice array, i.e., +// ... # 31, etc. +// ... ) +// array([20, 31, 12, 3]) +// >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1) +// array([20, 31, 12, 3]) +// >>> # because there are 4 choice arrays +// >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4) +// array([20, 1, 12, 3]) +// >>> # i.e., 0 // -// Booleans are accepted as well: +// A couple examples illustrating how choose broadcasts: // -// >>> np.invert(np.array([True, False])) -// array([False, True]) +// >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]] +// >>> choices = [-10, 10] +// >>> np.choose(a, choices) +// array([[ 10, -10, 10], +// [-10, 10, -10], +// [ 10, -10, 10]]) // -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. +// >>> # With thanks to Anne Archibald +// >>> a = np.array([0, 1]).reshape((2,1,1)) +// >>> c1 = np.array([1, 2, 3]).reshape((1,3,1)) +// >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5)) +// >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 +// array([[[ 1, 1, 1, 1, 1], +// [ 2, 2, 2, 2, 2], +// [ 3, 3, 3, 3, 3]], +// [[-1, -2, -3, -4, -5], +// [-1, -2, -3, -4, -5], +// [-1, -2, -3, -4, -5]]]) // -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) // -//go:linkname BitwiseInvert py.bitwise_invert -func BitwiseInvert(__llgo_va_list ...interface{}) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Return the complex conjugate, element-wise. +//go:linkname Choose py.choose +func Choose(a *py.Object, choices *py.Object, out *py.Object, mode *py.Object) *py.Object +// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. +// Calculate `2**p` for all `p` in the input array. // // Parameters // ---------- // x : array_like -// Input value. +// Input values. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -24333,423 +23658,445 @@ func BitwiseInvert(__llgo_va_list ...interface{}) *py.Object // // Returns // ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. +// out : ndarray or scalar +// Element-wise 2 to the power `x`. // This is a scalar if `x` is a scalar. // +// See Also +// -------- +// power +// // Notes // ----- -// `conj` is an alias for `conjugate`: +// .. versionadded:: 1.3.0 +// // -// >>> np.conj is np.conjugate -// True // // Examples // -------- -// >>> import numpy as np -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conj py.conj -func Conj(__llgo_va_list ...interface{}) *py.Object -// -// Range of values (maximum - minimum) along an axis. +// >>> np.exp2([2, 3]) +// array([ 4., 8.]) // -// The name of the function comes from the acronym for 'peak to peak'. +//go:linkname Exp2 py.exp2 +func Exp2(x *py.Object, out *py.Object) *py.Object // -// .. warning:: -// `ptp` preserves the data type of the array. This means the -// return value for an input of signed integers with n bits -// (e.g. `numpy.int8`, `numpy.int16`, etc) is also a signed integer -// with n bits. In that case, peak-to-peak values greater than -// ``2**(n-1)-1`` will be returned as negative values. An example -// with a work-around is shown below. +// Return the imaginary part of the complex argument. // // Parameters // ---------- -// a : array_like -// Input values. -// axis : None or int or tuple of ints, optional -// Axis along which to find the peaks. By default, flatten the -// array. `axis` may be negative, in -// which case it counts from the last to the first axis. -// If this is a tuple of ints, a reduction is performed on multiple -// axes, instead of a single axis or all the axes as before. -// out : array_like -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type of the output values will be cast if necessary. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `ptp` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. +// val : array_like +// Input array. // // Returns // ------- -// 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 +// out : ndarray or scalar +// The imaginary component of the complex argument. If `val` is real, +// the type of `val` is used for the output. If `val` has complex +// elements, the returned type is float. +// +// See Also +// -------- +// real, angle, real_if_close // // Examples // -------- -// >>> import numpy as np -// >>> x = np.array([[4, 9, 2, 10], -// ... [6, 9, 7, 12]]) +// >>> a = np.array([1+2j, 3+4j, 5+6j]) +// >>> a.imag +// array([2., 4., 6.]) +// >>> a.imag = np.array([8, 10, 12]) +// >>> a +// array([1. +8.j, 3.+10.j, 5.+12.j]) +// >>> np.imag(1 + 1j) +// 1.0 // -// >>> np.ptp(x, axis=1) -// array([8, 6]) // -// >>> np.ptp(x, axis=0) -// array([2, 0, 5, 2]) // -// >>> np.ptp(x) -// 10 +//go:linkname Imag py.imag +func Imag(val *py.Object) *py.Object // -// This example shows that a negative value can be returned when -// the input is an array of signed integers. +// Find the set exclusive-or of two arrays. // -// >>> y = np.array([[1, 127], -// ... [0, 127], -// ... [-1, 127], -// ... [-2, 127]], dtype=np.int8) -// >>> np.ptp(y, axis=1) -// array([ 126, 127, -128, -127], dtype=int8) +// Return the sorted, unique values that are in only one (not both) of the +// input arrays. // -// A work-around is to use the `view()` method to view the result as -// unsigned integers with the same bit width: +// Parameters +// ---------- +// ar1, ar2 : array_like +// Input arrays. +// assume_unique : bool +// If True, the input arrays are both assumed to be unique, which +// can speed up the calculation. Default is False. // -// >>> np.ptp(y, axis=1).view(np.uint8) -// array([126, 127, 128, 129], dtype=uint8) +// Returns +// ------- +// setxor1d : ndarray +// Sorted 1D array of unique values that are in only one of the input +// arrays. // +// Examples +// -------- +// >>> a = np.array([1, 2, 3, 2, 4]) +// >>> b = np.array([2, 3, 5, 7, 5]) +// >>> np.setxor1d(a,b) +// array([1, 4, 5, 7]) // // -//go:linkname Ptp py.ptp -func Ptp(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object) *py.Object -// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) // -// Return the distance between x and the nearest adjacent number. +//go:linkname Setxor1d py.setxor1d +func Setxor1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object) *py.Object +// Fill the main diagonal of the given array of any dimensionality. // -// Parameters -// ---------- -// x : array_like -// Values to find the spacing of. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// For an array `a` with ``a.ndim >= 2``, the diagonal is the list of +// locations with indices ``a[i, ..., i]`` all identical. This function +// modifies the input array in-place, it does not return a value. // -// Returns -// ------- -// out : ndarray or scalar -// The spacing of values of `x`. -// This is a scalar if `x` is a scalar. +// Parameters +// ---------- +// a : array, at least 2-D. +// Array whose diagonal is to be filled, it gets modified in-place. // -// Notes -// ----- -// It can be considered as a generalization of EPS: -// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there -// should not be any representable number between ``x + spacing(x)`` and -// x for any finite x. +// val : scalar or array_like +// Value(s) to write on the diagonal. If `val` is scalar, the value is +// written along the diagonal. If array-like, the flattened `val` is +// written along the diagonal, repeating if necessary to fill all +// diagonal entries. // -// Spacing of +- inf and NaN is NaN. +// wrap : bool +// For tall matrices in NumPy version up to 1.6.2, the +// diagonal "wrapped" after N columns. You can have this behavior +// with this option. This affects only tall matrices. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.spacing(1) == np.finfo(np.float64).eps -// True +// See also +// -------- +// diag_indices, diag_indices_from // -//go:linkname Spacing py.spacing -func Spacing(x *py.Object, out *py.Object) *py.Object -// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Notes +// ----- +// .. versionadded:: 1.4.0 // -// Compute tangent element-wise. +// This functionality can be obtained via `diag_indices`, but internally +// this version uses a much faster implementation that never constructs the +// indices and uses simple slicing. // -// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. +// Examples +// -------- +// >>> a = np.zeros((3, 3), int) +// >>> np.fill_diagonal(a, 5) +// >>> a +// array([[5, 0, 0], +// [0, 5, 0], +// [0, 0, 5]]) // -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// The same function can operate on a 4-D array: +// +// >>> a = np.zeros((3, 3, 3, 3), int) +// >>> np.fill_diagonal(a, 4) +// +// We only show a few blocks for clarity: +// +// >>> a[0, 0] +// array([[4, 0, 0], +// [0, 0, 0], +// [0, 0, 0]]) +// >>> a[1, 1] +// array([[0, 0, 0], +// [0, 4, 0], +// [0, 0, 0]]) +// >>> a[2, 2] +// array([[0, 0, 0], +// [0, 0, 0], +// [0, 0, 4]]) +// +// The wrap option affects only tall matrices: +// +// >>> # tall matrices no wrap +// >>> a = np.zeros((5, 3), int) +// >>> np.fill_diagonal(a, 4) +// >>> a +// array([[4, 0, 0], +// [0, 4, 0], +// [0, 0, 4], +// [0, 0, 0], +// [0, 0, 0]]) // -// Returns -// ------- -// y : ndarray -// The corresponding tangent values. -// This is a scalar if `x` is a scalar. +// >>> # tall matrices wrap +// >>> a = np.zeros((5, 3), int) +// >>> np.fill_diagonal(a, 4, wrap=True) +// >>> a +// array([[4, 0, 0], +// [0, 4, 0], +// [0, 0, 4], +// [0, 0, 0], +// [4, 0, 0]]) // -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) +// >>> # wide matrices +// >>> a = np.zeros((3, 5), int) +// >>> np.fill_diagonal(a, 4, wrap=True) +// >>> a +// array([[4, 0, 0, 0, 0], +// [0, 4, 0, 0, 0], +// [0, 0, 4, 0, 0]]) // -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. +// The anti-diagonal can be filled by reversing the order of elements +// using either `numpy.flipud` or `numpy.fliplr`. // -// Examples -// -------- -// >>> import numpy as np -// >>> from math import pi -// >>> np.tan(np.array([-pi,pi/2,pi])) -// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) -// >>> -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) +// >>> a = np.zeros((3, 3), int); +// >>> np.fill_diagonal(np.fliplr(a), [1,2,3]) # Horizontal flip +// >>> a +// array([[0, 0, 1], +// [0, 2, 0], +// [3, 0, 0]]) +// >>> np.fill_diagonal(np.flipud(a), [1,2,3]) # Vertical flip +// >>> a +// array([[0, 0, 3], +// [0, 2, 0], +// [1, 0, 0]]) // -//go:linkname Tan py.tan -func Tan(x *py.Object, out *py.Object) *py.Object +// Note that the order in which the diagonal is filled varies depending +// on the flip function. // -// Construct an open mesh from multiple sequences. // -// This function takes N 1-D sequences and returns N outputs with N -// dimensions each, such that the shape is 1 in all but one dimension -// and the dimension with the non-unit shape value cycles through all -// N dimensions. +//go:linkname FillDiagonal py.fill_diagonal +func FillDiagonal(a *py.Object, val *py.Object, wrap *py.Object) *py.Object +// compare_chararrays(a1, a2, cmp, rstrip) // -// Using `ix_` one can quickly construct index arrays that will index -// the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array -// ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``. +// Performs element-wise comparison of two string arrays using the +// comparison operator specified by `cmp_op`. // // Parameters // ---------- -// args : 1-D sequences -// Each sequence should be of integer or boolean type. -// Boolean sequences will be interpreted as boolean masks for the -// corresponding dimension (equivalent to passing in -// ``np.nonzero(boolean_sequence)``). +// a1, a2 : array_like +// Arrays to be compared. +// cmp : {"<", "<=", "==", ">=", ">", "!="} +// Type of comparison. +// rstrip : Boolean +// If True, the spaces at the end of Strings are removed before the comparison. // // Returns // ------- -// out : tuple of ndarrays -// N arrays with N dimensions each, with N the number of input -// sequences. Together these arrays form an open mesh. +// out : ndarray +// The output array of type Boolean with the same shape as a and b. // -// See Also -// -------- -// ogrid, mgrid, meshgrid +// Raises +// ------ +// ValueError +// If `cmp_op` is not valid. +// TypeError +// If at least one of `a` or `b` is a non-string array // // Examples // -------- -// >>> import numpy as np -// >>> a = np.arange(10).reshape(2, 5) -// >>> a -// array([[0, 1, 2, 3, 4], -// [5, 6, 7, 8, 9]]) -// >>> ixgrid = np.ix_([0, 1], [2, 4]) -// >>> ixgrid -// (array([[0], -// [1]]), array([[2, 4]])) -// >>> ixgrid[0].shape, ixgrid[1].shape -// ((2, 1), (1, 2)) -// >>> a[ixgrid] -// array([[2, 4], -// [7, 9]]) -// -// >>> ixgrid = np.ix_([True, True], [2, 4]) -// >>> a[ixgrid] -// array([[2, 4], -// [7, 9]]) -// >>> ixgrid = np.ix_([True, True], [False, False, True, False, True]) -// >>> a[ixgrid] -// array([[2, 4], -// [7, 9]]) +// >>> a = np.array(["a", "b", "cde"]) +// >>> b = np.array(["a", "a", "dec"]) +// >>> np.compare_chararrays(a, b, ">", True) +// array([False, True, False]) // +//go:linkname CompareChararrays py.compare_chararrays +func CompareChararrays(a1 *py.Object, a2 *py.Object, cmp *py.Object, rstrip *py.Object) *py.Object // +// Clip (limit) the values in an array. // -//go:linkname Ix_ py.ix_ -func Ix_(__llgo_va_list ...interface{}) *py.Object +// Given an interval, values outside the interval are clipped to +// the interval edges. For example, if an interval of ``[0, 1]`` +// is specified, values smaller than 0 become 0, and values larger +// than 1 become 1. // -// Return the product of array elements over a given axis treating Not a -// Numbers (NaNs) as ones. +// Equivalent to but faster than ``np.minimum(a_max, np.maximum(a, a_min))``. // -// One is returned for slices that are all-NaN or empty. +// No check is performed to ensure ``a_min < a_max``. // // Parameters // ---------- // a : array_like -// Array containing numbers whose product is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the product is computed. The default is to compute -// the product of the flattened array. -// dtype : data-type, optional -// The type of the returned array and of the accumulator in which the -// elements are summed. By default, the dtype of `a` is used. An -// exception is when `a` has an integer type with less precision than -// the platform (u)intp. In that case, the default will be either -// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 -// bits. For inexact inputs, dtype must be inexact. +// Array containing elements to clip. +// a_min, a_max : array_like or None +// Minimum and maximum value. If ``None``, clipping is not performed on +// the corresponding edge. Only one of `a_min` and `a_max` may be +// ``None``. Both are broadcast against `a`. // out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``. If provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. The casting of NaN to integer -// can yield unexpected results. -// keepdims : bool, optional -// If 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 `arr`. -// initial : scalar, optional -// The starting value for this product. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to include in the product. See `~numpy.ufunc.reduce` -// for details. +// The results will be placed in this array. It may be the input +// array for in-place clipping. `out` must be of the right shape +// to hold the output. Its type is preserved. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// .. versionadded:: 1.22.0 +// .. versionadded:: 1.17.0 // // Returns // ------- -// nanprod : ndarray -// A new array holding the result is returned unless `out` is -// specified, in which case it is returned. +// clipped_array : ndarray +// An array with the elements of `a`, but where values +// < `a_min` are replaced with `a_min`, and those > `a_max` +// with `a_max`. // // See Also // -------- -// numpy.prod : Product across array propagating NaNs. -// isnan : Show which elements are NaN. +// :ref:`ufuncs-output-type` +// +// Notes +// ----- +// When `a_min` is greater than `a_max`, `clip` returns an +// array in which all values are equal to `a_max`, +// as shown in the second example. // // Examples // -------- -// >>> import numpy as np -// >>> np.nanprod(1) -// 1 -// >>> np.nanprod([1]) -// 1 -// >>> np.nanprod([1, np.nan]) -// 1.0 -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nanprod(a) -// 6.0 -// >>> np.nanprod(a, axis=0) -// array([3., 2.]) +// >>> a = np.arange(10) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// >>> np.clip(a, 1, 8) +// array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) +// >>> np.clip(a, 8, 1) +// array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) +// >>> np.clip(a, 3, 6, out=a) +// array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) +// >>> a +// array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) +// >>> a = np.arange(10) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) +// >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) +// array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8]) +// +// +// +//go:linkname Clip py.clip +func Clip(a *py.Object, aMin *py.Object, aMax *py.Object, out *py.Object) *py.Object +// +// Return specified diagonals. +// +// If `a` is 2-D, returns the diagonal of `a` with the given offset, +// i.e., the collection of elements of the form ``a[i, i+offset]``. If +// `a` has more than two dimensions, then the axes specified by `axis1` +// and `axis2` are used to determine the 2-D sub-array whose diagonal is +// returned. The shape of the resulting array can be determined by +// removing `axis1` and `axis2` and appending an index to the right equal +// to the size of the resulting diagonals. +// +// In versions of NumPy prior to 1.7, this function always returned a new, +// independent array containing a copy of the values in the diagonal. +// +// In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, +// but depending on this fact is deprecated. Writing to the resulting +// array continues to work as it used to, but a FutureWarning is issued. +// +// Starting in NumPy 1.9 it returns a read-only view on the original array. +// Attempting to write to the resulting array will produce an error. +// +// In some future release, it will return a read/write view and writing to +// the returned array will alter your original array. The returned array +// will have the same type as the input array. +// +// If you don't write to the array returned by this function, then you can +// just ignore all of the above. // +// If you depend on the current behavior, then we suggest copying the +// returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead +// of just ``np.diagonal(a)``. This will work with both past and future +// versions of NumPy. // +// Parameters +// ---------- +// a : array_like +// Array from which the diagonals are taken. +// offset : int, optional +// Offset of the diagonal from the main diagonal. Can be positive or +// negative. Defaults to main diagonal (0). +// axis1 : int, optional +// Axis to be used as the first axis of the 2-D sub-arrays from which +// the diagonals should be taken. Defaults to first axis (0). +// axis2 : int, optional +// Axis to be used as the second axis of the 2-D sub-arrays from +// which the diagonals should be taken. Defaults to second axis (1). // -//go:linkname Nanprod py.nanprod -func Nanprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object +// Returns +// ------- +// array_of_diagonals : ndarray +// If `a` is 2-D, then a 1-D array containing the diagonal and of the +// same type as `a` is returned unless `a` is a `matrix`, in which case +// a 1-D array rather than a (2-D) `matrix` is returned in order to +// maintain backward compatibility. // -// Return the indices for the lower-triangle of arr. +// If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2` +// are removed, and a new axis inserted at the end corresponding to the +// diagonal. // -// See `tril_indices` for full details. +// Raises +// ------ +// ValueError +// If the dimension of `a` is less than 2. // -// Parameters -// ---------- -// arr : array_like -// The indices will be valid for square arrays whose dimensions are -// the same as arr. -// k : int, optional -// Diagonal offset (see `tril` for details). +// See Also +// -------- +// diag : MATLAB work-a-like for 1-D and 2-D arrays. +// diagflat : Create diagonal arrays. +// trace : Sum along diagonals. // // Examples // -------- -// >>> import numpy as np -// -// Create a 4 by 4 array -// -// >>> a = np.arange(16).reshape(4, 4) +// >>> a = np.arange(4).reshape(2,2) // >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Pass the array to get the indices of the lower triangular elements. +// array([[0, 1], +// [2, 3]]) +// >>> a.diagonal() +// array([0, 3]) +// >>> a.diagonal(1) +// array([1]) // -// >>> trili = np.tril_indices_from(a) -// >>> trili -// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) +// A 3-D example: // -// >>> a[trili] -// array([ 0, 4, 5, 8, 9, 10, 12, 13, 14, 15]) +// >>> a = np.arange(8).reshape(2,2,2); a +// array([[[0, 1], +// [2, 3]], +// [[4, 5], +// [6, 7]]]) +// >>> a.diagonal(0, # Main diagonals of two arrays created by skipping +// ... 0, # across the outer(left)-most axis last and +// ... 1) # the "middle" (row) axis first. +// array([[0, 6], +// [1, 7]]) // -// This is syntactic sugar for tril_indices(). +// The sub-arrays whose main diagonals we just obtained; note that each +// corresponds to fixing the right-most (column) axis, and that the +// diagonals are "packed" in rows. // -// >>> np.tril_indices(a.shape[0]) -// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) +// >>> a[:,:,0] # main diagonal is [0 6] +// array([[0, 2], +// [4, 6]]) +// >>> a[:,:,1] # main diagonal is [1 7] +// array([[1, 3], +// [5, 7]]) // -// Use the `k` parameter to return the indices for the lower triangular array -// up to the k-th diagonal. +// The anti-diagonal can be obtained by reversing the order of elements +// using either `numpy.flipud` or `numpy.fliplr`. // -// >>> trili1 = np.tril_indices_from(a, k=1) -// >>> a[trili1] -// array([ 0, 1, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15]) +// >>> a = np.arange(9).reshape(3, 3) +// >>> a +// array([[0, 1, 2], +// [3, 4, 5], +// [6, 7, 8]]) +// >>> np.fliplr(a).diagonal() # Horizontal flip +// array([2, 4, 6]) +// >>> np.flipud(a).diagonal() # Vertical flip +// array([6, 4, 2]) // -// See Also -// -------- -// tril_indices, tril, triu_indices_from +// Note that the order in which the diagonal is retrieved varies depending +// on the flip function. // // -//go:linkname TrilIndicesFrom py.tril_indices_from -func TrilIndicesFrom(arr *py.Object, k *py.Object) *py.Object -// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Diagonal py.diagonal +func Diagonal(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Object) *py.Object +// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Shift the bits of an integer to the left. +// Return the cube-root of an array, element-wise. // -// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. -// Since the internal representation of numbers is in binary format, this -// operation is equivalent to multiplying `x1` by ``2**x2``. +// .. versionadded:: 1.10.0 // // Parameters // ---------- -// x1 : array_like of integer type -// Input values. -// x2 : array_like of integer type -// Number of zeros to append to `x1`. Has to be non-negative. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// The values whose cube-roots are required. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -24768,169 +24115,31 @@ func TrilIndicesFrom(arr *py.Object, k *py.Object) *py.Object // // Returns // ------- -// out : array of integer type -// Return `x1` with bits shifted `x2` times to the left. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray +// An array of the same shape as `x`, containing the cube +// cube-root of each element in `x`. +// If `out` was provided, `y` is a reference to it. +// This is a scalar if `x` is a scalar. // -// See Also -// -------- -// right_shift : Shift the bits of an integer to the right. -// binary_repr : Return the binary representation of the input number -// as a string. // // Examples // -------- -// >>> import numpy as np -// >>> np.binary_repr(5) -// '101' -// >>> np.left_shift(5, 2) -// 20 -// >>> np.binary_repr(20) -// '10100' -// -// >>> np.left_shift(5, [1,2,3]) -// array([10, 20, 40]) -// -// Note that the dtype of the second argument may change the dtype of the -// result and can lead to unexpected results in some cases (see -// :ref:`Casting Rules `): -// -// >>> a = np.left_shift(np.uint8(255), np.int64(1)) # Expect 254 -// >>> print(a, type(a)) # Unexpected result due to upcasting -// 510 -// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) -// >>> print(b, type(b)) -// 254 -// -// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on -// ndarrays. -// -// >>> x1 = 5 -// >>> x2 = np.array([1, 2, 3]) -// >>> x1 << x2 -// array([10, 20, 40]) -// -//go:linkname BitwiseLeftShift py.bitwise_left_shift -func BitwiseLeftShift(__llgo_va_list ...interface{}) *py.Object -// -// concatenate( -// (a1, a2, ...), -// axis=0, -// out=None, -// dtype=None, -// casting="same_kind" -// ) -// -// Join a sequence of arrays along an existing axis. -// -// Parameters -// ---------- -// a1, a2, ... : sequence of array_like -// The arrays must have the same shape, except in the dimension -// corresponding to `axis` (the first, by default). -// axis : int, optional -// The axis along which the arrays will be joined. If axis is None, -// arrays are flattened before use. Default is 0. -// out : ndarray, optional -// If provided, the destination to place the result. The shape must be -// correct, matching that of what concatenate 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.20.0 -// -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Defaults to 'same_kind'. -// For a description of the options, please see :term:`casting`. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// res : ndarray -// The concatenated array. -// -// See Also -// -------- -// ma.concatenate : Concatenate function that preserves input masks. -// array_split : Split an array into multiple sub-arrays of equal or -// near-equal size. -// split : Split array into a list of multiple sub-arrays of equal size. -// hsplit : Split array into multiple sub-arrays horizontally (column wise). -// vsplit : Split array into multiple sub-arrays vertically (row wise). -// dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). -// stack : Stack a sequence of arrays along a new axis. -// block : Assemble arrays from blocks. -// hstack : Stack arrays in sequence horizontally (column wise). -// vstack : Stack arrays in sequence vertically (row wise). -// dstack : Stack arrays in sequence depth wise (along third dimension). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// -// Notes -// ----- -// When one or more of the arrays to be concatenated is a MaskedArray, -// this function will return a MaskedArray object instead of an ndarray, -// but the input masks are *not* preserved. In cases where a MaskedArray -// is expected as input, use the ma.concatenate function from the masked -// array module instead. -// -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> b = np.array([[5, 6]]) -// >>> np.concatenate((a, b), axis=0) -// array([[1, 2], -// [3, 4], -// [5, 6]]) -// >>> np.concatenate((a, b.T), axis=1) -// array([[1, 2, 5], -// [3, 4, 6]]) -// >>> np.concatenate((a, b), axis=None) -// array([1, 2, 3, 4, 5, 6]) -// -// This function will not preserve masking of MaskedArray inputs. -// -// >>> a = np.ma.arange(3) -// >>> a[1] = np.ma.masked -// >>> b = np.arange(2, 5) -// >>> a -// masked_array(data=[0, --, 2], -// mask=[False, True, False], -// fill_value=999999) -// >>> b -// array([2, 3, 4]) -// >>> np.concatenate([a, b]) -// masked_array(data=[0, 1, 2, 2, 3, 4], -// mask=False, -// fill_value=999999) -// >>> np.ma.concatenate([a, b]) -// masked_array(data=[0, --, 2, 2, 3, 4], -// mask=[False, True, False, False, False, False], -// fill_value=999999) -// -// +// >>> np.cbrt([1,8,27]) +// array([ 1., 2., 3.]) // -//go:linkname Concatenate py.concatenate -func Concatenate(a1 *py.Object, a2 *py.Object) *py.Object -// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +//go:linkname Cbrt py.cbrt +func Cbrt(x *py.Object, out *py.Object) *py.Object +// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Shift the bits of an integer to the left. +// Hyperbolic sine, element-wise. // -// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. -// Since the internal representation of numbers is in binary format, this -// operation is equivalent to multiplying `x1` by ``2**x2``. +// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or +// ``-1j * np.sin(1j*x)``. // // Parameters // ---------- -// x1 : array_like of integer type -// Input values. -// x2 : array_like of integer type -// Number of zeros to append to `x1`. Has to be non-negative. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). +// x : array_like +// Input array. // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -24949,2117 +24158,2373 @@ func Concatenate(a1 *py.Object, a2 *py.Object) *py.Object // // Returns // ------- -// out : array of integer type -// Return `x1` with bits shifted `x2` times to the left. -// This is a scalar if both `x1` and `x2` are scalars. +// y : ndarray +// The corresponding hyperbolic sine values. +// This is a scalar if `x` is a scalar. // -// See Also -// -------- -// right_shift : Shift the bits of an integer to the right. -// binary_repr : Return the binary representation of the input number -// as a string. +// Notes +// ----- +// If `out` is provided, the function writes the result into it, +// and returns a reference to `out`. (See Examples) +// +// References +// ---------- +// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. +// New York, NY: Dover, 1972, pg. 83. // // Examples // -------- -// >>> import numpy as np -// >>> np.binary_repr(5) -// '101' -// >>> np.left_shift(5, 2) -// 20 -// >>> np.binary_repr(20) -// '10100' +// >>> np.sinh(0) +// 0.0 +// >>> np.sinh(np.pi*1j/2) +// 1j +// >>> np.sinh(np.pi*1j) # (exact value is 0) +// 1.2246063538223773e-016j +// >>> # Discrepancy due to vagaries of floating point arithmetic. // -// >>> np.left_shift(5, [1,2,3]) -// array([10, 20, 40]) +// >>> # Example of providing the optional output parameter +// >>> out1 = np.array([0], dtype='d') +// >>> out2 = np.sinh([0.1], out1) +// >>> out2 is out1 +// True // -// Note that the dtype of the second argument may change the dtype of the -// result and can lead to unexpected results in some cases (see -// :ref:`Casting Rules `): +// >>> # Example of ValueError due to provision of shape mis-matched `out` +// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) +// Traceback (most recent call last): +// File "", line 1, in +// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) // -// >>> a = np.left_shift(np.uint8(255), np.int64(1)) # Expect 254 -// >>> print(a, type(a)) # Unexpected result due to upcasting -// 510 -// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) -// >>> print(b, type(b)) -// 254 +//go:linkname Sinh py.sinh +func Sinh(x *py.Object, out *py.Object) *py.Object // -// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on -// ndarrays. +// Return the indices to access the main diagonal of an n-dimensional array. +// +// See `diag_indices` for full details. +// +// Parameters +// ---------- +// arr : array, at least 2-D +// +// See Also +// -------- +// diag_indices +// +// Notes +// ----- +// .. versionadded:: 1.4.0 +// +// Examples +// -------- +// +// Create a 4 by 4 array. +// +// >>> a = np.arange(16).reshape(4, 4) +// >>> a +// array([[ 0, 1, 2, 3], +// [ 4, 5, 6, 7], +// [ 8, 9, 10, 11], +// [12, 13, 14, 15]]) +// +// Get the indices of the diagonal elements. +// +// >>> di = np.diag_indices_from(a) +// >>> di +// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) +// +// >>> a[di] +// array([ 0, 5, 10, 15]) +// +// This is simply syntactic sugar for diag_indices. +// +// >>> np.diag_indices(a.shape[0]) +// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) // -// >>> x1 = 5 -// >>> x2 = np.array([1, 2, 3]) -// >>> x1 << x2 -// array([10, 20, 40]) // -//go:linkname LeftShift py.left_shift -func LeftShift(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object // -// Transposes a matrix (or a stack of matrices) ``x``. +//go:linkname DiagIndicesFrom py.diag_indices_from +func DiagIndicesFrom(arr *py.Object) *py.Object +// +// Return the derivative of the specified order of a polynomial. // -// This function is Array API compatible. +// .. note:: +// This forms part of the old polynomial API. Since version 1.4, the +// new polynomial API defined in `numpy.polynomial` is preferred. +// A summary of the differences can be found in the +// :doc:`transition guide `. // // Parameters // ---------- -// x : array_like -// Input array having shape (..., M, N) and whose two innermost -// dimensions form ``MxN`` matrices. +// p : poly1d or sequence +// Polynomial to differentiate. +// A sequence is interpreted as polynomial coefficients, see `poly1d`. +// m : int, optional +// Order of differentiation (default: 1) // // Returns // ------- -// out : ndarray -// An array containing the transpose for each matrix and having shape -// (..., N, M). +// der : poly1d +// A new polynomial representing the derivative. // // See Also // -------- -// transpose : Generic transpose method. +// polyint : Anti-derivative of a polynomial. +// poly1d : Class for one-dimensional polynomials. // // Examples // -------- -// >>> import numpy as np -// >>> np.matrix_transpose([[1, 2], [3, 4]]) -// array([[1, 3], -// [2, 4]]) +// The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is: // -// >>> np.matrix_transpose([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) -// array([[[1, 3], -// [2, 4]], -// [[5, 7], -// [6, 8]]]) +// >>> p = np.poly1d([1,1,1,1]) +// >>> p2 = np.polyder(p) +// >>> p2 +// poly1d([3, 2, 1]) // +// which evaluates to: // +// >>> p2(2.) +// 17.0 // -//go:linkname MatrixTranspose py.matrix_transpose -func MatrixTranspose(__llgo_va_list ...interface{}) *py.Object +// We can verify this, approximating the derivative with +// ``(f(x + h) - f(x))/h``: // -// result_type(*arrays_and_dtypes) +// >>> (p(2. + 0.001) - p(2.)) / 0.001 +// 17.007000999997857 // -// Returns the type that results from applying the NumPy -// type promotion rules to the arguments. +// The fourth-order derivative of a 3rd-order polynomial is zero: // -// Type promotion in NumPy works similarly to the rules in languages -// like C++, with some slight differences. When both scalars and -// arrays are used, the array's type takes precedence and the actual value -// of the scalar is taken into account. +// >>> np.polyder(p, 2) +// poly1d([6, 2]) +// >>> np.polyder(p, 3) +// poly1d([6]) +// >>> np.polyder(p, 4) +// poly1d([0]) // -// For example, calculating 3*a, where a is an array of 32-bit floats, -// intuitively should result in a 32-bit float output. If the 3 is a -// 32-bit integer, the NumPy rules indicate it can't convert losslessly -// into a 32-bit float, so a 64-bit float should be the result type. -// By examining the value of the constant, '3', we see that it fits in -// an 8-bit integer, which can be cast losslessly into the 32-bit float. +// +// +//go:linkname Polyder py.polyder +func Polyder(p *py.Object, m *py.Object) *py.Object +// +// Find indices where elements should be inserted to maintain order. +// +// Find the indices into a sorted array `a` such that, if the +// corresponding elements in `v` were inserted before the indices, the +// order of `a` would be preserved. +// +// Assuming that `a` is sorted: +// +// ====== ============================ +// `side` returned index `i` satisfies +// ====== ============================ +// left ``a[i-1] < v <= a[i]`` +// right ``a[i-1] <= v < a[i]`` +// ====== ============================ // // Parameters // ---------- -// arrays_and_dtypes : list of arrays and dtypes -// The operands of some operation whose result type is needed. +// a : 1-D array_like +// Input array. If `sorter` is None, then it must be sorted in +// ascending order, otherwise `sorter` must be an array of indices +// that sort it. +// v : array_like +// Values to insert into `a`. +// side : {'left', 'right'}, optional +// If 'left', the index of the first suitable location found is given. +// If 'right', return the last such index. If there is no suitable +// index, return either 0 or N (where N is the length of `a`). +// sorter : 1-D array_like, optional +// Optional array of integer indices that sort array a into ascending +// order. They are typically the result of argsort. +// +// .. versionadded:: 1.7.0 // // Returns // ------- -// out : dtype -// The result type. +// indices : int or array of ints +// Array of insertion points with the same shape as `v`, +// or an integer if `v` is a scalar. +// +// See Also +// -------- +// sort : Return a sorted copy of an array. +// histogram : Produce histogram from 1-D data. +// +// Notes +// ----- +// Binary search is used to find the required insertion points. +// +// As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing +// `nan` values. The enhanced sort order is documented in `sort`. +// +// This function uses the same algorithm as the builtin python `bisect.bisect_left` +// (``side='left'``) and `bisect.bisect_right` (``side='right'``) functions, +// which is also vectorized in the `v` argument. +// +// Examples +// -------- +// >>> np.searchsorted([1,2,3,4,5], 3) +// 2 +// >>> np.searchsorted([1,2,3,4,5], 3, side='right') +// 3 +// >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3]) +// array([0, 5, 1, 2]) +// +// +// +//go:linkname Searchsorted py.searchsorted +func Searchsorted(a *py.Object, v *py.Object, side *py.Object, sorter *py.Object) *py.Object +// +// Returns True if first argument is a typecode lower/equal in type hierarchy. +// +// This is like the builtin :func:`issubclass`, but for `dtype`\ s. +// +// Parameters +// ---------- +// arg1, arg2 : dtype_like +// `dtype` or object coercible to one +// +// Returns +// ------- +// out : bool +// +// See Also +// -------- +// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. +// issubsctype, issubclass_ // -// See also +// Examples // -------- -// dtype, promote_types, min_scalar_type, can_cast +// `issubdtype` can be used to check the type of arrays: // -// Notes -// ----- -// The specific algorithm used is as follows. +// >>> ints = np.array([1, 2, 3], dtype=np.int32) +// >>> np.issubdtype(ints.dtype, np.integer) +// True +// >>> np.issubdtype(ints.dtype, np.floating) +// False // -// Categories are determined by first checking which of boolean, -// integer (int/uint), or floating point (float/complex) the maximum -// kind of all the arrays and the scalars are. +// >>> floats = np.array([1, 2, 3], dtype=np.float32) +// >>> np.issubdtype(floats.dtype, np.integer) +// False +// >>> np.issubdtype(floats.dtype, np.floating) +// True // -// If there are only scalars or the maximum category of the scalars -// is higher than the maximum category of the arrays, -// the data types are combined with :func:`promote_types` -// to produce the return value. +// Similar types of different sizes are not subdtypes of each other: // -// Otherwise, `min_scalar_type` is called on each scalar, and -// the resulting data types are all combined with :func:`promote_types` -// to produce the return value. +// >>> np.issubdtype(np.float64, np.float32) +// False +// >>> np.issubdtype(np.float32, np.float64) +// False // -// The set of int values is not a subset of the uint values for types -// with the same number of bits, something not reflected in -// :func:`min_scalar_type`, but handled as a special case in `result_type`. +// but both are subtypes of `floating`: // -// Examples -// -------- -// >>> import numpy as np -// >>> np.result_type(3, np.arange(7, dtype='i1')) -// dtype('int8') +// >>> np.issubdtype(np.float64, np.floating) +// True +// >>> np.issubdtype(np.float32, np.floating) +// True // -// >>> np.result_type('i4', 'c8') -// dtype('complex128') +// For convenience, dtype-like objects are allowed too: // -// >>> np.result_type(3.0, -2) -// dtype('float64') +// >>> np.issubdtype('S1', np.string_) +// True +// >>> np.issubdtype('i4', np.signedinteger) +// True // // // -//go:linkname ResultType py.result_type -func ResultType(__llgo_va_list ...interface{}) *py.Object +//go:linkname Issubdtype py.issubdtype +func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object // -// Sum of array elements over a given axis. +// unravel_index(indices, shape, order='C') +// +// Converts a flat index or array of flat indices into a tuple +// of coordinate arrays. // // Parameters // ---------- -// a : array_like -// Elements to sum. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a sum is performed. The default, -// axis=None, will sum all of the elements of the input array. If -// axis is negative it counts from the last to the first axis. If -// axis is a tuple of ints, a sum is performed on all of the axes -// specified in the tuple instead of a single axis or all the axes as -// before. -// dtype : dtype, optional -// The type of the returned array and of the accumulator in which the -// elements are summed. The dtype of `a` is used by default unless `a` -// has an integer dtype of less precision than the default platform -// integer. In that case, if `a` is signed then the platform integer -// is used while if `a` is unsigned then an unsigned integer of the -// same precision as the platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output, but the type of the output -// values will be cast if necessary. -// 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 input array. +// indices : array_like +// An integer array whose elements are indices into the flattened +// version of an array of dimensions ``shape``. Before version 1.6.0, +// this function accepted just one index value. +// shape : tuple of ints +// The shape of the array to use for unraveling ``indices``. // -// If the default value is passed, then `keepdims` will not be -// passed through to the `sum` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// initial : scalar, optional -// Starting value for the sum. See `~numpy.ufunc.reduce` for details. -// where : array_like of bool, optional -// Elements to include in the sum. See `~numpy.ufunc.reduce` for details. +// .. versionchanged:: 1.16.0 +// Renamed from ``dims`` to ``shape``. +// +// order : {'C', 'F'}, optional +// Determines whether the indices should be viewed as indexing in +// row-major (C-style) or column-major (Fortran-style) order. +// +// .. versionadded:: 1.6.0 // // Returns // ------- -// sum_along_axis : ndarray -// An array with the same shape as `a`, with the specified -// axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar -// is returned. If an output array is specified, a reference to -// `out` is returned. +// unraveled_coords : tuple of ndarray +// Each array in the tuple has the same shape as the ``indices`` +// array. // // See Also // -------- -// ndarray.sum : Equivalent method. -// add: ``numpy.add.reduce`` equivalent function. -// cumsum : Cumulative sum of array elements. -// trapezoid : Integration of array values using composite trapezoidal rule. +// ravel_multi_index // -// mean, average +// Examples +// -------- +// >>> np.unravel_index([22, 41, 37], (7,6)) +// (array([3, 6, 6]), array([4, 5, 1])) +// >>> np.unravel_index([31, 41, 13], (7,6), order='F') +// (array([3, 6, 6]), array([4, 5, 1])) // -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. +// >>> np.unravel_index(1621, (6,7,8,9)) +// (3, 1, 4, 1) // -// The sum of an empty array is the neutral element 0: // -// >>> np.sum([]) -// 0.0 // -// For floating point numbers the numerical precision of sum (and -// ``np.add.reduce``) is in general limited by directly adding each number -// individually to the result causing rounding errors in every step. -// However, often numpy will use a numerically better approach (partial -// pairwise summation) leading to improved precision in many use-cases. -// This improved precision is always provided when no ``axis`` is given. -// When ``axis`` is given, it will depend on which axis is summed. -// Technically, to provide the best speed possible, the improved precision -// is only used when the summation is along the fast axis in memory. -// Note that the exact precision may vary depending on other parameters. -// In contrast to NumPy, Python's ``math.fsum`` function uses a slower but -// more precise approach to summation. -// Especially when summing a large number of lower precision floating point -// numbers, such as ``float32``, numerical errors can become significant. -// In such cases it can be advisable to use `dtype="float64"` to use a higher -// precision for the output. +//go:linkname UnravelIndex py.unravel_index +func UnravelIndex(indices *py.Object, shape *py.Object, order *py.Object) *py.Object +// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Examples -// -------- -// >>> import numpy as np -// >>> np.sum([0.5, 1.5]) -// 2.0 -// >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32) -// np.int32(1) -// >>> np.sum([[0, 1], [0, 5]]) -// 6 -// >>> np.sum([[0, 1], [0, 5]], axis=0) -// array([0, 6]) -// >>> np.sum([[0, 1], [0, 5]], axis=1) -// array([1, 5]) -// >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1) -// array([1., 5.]) +// Numerical positive, element-wise. // -// If the accumulator is too small, overflow occurs: +// .. versionadded:: 1.13.0 // -// >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8) -// np.int8(-128) +// Parameters +// ---------- +// x : array_like or scalar +// Input array. // -// You can also start the sum with a value other than zero: +// Returns +// ------- +// y : ndarray or scalar +// Returned array or scalar: `y = +x`. +// This is a scalar if `x` is a scalar. // -// >>> np.sum([10], initial=5) -// 15 +// Notes +// ----- +// Equivalent to `x.copy()`, but only defined for types that support +// arithmetic. // +// Examples +// -------- // -//go:linkname Sum py.sum -func Sum(__llgo_va_list ...interface{}) *py.Object +// >>> x1 = np.array(([1., -1.])) +// >>> np.positive(x1) +// array([ 1., -1.]) // -// Insert values along the given axis before the given indices. +// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on +// ndarrays. // -// Parameters -// ---------- -// arr : array_like -// Input array. -// obj : slice, int, array-like of ints or bools -// Object that defines the index or indices before which `values` is -// inserted. +// >>> x1 = np.array(([1., -1.])) +// >>> +x1 +// array([ 1., -1.]) // -// .. versionchanged:: 2.1.2 -// Boolean indices are now treated as a mask of elements to insert, -// rather than being cast to the integers 0 and 1. +//go:linkname Positive py.positive +func Positive(x *py.Object, out *py.Object) *py.Object +// datetime_data(dtype, /) // -// Support for multiple insertions when `obj` is a single scalar or a -// sequence with one element (similar to calling insert multiple -// times). -// values : array_like -// Values to insert into `arr`. If the type of `values` is different -// from that of `arr`, `values` is converted to the type of `arr`. -// `values` should be shaped so that ``arr[...,obj,...] = values`` -// is legal. -// axis : int, optional -// Axis along which to insert `values`. If `axis` is None then `arr` -// is flattened first. +// Get information about the step size of a date or time type. +// +// The returned tuple can be passed as the second argument of `numpy.datetime64` and +// `numpy.timedelta64`. +// +// Parameters +// ---------- +// dtype : dtype +// The dtype object, which must be a `datetime64` or `timedelta64` type. // // Returns // ------- -// out : ndarray -// A copy of `arr` with `values` inserted. Note that `insert` -// does not occur in-place: a new array is returned. If -// `axis` is None, `out` is a flattened array. +// unit : str +// The :ref:`datetime unit ` on which this dtype +// is based. +// count : int +// The number of base units in a step. // -// See Also +// Examples // -------- -// append : Append elements at the end of an array. -// concatenate : Join a sequence of arrays along an existing axis. -// delete : Delete elements from an array. +// >>> dt_25s = np.dtype('timedelta64[25s]') +// >>> np.datetime_data(dt_25s) +// ('s', 25) +// >>> np.array(10, dt_25s).astype('timedelta64[s]') +// array(250, dtype='timedelta64[s]') +// +// The result can be used to construct a datetime that uses the same units +// as a timedelta +// +// >>> np.datetime64('2010', np.datetime_data(dt_25s)) +// numpy.datetime64('2010-01-01T00:00:00','25s') +// +//go:linkname DatetimeData py.datetime_data +func DatetimeData(dtype *py.Object) *py.Object +// +// Set a Python function to be used when pretty printing arrays. +// +// Parameters +// ---------- +// f : function or None +// Function to be used to pretty print arrays. The function should expect +// a single array argument and return a string of the representation of +// the array. If None, the function is reset to the default NumPy function +// to print arrays. +// repr : bool, optional +// If True (default), the function for pretty printing (``__repr__``) +// is set, if False the function that returns the default string +// representation (``__str__``) is set. // -// 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``. This is because of the difference between basic -// and advanced :ref:`indexing `. +// See Also +// -------- +// set_printoptions, get_printoptions // // Examples // -------- -// >>> import numpy as np -// >>> a = np.arange(6).reshape(3, 2) +// >>> def pprint(arr): +// ... return 'HA! - What are you going to do now?' +// ... +// >>> np.set_string_function(pprint) +// >>> a = np.arange(10) // >>> a -// array([[0, 1], -// [2, 3], -// [4, 5]]) -// >>> np.insert(a, 1, 6) -// array([0, 6, 1, 2, 3, 4, 5]) -// >>> np.insert(a, 1, 6, axis=1) -// array([[0, 6, 1], -// [2, 6, 3], -// [4, 6, 5]]) -// -// Difference between sequence and scalars, -// showing how ``obj=[1]`` behaves different from ``obj=1``: -// -// >>> np.insert(a, [1], [[7],[8],[9]], axis=1) -// array([[0, 7, 1], -// [2, 8, 3], -// [4, 9, 5]]) -// >>> np.insert(a, 1, [[7],[8],[9]], axis=1) -// array([[0, 7, 8, 9, 1], -// [2, 7, 8, 9, 3], -// [4, 7, 8, 9, 5]]) -// >>> np.array_equal(np.insert(a, 1, [7, 8, 9], axis=1), -// ... np.insert(a, [1], [[7],[8],[9]], axis=1)) -// True +// HA! - What are you going to do now? +// >>> _ = a +// >>> # [0 1 2 3 4 5 6 7 8 9] // -// >>> b = a.flatten() -// >>> b -// array([0, 1, 2, 3, 4, 5]) -// >>> np.insert(b, [2, 2], [6, 7]) -// array([0, 1, 6, 7, 2, 3, 4, 5]) +// We can reset the function to the default: // -// >>> np.insert(b, slice(2, 4), [7, 8]) -// array([0, 1, 7, 2, 8, 3, 4, 5]) +// >>> np.set_string_function(None) +// >>> a +// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) // -// >>> np.insert(b, [2, 2], [7.13, False]) # type casting -// array([0, 1, 7, 0, 2, 3, 4, 5]) +// `repr` affects either pretty printing or normal string representation. +// Note that ``__repr__`` is still affected by setting ``__str__`` +// because the width of each array element in the returned string becomes +// equal to the length of the result of ``__str__()``. // -// >>> x = np.arange(8).reshape(2, 4) -// >>> idx = (1, 3) -// >>> np.insert(x, idx, 999, axis=1) -// array([[ 0, 999, 1, 2, 999, 3], -// [ 4, 999, 5, 6, 999, 7]]) +// >>> x = np.arange(4) +// >>> np.set_string_function(lambda x:'random', repr=False) +// >>> x.__str__() +// 'random' +// >>> x.__repr__() +// 'array([0, 1, 2, 3])' // // // -//go:linkname Insert py.insert -func Insert(arr *py.Object, obj *py.Object, values *py.Object, axis *py.Object) *py.Object +//go:linkname SetStringFunction py.set_string_function +func SetStringFunction(f *py.Object, repr *py.Object) *py.Object // -// One-dimensional linear interpolation for monotonically increasing sample points. +// Compute the q-th percentile of the data along the specified axis. // -// Returns the one-dimensional piecewise linear interpolant to a function -// with given discrete data points (`xp`, `fp`), evaluated at `x`. +// Returns the q-th percentile(s) of the array elements. // // Parameters // ---------- -// x : array_like -// The x-coordinates at which to evaluate the interpolated values. +// a : array_like of real numbers +// Input array or object that can be converted to an array. +// q : array_like of float +// Percentage or sequence of percentages for the percentiles to compute. +// Values must be between 0 and 100 inclusive. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the percentiles are computed. The +// default is to compute the percentile(s) along a flattened +// version of the array. // -// xp : 1-D sequence of floats -// The x-coordinates of the data points, must be increasing if argument -// `period` is not specified. Otherwise, `xp` is internally sorted after -// normalizing the periodic boundaries with ``xp = xp % period``. +// .. versionchanged:: 1.9.0 +// A tuple of axes is supported +// out : ndarray, optional +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output, +// but the type (of the output) will be cast if necessary. +// overwrite_input : bool, optional +// If True, then allow the input array `a` to be modified by intermediate +// calculations, to save memory. In this case, the contents of the input +// `a` after this function completes is undefined. +// method : str, optional +// This parameter specifies the method to use for estimating the +// percentile. There are many different methods, some unique to NumPy. +// See the notes for explanation. The options sorted by their R type +// as summarized in the H&F paper [1]_ are: // -// fp : 1-D sequence of float or complex -// The y-coordinates of the data points, same length as `xp`. +// 1. 'inverted_cdf' +// 2. 'averaged_inverted_cdf' +// 3. 'closest_observation' +// 4. 'interpolated_inverted_cdf' +// 5. 'hazen' +// 6. 'weibull' +// 7. 'linear' (default) +// 8. 'median_unbiased' +// 9. 'normal_unbiased' // -// left : optional float or complex corresponding to fp -// Value to return for `x < xp[0]`, default is `fp[0]`. +// The first three methods are discontinuous. NumPy further defines the +// following discontinuous variations of the default 'linear' (7.) option: // -// right : optional float or complex corresponding to fp -// Value to return for `x > xp[-1]`, default is `fp[-1]`. +// * 'lower' +// * 'higher', +// * 'midpoint' +// * 'nearest' // -// period : None or float, optional -// A period for the x-coordinates. This parameter allows the proper -// interpolation of angular x-coordinates. Parameters `left` and `right` -// are ignored if `period` is specified. +// .. versionchanged:: 1.22.0 +// This argument was previously called "interpolation" and only +// offered the "linear" default and last four options. +// +// 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 array `a`. +// +// .. versionadded:: 1.9.0 +// +// interpolation : str, optional +// Deprecated name for the method keyword argument. +// +// .. deprecated:: 1.22.0 // // Returns // ------- -// y : float or complex (corresponding to fp) or ndarray -// The interpolated values, same shape as `x`. -// -// Raises -// ------ -// ValueError -// If `xp` and `fp` have different length -// If `xp` or `fp` are not 1-D sequences -// If `period == 0` +// percentile : scalar or ndarray +// If `q` is a single percentile and `axis=None`, then the result +// is a scalar. If multiple percentiles are given, first axis of +// the result corresponds to the percentiles. The other axes are +// the axes that remain after the reduction of `a`. If the input +// contains integers or floats smaller than ``float64``, the output +// data-type is ``float64``. Otherwise, the output data-type is the +// same as that of the input. If `out` is specified, that array is +// returned instead. // // See Also // -------- -// scipy.interpolate +// mean +// median : equivalent to ``percentile(..., 50)`` +// nanpercentile +// quantile : equivalent to percentile, except q in the range [0, 1]. // -// Warnings -// -------- -// The x-coordinate sequence is expected to be increasing, but this is not -// explicitly enforced. However, if the sequence `xp` is non-increasing, -// interpolation results are meaningless. +// Notes +// ----- +// 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 +// percentile if the normalized ranking does not match the location of +// ``q`` exactly. This function is the same as the median if ``q=50``, the +// same as the minimum if ``q=0`` and the same as the maximum if +// ``q=100``. +// +// 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. +// +// The following formula determines the virtual index ``i + g``, the location +// of the percentile in the sorted sample: // -// Note that, since NaN is unsortable, `xp` also cannot contain NaNs. +// .. math:: +// i + g = (q / 100) * ( n - alpha - beta + 1 ) + alpha // -// A simple check for `xp` being strictly increasing is:: +// The different methods then work as follows // -// np.all(np.diff(xp) > 0) +// inverted_cdf: +// method 1 of H&F [1]_. +// This method gives discontinuous results: // -// Examples -// -------- -// >>> import numpy as np -// >>> xp = [1, 2, 3] -// >>> fp = [3, 2, 0] -// >>> np.interp(2.5, xp, fp) -// 1.0 -// >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp) -// array([3. , 3. , 2.5 , 0.56, 0. ]) -// >>> UNDEF = -99.0 -// >>> np.interp(3.14, xp, fp, right=UNDEF) -// -99.0 +// * if g > 0 ; then take j +// * if g = 0 ; then take i // -// Plot an interpolant to the sine function: +// averaged_inverted_cdf: +// method 2 of H&F [1]_. +// This method give discontinuous results: // -// >>> x = np.linspace(0, 2*np.pi, 10) -// >>> y = np.sin(x) -// >>> xvals = np.linspace(0, 2*np.pi, 50) -// >>> yinterp = np.interp(xvals, x, y) -// >>> import matplotlib.pyplot as plt -// >>> plt.plot(x, y, 'o') -// [] -// >>> plt.plot(xvals, yinterp, '-x') -// [] -// >>> plt.show() +// * if g > 0 ; then take j +// * if g = 0 ; then average between bounds // -// Interpolation with periodic x-coordinates: +// closest_observation: +// method 3 of H&F [1]_. +// This method give discontinuous results: // -// >>> x = [-180, -170, -185, 185, -10, -5, 0, 365] -// >>> xp = [190, -190, 350, -350] -// >>> fp = [5, 10, 3, 4] -// >>> np.interp(x, xp, fp, period=360) -// array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75]) +// * 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 // -// Complex interpolation: +// interpolated_inverted_cdf: +// method 4 of H&F [1]_. +// This method give continuous results using: // -// >>> x = [1.5, 4.0] -// >>> xp = [2,3,5] -// >>> fp = [1.0j, 0, 2+3j] -// >>> np.interp(x, xp, fp) -// array([0.+1.j , 1.+1.5j]) +// * alpha = 0 +// * beta = 1 // +// hazen: +// method 5 of H&F [1]_. +// This method give continuous results using: // +// * alpha = 1/2 +// * beta = 1/2 // -//go:linkname Interp py.interp -func Interp(x *py.Object, xp *py.Object, fp *py.Object, left *py.Object, right *py.Object, period *py.Object) *py.Object +// weibull: +// method 6 of H&F [1]_. +// This method give continuous results using: // -// Round an array to the given number of decimals. +// * alpha = 0 +// * beta = 0 // -// `around` is an alias of `~numpy.round`. +// linear: +// method 7 of H&F [1]_. +// This method give continuous results using: // -// See Also -// -------- -// ndarray.round : equivalent method -// round : alias for this function -// ceil, fix, floor, rint, trunc +// * alpha = 1 +// * beta = 1 // +// median_unbiased: +// 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: // +// * alpha = 1/3 +// * beta = 1/3 // -//go:linkname Around py.around -func Around(a *py.Object, decimals *py.Object, out *py.Object) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// normal_unbiased: +// 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: // -// Compute bit-wise inversion, or bit-wise NOT, element-wise. +// * alpha = 3/8 +// * beta = 3/8 // -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. +// lower: +// NumPy method kept for backwards compatibility. +// Takes ``i`` as the interpolation point. // -// For signed integer inputs, the bit-wise NOT of the absolute value is -// returned. In a two's-complement system, this operation effectively flips -// all the bits, resulting in a representation that corresponds to the -// negative of the input plus one. This is the most common method of -// representing signed integers on computers [1]_. A N-bit two's-complement -// system can represent every integer in the range :math:`-2^{N-1}` to -// :math:`+2^{N-1}-1`. +// higher: +// NumPy method kept for backwards compatibility. +// Takes ``j`` as the interpolation point. // -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// nearest: +// NumPy method kept for backwards compatibility. +// Takes ``i`` or ``j``, whichever is nearest. +// +// midpoint: +// NumPy method kept for backwards compatibility. +// Uses ``(i + j) / 2``. +// +// Examples +// -------- +// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) +// >>> a +// array([[10, 7, 4], +// [ 3, 2, 1]]) +// >>> np.percentile(a, 50) +// 3.5 +// >>> np.percentile(a, 50, axis=0) +// array([6.5, 4.5, 2.5]) +// >>> np.percentile(a, 50, axis=1) +// array([7., 2.]) +// >>> np.percentile(a, 50, axis=1, keepdims=True) +// array([[7.], +// [2.]]) +// +// >>> m = np.percentile(a, 50, axis=0) +// >>> out = np.zeros_like(m) +// >>> np.percentile(a, 50, axis=0, out=out) +// array([6.5, 4.5, 2.5]) +// >>> m +// array([6.5, 4.5, 2.5]) +// +// >>> b = a.copy() +// >>> np.percentile(b, 50, axis=1, overwrite_input=True) +// array([7., 2.]) +// >>> assert not np.all(a == b) +// +// The different methods can be visualized graphically: +// +// .. plot:: +// +// import matplotlib.pyplot as plt +// +// a = np.arange(4) +// p = np.linspace(0, 100, 6001) +// ax = plt.gca() +// lines = [ +// ('linear', '-', 'C0'), +// ('inverted_cdf', ':', 'C1'), +// # Almost the same as `inverted_cdf`: +// ('averaged_inverted_cdf', '-.', 'C1'), +// ('closest_observation', ':', 'C2'), +// ('interpolated_inverted_cdf', '--', 'C1'), +// ('hazen', '--', 'C3'), +// ('weibull', '-.', 'C4'), +// ('median_unbiased', '--', 'C5'), +// ('normal_unbiased', '-.', 'C6'), +// ] +// for method, style, color in lines: +// ax.plot( +// p, np.percentile(a, p, method=method), +// label=method, linestyle=style, color=color) +// ax.set( +// title='Percentiles for different methods and data: ' + str(a), +// xlabel='Percentile', +// ylabel='Estimated percentile value', +// yticks=a) +// ax.legend(bbox_to_anchor=(1.03, 1)) +// plt.tight_layout() +// plt.show() // -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. +// References +// ---------- +// .. [1] R. J. Hyndman and Y. Fan, +// "Sample quantiles in statistical packages," +// The American Statistician, 50(4), pp. 361-365, 1996 // -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. // -// Notes -// ----- -// ``numpy.bitwise_not`` is an alias for `invert`: // -// >>> np.bitwise_not is np.invert -// True +//go:linkname Percentile py.percentile +func Percentile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object // -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement +// Calculate the n-th discrete difference along the given axis. // -// Examples -// -------- -// >>> import numpy as np +// The first difference is given by ``out[i] = a[i+1] - a[i]`` along +// the given axis, higher differences are calculated by using `diff` +// recursively. // -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: +// Parameters +// ---------- +// a : array_like +// Input array +// n : int, optional +// The number of times values are differenced. If zero, the input +// is returned as-is. +// axis : int, optional +// The axis along which the difference is taken, default is the +// last axis. +// prepend, append : array_like, optional +// Values to prepend or append to `a` along axis prior to +// performing the difference. Scalar values are expanded to +// arrays with length 1 in the direction of axis and the shape +// of the input array in along all other axes. Otherwise the +// dimension and shape must match `a` except along axis. // -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// np.uint8(242) -// >>> np.binary_repr(x, width=8) -// '11110010' +// .. versionadded:: 1.16.0 // -// The result depends on the bit-width: +// Returns +// ------- +// diff : ndarray +// The n-th differences. The shape of the output is the same as `a` +// except along `axis` where the dimension is smaller by `n`. The +// type of the output is the same as the type of the difference +// between any two elements of `a`. This is the same as the type of +// `a` in most cases. A notable exception is `datetime64`, which +// results in a `timedelta64` output array. // -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// np.uint16(65522) -// >>> np.binary_repr(x, width=16) -// '1111111111110010' +// See Also +// -------- +// gradient, ediff1d, cumsum // -// When using signed integer types, the result is the bit-wise NOT of -// the unsigned type, interpreted as a signed integer: +// Notes +// ----- +// Type is preserved for boolean arrays, so the result will contain +// `False` when consecutive elements are the same and `True` when they +// differ. // -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' +// For unsigned integer arrays, the results will also be unsigned. This +// should not be surprising, as the result is consistent with +// calculating the difference directly: // -// Booleans are accepted as well: +// >>> u8_arr = np.array([1, 0], dtype=np.uint8) +// >>> np.diff(u8_arr) +// array([255], dtype=uint8) +// >>> u8_arr[1,...] - u8_arr[0,...] +// 255 // -// >>> np.invert(np.array([True, False])) -// array([False, True]) +// If this is not desirable, then the array should be cast to a larger +// integer type first: // -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. +// >>> i16_arr = u8_arr.astype(np.int16) +// >>> np.diff(i16_arr) +// array([-1], dtype=int16) // -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) +// Examples +// -------- +// >>> x = np.array([1, 2, 4, 7, 0]) +// >>> np.diff(x) +// array([ 1, 2, 3, -7]) +// >>> np.diff(x, n=2) +// array([ 1, 1, -10]) // -//go:linkname BitwiseNot py.bitwise_not -func BitwiseNot(__llgo_va_list ...interface{}) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]]) +// >>> np.diff(x) +// array([[2, 3, 4], +// [5, 1, 2]]) +// >>> np.diff(x, axis=0) +// array([[-1, 2, 0, -2]]) // -// Returns the element-wise remainder of division. +// >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64) +// >>> np.diff(x) +// array([1, 1], dtype='timedelta64[D]') // -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator ``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. // -// .. warning:: // -// This should not be confused with: +//go:linkname Diff py.diff +func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, append *py.Object) *py.Object // -// * Python's `math.remainder` and C's ``remainder``, which -// compute the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. +// Print the NumPy arrays in the given dictionary. // -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// If there is no dictionary passed in or `vardict` is None then returns +// NumPy arrays in the globals() dictionary (all NumPy arrays in the +// namespace). // -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. +// Parameters +// ---------- +// vardict : dict, optional +// A dictionary possibly containing ndarrays. Default is globals(). // -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor +// Returns +// ------- +// out : None +// Returns 'None'. // -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. +// Notes +// ----- +// Prints out the name, shape, bytes and type of all of the ndarrays +// present in `vardict`. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) +// Examples +// -------- +// >>> a = np.arange(10) +// >>> b = np.ones(20) +// >>> np.who() +// Name Shape Bytes Type +// =========================================================== +// a 10 80 int64 +// b 20 160 float64 +// Upper bound on total bytes = 240 // -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. +// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', +// ... 'idx':5} +// >>> np.who(d) +// Name Shape Bytes Type +// =========================================================== +// x 2 16 float64 +// y 3 24 float64 +// Upper bound on total bytes = 40 // -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) // -//go:linkname Mod py.mod -func Mod(__llgo_va_list ...interface{}) *py.Object // -// Find the intersection of two arrays. +//go:linkname Who py.who +func Who(vardict *py.Object) *py.Object // -// Return the sorted, unique values that are in both of the input arrays. +// Find the unique elements of an array. +// +// Returns the sorted unique elements of an array. There are three optional +// outputs in addition to the unique elements: +// +// * the indices of the input array that give the unique values +// * the indices of the unique array that reconstruct the input array +// * the number of times each unique value comes up in the input array // // Parameters // ---------- -// ar1, ar2 : array_like -// Input arrays. Will be flattened if not already 1D. -// assume_unique : bool -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. If True but ``ar1`` or ``ar2`` are not -// unique, incorrect results and out-of-bounds indices could result. -// Default is False. -// return_indices : bool -// If True, the indices which correspond to the intersection of the two -// arrays are returned. The first instance of a value is used if there are -// multiple. Default is False. +// ar : array_like +// Input array. Unless `axis` is specified, this will be flattened if it +// is not already 1-D. +// return_index : bool, optional +// If True, also return the indices of `ar` (along the specified axis, +// if provided, or in the flattened array) that result in the unique array. +// return_inverse : bool, optional +// If True, also return the indices of the unique array (for the specified +// axis, if provided) that can be used to reconstruct `ar`. +// return_counts : bool, optional +// If True, also return the number of times each unique item appears +// in `ar`. +// 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 +// as the elements of a 1-D array with the dimension of the given axis, +// see the notes for more details. Object arrays or structured arrays +// that contain objects are not supported if the `axis` kwarg is used. The +// default is None. +// +// .. 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 +// The sorted unique values. +// unique_indices : ndarray, optional +// The indices of the first occurrences of the unique values in the +// original array. Only provided if `return_index` is True. +// unique_inverse : ndarray, optional +// The indices to reconstruct the original array from the +// unique array. Only provided if `return_inverse` is True. +// unique_counts : ndarray, optional +// The number of times each of the unique values comes up in the +// original array. Only provided if `return_counts` is True. // -// Returns -// ------- -// intersect1d : ndarray -// Sorted 1D array of common and unique elements. -// comm1 : ndarray -// The indices of the first occurrences of the common values in `ar1`. -// Only provided if `return_indices` is True. -// comm2 : ndarray -// The indices of the first occurrences of the common values in `ar2`. -// Only provided if `return_indices` is True. +// .. versionadded:: 1.9.0 // -// Examples +// See Also // -------- -// >>> import numpy as np -// >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1]) -// array([1, 3]) -// -// To intersect more than two arrays, use functools.reduce: -// -// >>> from functools import reduce -// >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) -// array([3]) +// numpy.lib.arraysetops : Module with a number of other functions for +// performing set operations on arrays. +// repeat : Repeat elements of an array. // -// To return the indices of the values common to the input arrays -// along with the intersected values: +// Notes +// ----- +// When an axis is specified the subarrays indexed by the axis are sorted. +// This is done by making the specified axis the first dimension of the array +// (move the axis to the first dimension to keep the order of the other axes) +// and then flattening the subarrays in C order. The flattened subarrays are +// then viewed as a structured type with each element given a label, with the +// effect that we end up with a 1-D array of structured types that can be +// treated in the same way as any other 1-D array. The result is that the +// flattened subarrays are sorted in lexicographic order starting with the +// first element. // -// >>> x = np.array([1, 1, 2, 3, 4]) -// >>> y = np.array([2, 1, 4, 6]) -// >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True) -// >>> x_ind, y_ind -// (array([0, 2, 4]), array([1, 0, 2])) -// >>> xy, x[x_ind], y[y_ind] -// (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4])) +// .. versionchanged: NumPy 1.21 +// If nan values are in the input array, a single nan is put +// to the end of the sorted unique values. // +// Also for complex arrays all NaN values are considered equivalent +// (no matter whether the NaN is in the real or imaginary part). +// As the representant for the returned array the smallest one in the +// lexicographical order is chosen - see np.sort for how the lexicographical +// order is defined for complex arrays. // +// Examples +// -------- +// >>> np.unique([1, 1, 2, 2, 3, 3]) +// array([1, 2, 3]) +// >>> a = np.array([[1, 1], [2, 3]]) +// >>> np.unique(a) +// array([1, 2, 3]) // -//go:linkname Intersect1d py.intersect1d -func Intersect1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, returnIndices *py.Object) *py.Object +// Return the unique rows of a 2D array // -// Check whether or not an object can be iterated over. +// >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]]) +// >>> np.unique(a, axis=0) +// array([[1, 0, 0], [2, 3, 4]]) // -// Parameters -// ---------- -// y : object -// Input object. +// Return the indices of the original array that give the unique values: // -// Returns -// ------- -// b : bool -// Return ``True`` if the object has an iterator method or is a -// sequence and ``False`` otherwise. +// >>> a = np.array(['a', 'b', 'b', 'c', 'a']) +// >>> u, indices = np.unique(a, return_index=True) +// >>> u +// array(['a', 'b', 'c'], dtype='>> indices +// array([0, 1, 3]) +// >>> a[indices] +// array(['a', 'b', 'c'], dtype='>> import numpy as np -// >>> np.iterable([1, 2, 3]) -// True -// >>> np.iterable(2) -// False +// >>> a = np.array([1, 2, 6, 4, 2, 3, 2]) +// >>> u, indices = np.unique(a, return_inverse=True) +// >>> u +// array([1, 2, 3, 4, 6]) +// >>> indices +// array([0, 1, 4, 3, 1, 2, 1]) +// >>> u[indices] +// array([1, 2, 6, 4, 2, 3, 2]) // -// Notes -// ----- -// In most cases, the results of ``np.iterable(obj)`` are consistent with -// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is -// the treatment of 0-dimensional arrays:: +// Reconstruct the input values from the unique values and counts: // -// >>> from collections.abc import Iterable -// >>> a = np.array(1.0) # 0-dimensional numpy array -// >>> isinstance(a, Iterable) -// True -// >>> np.iterable(a) -// False +// >>> a = np.array([1, 2, 6, 4, 2, 3, 2]) +// >>> values, counts = np.unique(a, return_counts=True) +// >>> values +// array([1, 2, 3, 4, 6]) +// >>> counts +// array([1, 3, 1, 1, 1]) +// >>> np.repeat(values, counts) +// array([1, 2, 2, 2, 3, 4, 6]) # original order not preserved // // // -//go:linkname Iterable py.iterable -func Iterable(y *py.Object) *py.Object +//go:linkname Unique py.unique +func Unique(ar *py.Object, returnIndex *py.Object, returnInverse *py.Object, returnCounts *py.Object, axis *py.Object) *py.Object // -// unravel_index(indices, shape, order='C') +// Check for a complex type or an array of complex numbers. // -// Converts a flat index or array of flat indices into a tuple -// of coordinate arrays. +// The type of the input is checked, not the value. Even if the input +// has an imaginary part equal to zero, `iscomplexobj` evaluates to True. // // Parameters // ---------- -// indices : array_like -// An integer array whose elements are indices into the flattened -// version of an array of dimensions ``shape``. Before version 1.6.0, -// this function accepted just one index value. -// shape : tuple of ints -// The shape of the array to use for unraveling ``indices``. -// order : {'C', 'F'}, optional -// Determines whether the indices should be viewed as indexing in -// row-major (C-style) or column-major (Fortran-style) order. +// x : any +// The input can be of any type and shape. // // Returns // ------- -// unraveled_coords : tuple of ndarray -// Each array in the tuple has the same shape as the ``indices`` -// array. +// iscomplexobj : bool +// The return value, True if `x` is of a complex type or has at least +// one complex element. // // See Also // -------- -// ravel_multi_index +// isrealobj, iscomplex // // Examples // -------- -// >>> import numpy as np -// >>> np.unravel_index([22, 41, 37], (7,6)) -// (array([3, 6, 6]), array([4, 5, 1])) -// >>> np.unravel_index([31, 41, 13], (7,6), order='F') -// (array([3, 6, 6]), array([4, 5, 1])) -// -// >>> np.unravel_index(1621, (6,7,8,9)) -// (3, 1, 4, 1) -// -// -// -//go:linkname UnravelIndex py.unravel_index -func UnravelIndex(indices *py.Object, shape *py.Object, order *py.Object) *py.Object -// -// Load data from a text file, with missing values handled as specified. -// -// Each line past the first `skip_header` lines is split at the `delimiter` -// character, and characters following the `comments` character are discarded. +// >>> np.iscomplexobj(1) +// False +// >>> np.iscomplexobj(1+0j) +// True +// >>> np.iscomplexobj([3, 1+0j, True]) +// True // -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : dtype, optional -// Data type of the resulting array. -// If None, the dtypes will be determined by the contents of each -// column, individually. -// comments : str, optional -// The character used to indicate the start of a comment. -// All the characters occurring on a line after a comment are discarded. -// delimiter : str, int, or sequence, optional -// The string used to separate values. By default, any consecutive -// whitespaces act as delimiter. An integer or sequence of integers -// can also be provided as width(s) of each field. -// skiprows : int, optional -// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. -// skip_header : int, optional -// The number of lines to skip at the beginning of the file. -// skip_footer : int, optional -// The number of lines to skip at the end of the file. -// converters : variable, optional -// The set of functions that convert the data of a column to a value. -// The converters can also be used to provide a default value -// for missing data: ``converters = {3: lambda s: float(s or 0)}``. -// missing : variable, optional -// `missing` was removed in numpy 1.10. Please use `missing_values` -// instead. -// missing_values : variable, optional -// The set of strings corresponding to missing data. -// filling_values : variable, optional -// The set of values to be used as default when the data are missing. -// usecols : sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. -// names : {None, True, str, sequence}, optional -// If `names` is True, the field names are read from the first line after -// the first `skip_header` lines. This line can optionally be preceded -// by a comment delimiter. Any content before the comment delimiter is -// discarded. If `names` is a sequence or a single-string of -// comma-separated names, the names will be used to define the field -// names in a structured dtype. If `names` is None, the names of the -// dtype fields will be used, if any. -// excludelist : sequence, optional -// A list of names to exclude. This list is appended to the default list -// ['return','file','print']. Excluded names are appended with an -// underscore: for example, `file` would become `file_`. -// deletechars : str, optional -// A string combining invalid characters that must be deleted from the -// names. -// defaultfmt : str, optional -// A format used to define default field names, such as "f%i" or "f_%02i". -// autostrip : bool, optional -// Whether to automatically strip white spaces from the variables. -// replace_space : char, optional -// Character(s) used in replacement of white spaces in the variable -// names. By default, use a '_'. -// case_sensitive : {True, False, 'upper', 'lower'}, optional -// If True, field names are case sensitive. -// If False or 'upper', field names are converted to upper case. -// If 'lower', field names are converted to lower case. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = genfromtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// usemask : bool, optional -// If True, return a masked array. -// If False, return a regular array. -// loose : bool, optional -// If True, do not raise errors for invalid values. -// invalid_raise : bool, optional -// If True, an exception is raised if an inconsistency is detected in the -// number of columns. -// If False, a warning is emitted and the offending lines are skipped. -// max_rows : int, optional -// The maximum number of rows to read. Must not be used with skip_footer -// at the same time. If given, the value must be at least 1. Default is -// to read the entire file. -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply when `fname` -// is a file object. The special value 'bytes' enables backward -// compatibility workarounds that ensure that you receive byte arrays -// when possible and passes latin1 encoded strings to converters. -// Override this value to receive unicode arrays and pass strings -// as input to converters. If set to None the system default is used. -// The default value is 'bytes'. -// -// .. versionchanged:: 2.0 -// Before NumPy 2, the default was ``'bytes'`` for Python 2 -// compatibility. The default is now ``None``. // -// ndmin : int, optional -// Same parameter as `loadtxt` // -// .. versionadded:: 1.23.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +//go:linkname Iscomplexobj py.iscomplexobj +func Iscomplexobj(x *py.Object) *py.Object // -// .. versionadded:: 1.20.0 +// 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 +// `a`). +// +// Parameters +// ---------- +// a : array_like +// Input array. +// tol : float +// Tolerance in machine epsilons for the complex part of the elements +// in the array. If the tolerance is <=1, then the absolute tolerance +// is used. // // Returns // ------- // out : ndarray -// Data read from the text file. If `usemask` is True, this is a -// masked array. +// If `a` is real, the type of `a` is used for the output. If `a` +// has complex elements, the returned type is float. // // See Also // -------- -// numpy.loadtxt : equivalent function when no data is missing. +// real, imag, angle // // Notes // ----- -// * When spaces are used as delimiters, or when no delimiter has been given -// as input, there should not be any missing data between two fields. -// * When variables are named (either by a flexible dtype or with a `names` -// sequence), there must not be any header in the file (else a ValueError -// exception is raised). -// * Individual values are not stripped of spaces by default. -// When using a custom converter, make sure the function does remove spaces. -// * Custom converters may receive unexpected values due to dtype -// discovery. -// -// References -// ---------- -// .. [1] NumPy User Guide, section `I/O with NumPy -// `_. +// Machine epsilon varies from machine to machine and between data types +// but Python floats on most platforms have a machine epsilon equal to +// 2.2204460492503131e-16. You can use 'np.finfo(float).eps' to print +// out the machine epsilon for floats. // // Examples // -------- -// >>> from io import StringIO -// >>> import numpy as np -// -// Comma delimited file with mixed dtype -// -// >>> s = StringIO("1,1.3,abcde") -// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), -// ... ('mystring','S5')], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only -// >>> data = np.genfromtxt(s, dtype=None, -// ... names = ['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, 'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) -// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", -// ... names=['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> np.finfo(float).eps +// 2.2204460492503131e-16 # may vary // -// An example with fixed-width columns +// >>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000) +// array([2.1, 5.2]) +// >>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000) +// array([2.1+4.e-13j, 5.2 + 3e-15j]) // -// >>> s = StringIO("11.3abcde") -// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], -// ... delimiter=[1,3,5]) -// >>> data -// array((1, 1.3, 'abcde'), -// dtype=[('intvar', '>> f = StringIO(''' -// ... text,# of chars -// ... hello world,11 -// ... numpy,5''') -// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') -// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], -// dtype=[('f0', 'S12'), ('f1', 'S12')]) +//go:linkname RealIfClose py.real_if_close +func RealIfClose(a *py.Object, tol *py.Object) *py.Object // +// Split an array into multiple sub-arrays horizontally (column-wise). // +// Please refer to the `split` documentation. `hsplit` is equivalent +// to `split` with ``axis=1``, the array is always split along the second +// axis except for 1-D arrays, where it is split at ``axis=0``. // -//go:linkname Genfromtxt py.genfromtxt -func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object +// See Also +// -------- +// split : Split an array into multiple sub-arrays of equal size. // -// Load data from a text file. +// Examples +// -------- +// >>> x = np.arange(16.0).reshape(4, 4) +// >>> x +// array([[ 0., 1., 2., 3.], +// [ 4., 5., 6., 7.], +// [ 8., 9., 10., 11.], +// [12., 13., 14., 15.]]) +// >>> np.hsplit(x, 2) +// [array([[ 0., 1.], +// [ 4., 5.], +// [ 8., 9.], +// [12., 13.]]), +// array([[ 2., 3.], +// [ 6., 7.], +// [10., 11.], +// [14., 15.]])] +// >>> np.hsplit(x, np.array([3, 6])) +// [array([[ 0., 1., 2.], +// [ 4., 5., 6.], +// [ 8., 9., 10.], +// [12., 13., 14.]]), +// array([[ 3.], +// [ 7.], +// [11.], +// [15.]]), +// array([], shape=(4, 0), dtype=float64)] // -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : data-type, optional -// Data-type of the resulting array; default: float. If this is a -// structured data-type, the resulting array will be 1-dimensional, and -// 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 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 character used to separate the values. For backwards compatibility, -// byte strings will be decoded as 'latin1'. The default is whitespace. +// With a higher dimensional array the split is still along the second axis. // -// .. versionchanged:: 1.23.0 -// Only single character delimiters are supported. Newline characters -// cannot be used as the delimiter. +// >>> x = np.arange(8.0).reshape(2, 2, 2) +// >>> x +// array([[[0., 1.], +// [2., 3.]], +// [[4., 5.], +// [6., 7.]]]) +// >>> np.hsplit(x, 2) +// [array([[[0., 1.]], +// [[4., 5.]]]), +// array([[[2., 3.]], +// [[6., 7.]]])] // -// 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. +// With a 1-D array, the split is along axis 0. // -// .. versionchanged:: 1.23.0 -// The ability to pass a single callable to be applied to all columns -// was added. +// >>> x = np.array([0, 1, 2, 3, 4, 5]) +// >>> np.hsplit(x, 2) +// [array([0, 1, 2]), array([3, 4, 5])] // -// skiprows : int, optional -// Skip the first `skiprows` lines, including comments; default: 0. -// usecols : int or sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. -// The default, None, results in all columns being read. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = loadtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// ndmin : int, optional -// The returned array will have at least `ndmin` dimensions. -// Otherwise mono-dimensional axes will be squeezed. -// Legal values: 0 (default), 1 or 2. -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// The special value 'bytes' enables backward compatibility workarounds -// that ensures you receive byte arrays as results if possible and passes -// 'latin1' encoded strings to converters. Override this value to receive -// unicode arrays and pass strings as input to converters. If set to None -// the system default is used. The default value is None. // -// .. versionchanged:: 2.0 -// Before NumPy 2, the default was ``'bytes'`` for Python 2 -// compatibility. The default is now ``None``. // -// max_rows : int, optional -// 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`. +//go:linkname Hsplit py.hsplit +func Hsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object // -// .. 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. +// Return the cumulative product of array elements over a given axis treating Not a +// Numbers (NaNs) as one. The cumulative product does not change when NaNs are +// encountered and leading NaNs are replaced by ones. // -// If two consecutive instances of `quotechar` are found within a quoted -// field, the first is treated as an escape character. See examples. +// Ones are returned for slices that are all-NaN or empty. // -// .. versionadded:: 1.23.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// .. versionadded:: 1.12.0 // -// .. versionadded:: 1.20.0 +// Parameters +// ---------- +// a : array_like +// Input array. +// axis : int, optional +// Axis along which the cumulative product is computed. By default +// the input is flattened. +// dtype : dtype, optional +// Type of the returned array, as well as of the accumulator in which +// the elements are multiplied. If *dtype* is not specified, it +// defaults to the dtype of `a`, unless `a` has an integer dtype with +// a precision less than that of the default platform integer. In +// that case, the default platform integer is used instead. +// out : ndarray, optional +// Alternative output array in which to place the result. It must +// have the same shape and buffer length as the expected output +// but the type of the resulting values will be cast if necessary. // // Returns // ------- -// out : ndarray -// Data read from the text file. -// -// See Also -// -------- -// load, fromstring, fromregex -// genfromtxt : Load data with missing values handled as specified. -// scipy.io.loadmat : reads MATLAB data files -// -// Notes -// ----- -// This function aims to be a fast reader for simply formatted files. The -// `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`. +// nancumprod : ndarray +// A new array holding the result is returned unless `out` is +// specified, in which case it is returned. // -// The strings produced by the Python float.hex method can be used as -// input for floats. +// See Also +// -------- +// numpy.cumprod : Cumulative product across array propagating NaNs. +// isnan : Show which elements are NaN. // // Examples // -------- -// >>> import numpy as np -// >>> from io import StringIO # StringIO behaves like a file object -// >>> c = StringIO("0 1\n2 3") -// >>> np.loadtxt(c) -// array([[0., 1.], -// [2., 3.]]) -// -// >>> d = StringIO("M 21 72\nF 35 58") -// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), -// ... 'formats': ('S1', 'i4', 'f4')}) -// array([(b'M', 21, 72.), (b'F', 35, 58.)], -// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") -// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) -// >>> x -// array([1., 3.]) -// >>> 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.]]) +// >>> np.nancumprod(1) +// array([1]) +// >>> np.nancumprod([1]) +// array([1]) +// >>> np.nancumprod([1, np.nan]) +// array([1., 1.]) +// >>> a = np.array([[1, 2], [3, np.nan]]) +// >>> np.nancumprod(a) +// array([1., 2., 6., 6.]) +// >>> np.nancumprod(a, axis=0) +// array([[1., 2.], +// [3., 2.]]) +// >>> np.nancumprod(a, axis=1) +// array([[1., 2.], +// [3., 3.]]) // -// `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. +//go:linkname Nancumprod py.nancumprod +func Nancumprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object +// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// >>> s = StringIO("10.01 31.25-\n19.22 64.31\n17.57- 63.94") -// >>> def conv(fld): -// ... return -float(fld[:-1]) if fld.endswith("-") else float(fld) -// ... -// >>> np.loadtxt(s, converters=conv) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) +// Calculate the absolute value element-wise. // -// Using a callable as the converter can be particularly useful for handling -// values with different formatting, e.g. floats with underscores: +// ``np.abs`` is a shorthand for this function. // -// >>> s = StringIO("1 2.7 100_000") -// >>> np.loadtxt(s, converters=float) -// array([1.e+00, 2.7e+00, 1.e+05]) +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// This idea can be extended to automatically handle values specified in -// many different formats, such as hex values: +// Returns +// ------- +// absolute : ndarray +// An ndarray containing the absolute value of +// each element in `x`. For complex input, ``a + ib``, the +// absolute value is :math:`\sqrt{ a^2 + b^2 }`. +// This is a scalar if `x` is a scalar. // -// >>> 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) -// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) +// Examples +// -------- +// >>> x = np.array([-1.2, 1.2]) +// >>> np.absolute(x) +// array([ 1.2, 1.2]) +// >>> np.absolute(1.2 + 1j) +// 1.5620499351813308 // -// Or a format where the ``-`` sign comes after the number: +// Plot the function over ``[-10, 10]``: // -// >>> 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) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) +// >>> import matplotlib.pyplot as plt // -// 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`: +// >>> x = np.linspace(start=-10, stop=10, num=101) +// >>> plt.plot(x, np.absolute(x)) +// >>> plt.show() // -// >>> 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', '>> xx = x + 1j * x[:, np.newaxis] +// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') +// >>> plt.show() // -// >>> 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', '>> x = np.array([-1.2, 1.2]) +// >>> abs(x) +// array([1.2, 1.2]) // -// >>> 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.]]) +// The convolution operator is often seen in signal processing, where it +// models the effect of a linear time-invariant system on a signal [1]_. In +// probability theory, the sum of two independent random variables is +// distributed according to the convolution of their individual +// distributions. // +// If `v` is longer than `a`, the arrays are swapped before computation. // +// Parameters +// ---------- +// a : (N,) array_like +// First one-dimensional input array. +// v : (M,) array_like +// Second one-dimensional input array. +// mode : {'full', 'valid', 'same'}, optional +// 'full': +// By default, mode is 'full'. This returns the convolution +// at each point of overlap, with an output shape of (N+M-1,). At +// the end-points of the convolution, the signals do not overlap +// completely, and boundary effects may be seen. // -//go:linkname Loadtxt py.loadtxt -func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object +// 'same': +// Mode 'same' returns output of length ``max(M, N)``. Boundary +// effects are still visible. // -// Return the maximum of an array or maximum along an axis. +// 'valid': +// Mode 'valid' returns output of length +// ``max(M, N) - min(M, N) + 1``. The convolution product is only given +// for points where the signals overlap completely. Values outside +// the signal boundary have no effect. // -// `amax` is an alias of `~numpy.max`. +// Returns +// ------- +// out : ndarray +// Discrete, linear convolution of `a` and `v`. // // See Also // -------- -// max : alias of this function -// ndarray.max : equivalent method +// scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier +// Transform. +// scipy.linalg.toeplitz : Used to construct the convolution operator. +// polymul : Polynomial multiplication. Same output as convolve, but also +// accepts poly1d objects as input. // +// Notes +// ----- +// The discrete convolution operation is defined as // -//go:linkname Amax py.amax -func Amax(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -//go:linkname Log py.log -func Log(__llgo_va_list ...interface{}) *py.Object +// .. math:: (a * v)_n = \sum_{m = -\infty}^{\infty} a_m v_{n - m} // -// Put values into the destination array by matching 1d index and data slices. +// 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 +// domain, after appropriate padding (padding is necessary to prevent +// circular convolution). Since multiplication is more efficient (faster) +// than convolution, the function `scipy.signal.fftconvolve` exploits the +// FFT to calculate the convolution of large data-sets. // -// This iterates over matching 1d slices oriented along the specified axis in -// the index and data arrays, and uses the former to place values into the -// latter. These slices can be different lengths. +// References +// ---------- +// .. [1] Wikipedia, "Convolution", +// https://en.wikipedia.org/wiki/Convolution // -// Functions returning an index along an axis, like `argsort` and -// `argpartition`, produce suitable indices for this function. +// Examples +// -------- +// Note how the convolution operator flips the second array +// before "sliding" the two across one another: // -// Parameters -// ---------- -// arr : ndarray (Ni..., M, Nk...) -// Destination array. -// indices : ndarray (Ni..., J, Nk...) -// Indices to change along each 1d slice of `arr`. This must match the -// dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast -// against `arr`. -// values : array_like (Ni..., J, Nk...) -// values to insert at those indices. Its shape and dimension are -// broadcast to match that of `indices`. -// axis : int -// The axis to take 1d slices along. If axis is None, the destination -// array is treated as if a flattened 1d view had been created of it. +// >>> np.convolve([1, 2, 3], [0, 1, 0.5]) +// array([0. , 1. , 2.5, 4. , 1.5]) +// +// Only return the middle values of the convolution. +// Contains boundary effects, where zeros are taken +// into account: // -// Notes -// ----- -// This is equivalent to (but faster than) the following use of `ndindex` and -// `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: +// >>> np.convolve([1,2,3],[0,1,0.5], 'same') +// array([1. , 2.5, 4. ]) // -// Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] -// J = indices.shape[axis] # Need not equal M +// The two arrays are of the same length, so there +// is only one position where they completely overlap: // -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// a_1d = a [ii + s_[:,] + kk] -// indices_1d = indices[ii + s_[:,] + kk] -// values_1d = values [ii + s_[:,] + kk] -// for j in range(J): -// a_1d[indices_1d[j]] = values_1d[j] +// >>> np.convolve([1,2,3],[0,1,0.5], 'valid') +// array([2.5]) // -// Equivalently, eliminating the inner loop, the last two lines would be:: // -// a_1d[indices_1d] = values_1d // -// See Also -// -------- -// take_along_axis : -// Take values from the input array by matching 1d index and data slices +//go:linkname Convolve py.convolve +func Convolve(a *py.Object, v *py.Object, mode *py.Object) *py.Object +// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Examples -// -------- -// >>> import numpy as np +// Element-wise minimum of array elements. // -// For this sample array +// Compare two arrays and return a new array containing the element-wise +// minima. If one of the elements being compared is a NaN, then the +// non-nan element is returned. If both elements are NaNs then the first +// is returned. The latter distinction is important for complex NaNs, +// which are defined as at least one of the real or imaginary parts being +// a NaN. The net effect is that NaNs are ignored when possible. // -// >>> a = np.array([[10, 30, 20], [60, 40, 50]]) +// Parameters +// ---------- +// x1, x2 : array_like +// The arrays holding the elements to be compared. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// We can replace the maximum values with: +// Returns +// ------- +// y : ndarray or scalar +// The minimum of `x1` and `x2`, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. // -// >>> ai = np.argmax(a, axis=1, keepdims=True) -// >>> ai -// array([[1], -// [0]]) -// >>> np.put_along_axis(a, ai, 99, axis=1) -// >>> a -// array([[10, 99, 20], -// [99, 40, 50]]) +// See Also +// -------- +// fmax : +// Element-wise maximum of two arrays, ignores NaNs. +// minimum : +// Element-wise minimum of two arrays, propagates NaNs. +// amin : +// The minimum value of an array along a given axis, propagates NaNs. +// nanmin : +// The minimum value of an array along a given axis, ignores NaNs. // +// maximum, amax, nanmax // +// Notes +// ----- +// .. versionadded:: 1.3.0 // -//go:linkname PutAlongAxis py.put_along_axis -func PutAlongAxis(arr *py.Object, indices *py.Object, values *py.Object, axis *py.Object) *py.Object -// Broadcast an array to a new shape. +// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither +// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. // -// Parameters -// ---------- -// array : array_like -// The array to broadcast. -// shape : tuple or int -// The shape of the desired array. A single integer ``i`` is interpreted -// as ``(i,)``. -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise -// the returned array will be forced to be a base-class array (default). +// Examples +// -------- +// >>> np.fmin([2, 3, 4], [1, 5, 2]) +// array([1, 3, 2]) // -// Returns -// ------- -// broadcast : array -// A readonly view on the original array with the given shape. It is -// typically not contiguous. Furthermore, more than one element of a -// broadcasted array may refer to a single memory location. +// >>> np.fmin(np.eye(2), [0.5, 2]) +// array([[ 0.5, 0. ], +// [ 0. , 1. ]]) // -// Raises -// ------ -// ValueError -// If the array is not compatible with the new shape according to NumPy's -// broadcasting rules. +// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) +// array([ 0., 0., nan]) // -// See Also -// -------- -// broadcast -// broadcast_arrays -// broadcast_shapes +//go:linkname Fmin py.fmin +func Fmin(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Examples -// -------- -// >>> import numpy as np -// >>> x = np.array([1, 2, 3]) -// >>> np.broadcast_to(x, (3, 3)) -// array([[1, 2, 3], -// [1, 2, 3], -// [1, 2, 3]]) +// Returns x1 * 2**x2, element-wise. // +// The mantissas `x1` and twos exponents `x2` are used to construct +// floating point numbers ``x1 * 2**x2``. // -//go:linkname BroadcastTo py.broadcast_to -func BroadcastTo(array *py.Object, shape *py.Object, subok *py.Object) *py.Object +// Parameters +// ---------- +// x1 : array_like +// Array of multipliers. +// x2 : array_like, int +// Array of twos exponents. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// Return the indices for the upper-triangle of arr. +// Returns +// ------- +// y : ndarray or scalar +// The result of ``x1 * 2**x2``. +// This is a scalar if both `x1` and `x2` are scalars. // -// See `triu_indices` for full details. +// See Also +// -------- +// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. // -// Parameters -// ---------- -// arr : ndarray, shape(N, N) -// The indices will be valid for square arrays. -// k : int, optional -// Diagonal offset (see `triu` for details). +// Notes +// ----- +// Complex dtypes are not supported, they will raise a TypeError. // -// Returns -// ------- -// triu_indices_from : tuple, shape(2) of ndarray, shape(N) -// Indices for the upper-triangle of `arr`. +// `ldexp` is useful as the inverse of `frexp`, if used by itself it is +// more clear to simply use the expression ``x1 * 2**x2``. // -// Examples -// -------- -// >>> import numpy as np +// Examples +// -------- +// >>> np.ldexp(5, np.arange(4)) +// array([ 5., 10., 20., 40.], dtype=float16) // -// Create a 4 by 4 array +// >>> x = np.arange(6) +// >>> np.ldexp(*np.frexp(x)) +// array([ 0., 1., 2., 3., 4., 5.]) // -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) +//go:linkname Ldexp py.ldexp +func Ldexp(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// Pass the array to get the indices of the upper triangular elements. +// Compute the truth value of NOT x element-wise. // -// >>> triui = np.triu_indices_from(a) -// >>> triui -// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) +// Parameters +// ---------- +// x : array_like +// Logical NOT is applied to the elements of `x`. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// >>> a[triui] -// array([ 0, 1, 2, 3, 5, 6, 7, 10, 11, 15]) +// Returns +// ------- +// y : bool or ndarray of bool +// Boolean result with the same shape as `x` of the NOT operation +// on elements of `x`. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// logical_and, logical_or, logical_xor +// +// Examples +// -------- +// >>> np.logical_not(3) +// False +// >>> np.logical_not([True, False, 0, 1]) +// array([False, True, True, False]) +// +// >>> x = np.arange(5) +// >>> np.logical_not(x<3) +// array([False, False, False, True, True]) // -// This is syntactic sugar for triu_indices(). +//go:linkname LogicalNot py.logical_not +func LogicalNot(x *py.Object, out *py.Object) *py.Object +// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// >>> np.triu_indices(a.shape[0]) -// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) +// Return the fractional and integral parts of an array, element-wise. // -// Use the `k` parameter to return the indices for the upper triangular array -// from the k-th diagonal. +// The fractional and integral parts are negative if the given number is +// negative. // -// >>> triuim1 = np.triu_indices_from(a, k=1) -// >>> a[triuim1] -// array([ 1, 2, 3, 6, 7, 11]) +// Parameters +// ---------- +// x : array_like +// Input array. +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // +// Returns +// ------- +// y1 : ndarray +// Fractional part of `x`. +// This is a scalar if `x` is a scalar. +// y2 : ndarray +// Integral part of `x`. +// This is a scalar if `x` is a scalar. // -// See Also -// -------- -// triu_indices, triu, tril_indices_from +// Notes +// ----- +// For integer input the return values are floats. // +// See Also +// -------- +// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values +// switched, except it always has a positive remainder. // -//go:linkname TriuIndicesFrom py.triu_indices_from -func TriuIndicesFrom(arr *py.Object, k *py.Object) *py.Object +// Examples +// -------- +// >>> np.modf([0, 3.5]) +// (array([ 0. , 0.5]), array([ 0., 3.])) +// >>> np.modf(-0.5) +// (-0.5, -0) // -// Return True if x is a not complex type or an array of complex numbers. +//go:linkname Modf py.modf +func Modf(x *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object // -// The type of the input is checked, not the value. So even if the input -// has an imaginary part equal to zero, `isrealobj` evaluates to False -// if the data type is complex. +// Format a floating-point scalar as a decimal string in scientific notation. +// +// Provides control over rounding, trimming and padding. Uses and assumes +// IEEE unbiased rounding. Uses the "Dragon4" algorithm. // // Parameters // ---------- -// x : any -// The input can be of any type and shape. +// x : python float or numpy floating scalar +// Value to format. +// precision : non-negative integer or None, optional +// Maximum number of digits to print. May be None if `unique` is +// `True`, but must be an integer if unique is `False`. +// unique : boolean, optional +// If `True`, use a digit-generation strategy which gives the shortest +// representation which uniquely identifies the floating-point number from +// other values of the same type, by judicious rounding. If `precision` +// is given fewer digits than necessary can be printed. If `min_digits` +// is given more can be printed, in which cases the last digit is rounded +// with unbiased rounding. +// If `False`, digits are generated as if printing an infinite-precision +// value and stopping after `precision` digits, rounding the remaining +// value with unbiased rounding +// trim : one of 'k', '.', '0', '-', optional +// Controls post-processing trimming of trailing digits, as follows: +// +// * 'k' : keep trailing zeros, keep decimal point (no trimming) +// * '.' : trim all trailing zeros, leave decimal point +// * '0' : trim all but the zero before the decimal point. Insert the +// zero if it is missing. +// * '-' : trim trailing zeros and any trailing decimal point +// sign : boolean, optional +// Whether to show the sign for positive values. +// pad_left : non-negative integer, optional +// Pad the left side of the string with whitespace until at least that +// many characters are to the left of the decimal point. +// exp_digits : non-negative integer, optional +// Pad the exponent with zeros until it contains at least this many digits. +// If omitted, the exponent will be at least 2 digits. +// min_digits : non-negative integer or None, optional +// Minimum number of digits to print. This only has an effect for +// `unique=True`. In that case more digits than necessary to uniquely +// identify the value may be printed and rounded unbiased. +// +// -- versionadded:: 1.21.0 // // Returns // ------- -// y : bool -// The return value, False if `x` is of a complex type. +// rep : string +// The string representation of the floating point value // // See Also // -------- -// iscomplexobj, isreal -// -// Notes -// ----- -// The function is only meant for arrays with numerical values but it -// accepts all other objects. Since it assumes array input, the return -// value of other objects may be True. -// -// >>> np.isrealobj('A string') -// True -// >>> np.isrealobj(False) -// True -// >>> np.isrealobj(None) -// True +// format_float_positional // // Examples // -------- -// >>> import numpy as np -// >>> np.isrealobj(1) -// True -// >>> np.isrealobj(1+0j) -// False -// >>> np.isrealobj([3, 1+0j, True]) -// False +// >>> np.format_float_scientific(np.float32(np.pi)) +// '3.1415927e+00' +// >>> s = np.float32(1.23e24) +// >>> np.format_float_scientific(s, unique=False, precision=15) +// '1.230000071797338e+24' +// >>> np.format_float_scientific(s, exp_digits=4) +// '1.23e+0024' // // +//go:linkname FormatFloatScientific py.format_float_scientific +func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object // -//go:linkname Isrealobj py.isrealobj -func Isrealobj(x *py.Object) *py.Object +// Compute the qth percentile of the data along the specified axis, +// while ignoring nan values. // -// Return the character for the minimum-size type to which given types can -// be safely cast. +// Returns the qth percentile(s) of the array elements. // -// The returned type character must represent the smallest size dtype such -// that an array of the returned type can handle the data from an array of -// all types in `typechars` (or if `typechars` is an array, then its -// dtype.char). +// .. versionadded:: 1.9.0 // // Parameters // ---------- -// typechars : list of str or array_like -// If a list of strings, each string should represent a dtype. -// If array_like, the character representation of the array dtype is used. -// typeset : str or list of str, optional -// The set of characters that the returned character is chosen from. -// The default set is 'GDFgdf'. -// default : str, optional -// The default character, this is returned if none of the characters in -// `typechars` matches a character in `typeset`. -// -// Returns -// ------- -// typechar : str -// The character representing the minimum-size type that was found. +// a : array_like +// Input array or object that can be converted to an array, containing +// nan values to be ignored. +// q : array_like of float +// Percentile or sequence of percentiles to compute, which must be +// between 0 and 100 inclusive. +// axis : {int, tuple of int, None}, optional +// Axis or axes along which the percentiles are computed. The default +// is to compute the percentile(s) along a flattened version of the +// array. +// out : ndarray, optional +// Alternative output array in which to place the result. It must have +// the same shape and buffer length as the expected output, but the +// type (of the output) will be cast if necessary. +// overwrite_input : bool, optional +// If True, then allow the input array `a` to be modified by +// intermediate calculations, to save memory. In this case, the +// contents of the input `a` after this function completes is +// undefined. +// method : str, optional +// This parameter specifies the method to use for estimating the +// percentile. There are many different methods, some unique to NumPy. +// See the notes for explanation. The options sorted by their R type +// as summarized in the H&F paper [1]_ are: // -// See Also -// -------- -// dtype +// 1. 'inverted_cdf' +// 2. 'averaged_inverted_cdf' +// 3. 'closest_observation' +// 4. 'interpolated_inverted_cdf' +// 5. 'hazen' +// 6. 'weibull' +// 7. 'linear' (default) +// 8. 'median_unbiased' +// 9. 'normal_unbiased' // -// Examples -// -------- -// >>> import numpy as np -// >>> np.mintypecode(['d', 'f', 'S']) -// 'd' -// >>> x = np.array([1.1, 2-3.j]) -// >>> np.mintypecode(x) -// 'D' +// The first three methods are discontinuous. NumPy further defines the +// following discontinuous variations of the default 'linear' (7.) option: // -// >>> np.mintypecode('abceh', default='G') -// 'G' +// * 'lower' +// * 'higher', +// * 'midpoint' +// * 'nearest' // +// .. versionchanged:: 1.22.0 +// This argument was previously called "interpolation" and only +// offered the "linear" default and last four options. // +// 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 array `a`. // -//go:linkname Mintypecode py.mintypecode -func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *py.Object) *py.Object +// If this is anything but the default value it will be passed +// through (in the special case of an empty array) to the +// `mean` function of the underlying array. If the array is +// a sub-class and `mean` does not have the kwarg `keepdims` this +// will raise a RuntimeError. // -// Test element-wise for positive infinity, return result as bool array. +// interpolation : str, optional +// Deprecated name for the method keyword argument. // -// Parameters -// ---------- -// x : array_like -// The input array. -// out : array_like, optional -// A location into which the result is stored. If provided, it must have a -// shape that the input broadcasts to. If not provided or None, a -// freshly-allocated boolean array is returned. +// .. deprecated:: 1.22.0 // // Returns // ------- -// out : ndarray -// A boolean array with the same dimensions as the input. -// If second argument is not supplied then a boolean array is returned -// with values True where the corresponding element of the input is -// positive infinity and values False where the element of the input is -// not positive infinity. -// -// If a second argument is supplied the result is stored there. If the -// type of that array is a numeric type the result is represented as zeros -// and ones, if the type is boolean then as False and True. -// The return value `out` is then a reference to that array. +// percentile : scalar or ndarray +// If `q` is a single percentile and `axis=None`, then the result +// is a scalar. If multiple percentiles are given, first axis of +// the result corresponds to the percentiles. The other axes are +// the axes that remain after the reduction of `a`. If the input +// contains integers or floats smaller than ``float64``, the output +// data-type is ``float64``. Otherwise, the output data-type is the +// same as that of the input. If `out` is specified, that array is +// returned instead. // // See Also // -------- -// isinf, isneginf, isfinite, isnan +// nanmean +// nanmedian : equivalent to ``nanpercentile(..., 50)`` +// percentile, median, mean +// nanquantile : equivalent to nanpercentile, except q in range [0, 1]. // // Notes // ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). -// -// Errors result if the second argument is also supplied when x is a scalar -// input, if first and second arguments have different shapes, or if the -// first argument has complex values +// For more information please see `numpy.percentile` // // Examples // -------- -// >>> import numpy as np -// >>> np.isposinf(np.inf) -// True -// >>> np.isposinf(-np.inf) -// False -// >>> np.isposinf([-np.inf, 0., np.inf]) -// array([False, False, True]) +// >>> a = np.array([[10., 7., 4.], [3., 2., 1.]]) +// >>> a[0][1] = np.nan +// >>> a +// array([[10., nan, 4.], +// [ 3., 2., 1.]]) +// >>> np.percentile(a, 50) +// nan +// >>> np.nanpercentile(a, 50) +// 3.0 +// >>> np.nanpercentile(a, 50, axis=0) +// array([6.5, 2. , 2.5]) +// >>> np.nanpercentile(a, 50, axis=1, keepdims=True) +// array([[7.], +// [2.]]) +// >>> m = np.nanpercentile(a, 50, axis=0) +// >>> out = np.zeros_like(m) +// >>> np.nanpercentile(a, 50, axis=0, out=out) +// array([6.5, 2. , 2.5]) +// >>> m +// array([6.5, 2. , 2.5]) // -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isposinf(x, y) -// array([0, 0, 1]) -// >>> y -// array([0, 0, 1]) +// >>> b = a.copy() +// >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True) +// array([7., 2.]) +// >>> assert not np.all(a==b) +// +// References +// ---------- +// .. [1] R. J. Hyndman and Y. Fan, +// "Sample quantiles in statistical packages," +// The American Statistician, 50(4), pp. 361-365, 1996 // // // -//go:linkname Isposinf py.isposinf -func Isposinf(x *py.Object, out *py.Object) *py.Object +//go:linkname Nanpercentile py.nanpercentile +func Nanpercentile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object // -// Find the indices of array elements that are non-zero, grouped by element. +// Stack arrays in sequence horizontally (column wise). +// +// This is equivalent to concatenation along the second axis, except for 1-D +// arrays where it concatenates along the first axis. Rebuilds arrays divided +// by `hsplit`. +// +// This function makes most sense for arrays with up to 3 dimensions. For +// instance, for pixel-data with a height (first axis), width (second axis), +// and r/g/b channels (third axis). The functions `concatenate`, `stack` and +// `block` provide more general stacking and concatenation operations. // // Parameters // ---------- -// a : array_like -// Input data. +// tup : sequence of ndarrays +// 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 // ------- -// index_array : (N, a.ndim) ndarray -// Indices of elements that are non-zero. Indices are grouped by element. -// This array will have shape ``(N, a.ndim)`` where ``N`` is the number of -// non-zero items. +// stacked : ndarray +// The array formed by stacking the given arrays. // // See Also // -------- -// where, nonzero -// -// Notes -// ----- -// ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``, -// but produces a result of the correct shape for a 0D array. -// -// The output of ``argwhere`` is not suitable for indexing arrays. -// For this purpose use ``nonzero(a)`` instead. +// concatenate : Join a sequence of arrays along an existing axis. +// stack : Join a sequence of arrays along a new axis. +// block : Assemble an nd-array from nested lists of blocks. +// vstack : Stack arrays in sequence vertically (row wise). +// dstack : Stack arrays in sequence depth wise (along third axis). +// column_stack : Stack 1-D arrays as columns into a 2-D array. +// hsplit : Split an array into multiple sub-arrays horizontally (column-wise). // // Examples // -------- -// >>> import numpy as np -// >>> x = np.arange(6).reshape(2,3) -// >>> x -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.argwhere(x>1) -// array([[0, 2], -// [1, 0], -// [1, 1], -// [1, 2]]) -// -// -// -//go:linkname Argwhere py.argwhere -func Argwhere(a *py.Object) *py.Object -//go:linkname Log2 py.log2 -func Log2(__llgo_va_list ...interface{}) *py.Object -// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Multiply arguments element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays to be multiplied. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The product of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. +// >>> a = np.array((1,2,3)) +// >>> b = np.array((4,5,6)) +// >>> np.hstack((a,b)) +// array([1, 2, 3, 4, 5, 6]) +// >>> a = np.array([[1],[2],[3]]) +// >>> b = np.array([[4],[5],[6]]) +// >>> np.hstack((a,b)) +// array([[1, 4], +// [2, 5], +// [3, 6]]) // -// Notes -// ----- -// Equivalent to `x1` * `x2` in terms of array broadcasting. // -// Examples -// -------- -// >>> import numpy as np -// >>> np.multiply(2.0, 4.0) -// 8.0 // -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.multiply(x1, x2) -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) +//go:linkname Hstack py.hstack +func Hstack(tup *py.Object) *py.Object // -// The ``*`` operator can be used as a shorthand for ``np.multiply`` on -// ndarrays. +// Split an array into multiple sub-arrays as views into `ary`. // -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 * x2 -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) +// Parameters +// ---------- +// ary : ndarray +// Array to be divided into sub-arrays. +// indices_or_sections : int or 1-D array +// If `indices_or_sections` is an integer, N, the array will be divided +// into N equal arrays along `axis`. If such a split is not possible, +// an error is raised. // -//go:linkname Multiply py.multiply -func Multiply(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// If `indices_or_sections` is a 1-D array of sorted integers, the entries +// indicate where along `axis` the array is split. For example, +// ``[2, 3]`` would, for ``axis=0``, result in // -// Return the indices to access the main diagonal of an array. +// - ary[:2] +// - ary[2:3] +// - ary[3:] // -// This returns a tuple of indices that can be used to access the main -// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape -// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for -// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` -// for ``i = [0..n-1]``. +// If an index exceeds the dimension of the array along `axis`, +// an empty sub-array is returned correspondingly. +// axis : int, optional +// The axis along which to split, default is 0. // -// Parameters -// ---------- -// n : int -// The size, along each dimension, of the arrays for which the returned -// indices can be used. +// Returns +// ------- +// sub-arrays : list of ndarrays +// A list of sub-arrays as views into `ary`. // -// ndim : int, optional -// The number of dimensions. +// Raises +// ------ +// ValueError +// If `indices_or_sections` is given as an integer, but +// a split does not result in equal division. // // See Also // -------- -// diag_indices_from +// array_split : Split an array into multiple sub-arrays of equal or +// near-equal size. Does not raise an exception if +// an equal division cannot be made. +// hsplit : Split array into multiple sub-arrays horizontally (column-wise). +// vsplit : Split array into multiple sub-arrays vertically (row wise). +// dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). +// concatenate : Join a sequence of arrays along an existing axis. +// stack : Join a sequence of arrays along a new axis. +// hstack : Stack arrays in sequence horizontally (column wise). +// vstack : Stack arrays in sequence vertically (row wise). +// dstack : Stack arrays in sequence depth wise (along third dimension). // // Examples // -------- -// >>> import numpy as np -// -// Create a set of indices to access the diagonal of a (4, 4) array: -// -// >>> di = np.diag_indices(4) -// >>> di -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// >>> a[di] = 100 -// >>> a -// array([[100, 1, 2, 3], -// [ 4, 100, 6, 7], -// [ 8, 9, 100, 11], -// [ 12, 13, 14, 100]]) +// >>> x = np.arange(9.0) +// >>> np.split(x, 3) +// [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])] // -// Now, we create indices to manipulate a 3-D array: +// >>> x = np.arange(8.0) +// >>> np.split(x, [3, 5, 6, 10]) +// [array([0., 1., 2.]), +// array([3., 4.]), +// array([5.]), +// array([6., 7.]), +// array([], dtype=float64)] // -// >>> d3 = np.diag_indices(2, 3) -// >>> d3 -// (array([0, 1]), array([0, 1]), array([0, 1])) // -// And use it to set the diagonal of an array of zeros to 1: // -// >>> a = np.zeros((2, 2, 2), dtype=int) -// >>> a[d3] = 1 -// >>> a -// array([[[1, 0], -// [0, 0]], -// [[0, 0], -// [0, 1]]]) +//go:linkname Split py.split +func Split(ary *py.Object, indicesOrSections *py.Object, axis *py.Object) *py.Object // +// Apply a function to 1-D slices along the given axis. // +// Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays +// and `a` is a 1-D slice of `arr` along `axis`. // -//go:linkname DiagIndices py.diag_indices -func DiagIndices(n *py.Object, ndim *py.Object) *py.Object +// This is equivalent to (but faster than) the following use of `ndindex` and +// `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices:: // -// Stack arrays in sequence depth wise (along third axis). +// Ni, Nk = a.shape[:axis], a.shape[axis+1:] +// for ii in ndindex(Ni): +// for kk in ndindex(Nk): +// f = func1d(arr[ii + s_[:,] + kk]) +// Nj = f.shape +// for jj in ndindex(Nj): +// out[ii + jj + kk] = f[jj] // -// This is equivalent to concatenation along the third axis after 2-D arrays -// of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape -// `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by -// `dsplit`. +// Equivalently, eliminating the inner loop, this can be expressed as:: // -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// and r/g/b channels (third axis). The functions `concatenate`, `stack` and -// `block` provide more general stacking and concatenation operations. +// Ni, Nk = a.shape[:axis], a.shape[axis+1:] +// for ii in ndindex(Ni): +// for kk in ndindex(Nk): +// out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk]) // // Parameters // ---------- -// tup : sequence of arrays -// The arrays must have the same shape along all but the third axis. -// 1-D or 2-D arrays must have the same shape. +// func1d : function (M,) -> (Nj...) +// This function should accept 1-D arrays. It is applied to 1-D +// slices of `arr` along the specified axis. +// axis : integer +// Axis along which `arr` is sliced. +// arr : ndarray (Ni..., M, Nk...) +// Input array. +// args : any +// Additional arguments to `func1d`. +// kwargs : any +// Additional named arguments to `func1d`. +// +// .. versionadded:: 1.9.0 +// // // Returns // ------- -// stacked : ndarray -// The array formed by stacking the given arrays, will be at least 3-D. +// out : ndarray (Ni..., Nj..., Nk...) +// The output array. The shape of `out` is identical to the shape of +// `arr`, except along the `axis` dimension. This axis is removed, and +// replaced with new dimensions equal to the shape of the return value +// of `func1d`. So if `func1d` returns a scalar `out` will have one +// fewer dimensions than `arr`. // // See Also // -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// vstack : Stack arrays in sequence vertically (row wise). -// hstack : Stack arrays in sequence horizontally (column wise). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// dsplit : Split array along third axis. +// apply_over_axes : Apply a function repeatedly over multiple axes. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array((1,2,3)) -// >>> b = np.array((2,3,4)) -// >>> np.dstack((a,b)) -// array([[[1, 2], -// [2, 3], -// [3, 4]]]) -// -// >>> a = np.array([[1],[2],[3]]) -// >>> b = np.array([[2],[3],[4]]) -// >>> np.dstack((a,b)) -// array([[[1, 2]], -// [[2, 3]], -// [[3, 4]]]) +// >>> def my_func(a): +// ... """Average first and last element of a 1-D array""" +// ... return (a[0] + a[-1]) * 0.5 +// >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) +// >>> np.apply_along_axis(my_func, 0, b) +// array([4., 5., 6.]) +// >>> np.apply_along_axis(my_func, 1, b) +// array([2., 5., 8.]) // +// For a function that returns a 1D array, the number of dimensions in +// `outarr` is the same as `arr`. // +// >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]]) +// >>> np.apply_along_axis(sorted, 1, b) +// array([[1, 7, 8], +// [3, 4, 9], +// [2, 5, 6]]) // -//go:linkname Dstack py.dstack -func Dstack(tup *py.Object) *py.Object +// For a function that returns a higher dimensional array, those dimensions +// are inserted in place of the `axis` dimension. // -// Construct an array by repeating A the number of times given by reps. +// >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) +// >>> np.apply_along_axis(np.diag, -1, b) +// array([[[1, 0, 0], +// [0, 2, 0], +// [0, 0, 3]], +// [[4, 0, 0], +// [0, 5, 0], +// [0, 0, 6]], +// [[7, 0, 0], +// [0, 8, 0], +// [0, 0, 9]]]) // -// If `reps` has length ``d``, the result will have dimension of -// ``max(d, A.ndim)``. // -// If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new -// axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, -// or shape (1, 1, 3) for 3-D replication. If this is not the desired -// behavior, promote `A` to d-dimensions manually before calling this -// function. +//go:linkname ApplyAlongAxis py.apply_along_axis +func ApplyAlongAxis(func1d *py.Object, axis *py.Object, arr *py.Object, __llgo_va_list ...interface{}) *py.Object // -// If ``A.ndim > d``, `reps` is promoted to `A`.ndim by prepending 1's to it. -// Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as -// (1, 1, 2, 2). +// Do a keyword search on docstrings. // -// Note : Although tile may be used for broadcasting, it is strongly -// recommended to use numpy's broadcasting operations and functions. +// A list of objects that matched the search is displayed, +// sorted by relevance. All given keywords need to be found in the +// docstring for it to be returned as a result, but the order does +// not matter. // // Parameters // ---------- -// A : array_like -// The input array. -// reps : array_like -// The number of repetitions of `A` along each axis. -// -// Returns -// ------- -// c : ndarray -// The tiled output array. +// what : str +// String containing words to look for. +// module : str or list, optional +// Name of module(s) whose docstrings to go through. +// import_modules : bool, optional +// Whether to import sub-modules in packages. Default is True. +// regenerate : bool, optional +// Whether to re-generate the docstring cache. Default is False. +// output : file-like, optional +// File-like object to write the output to. If omitted, use a pager. // // See Also // -------- -// repeat : Repeat elements of an array. -// broadcast_to : Broadcast an array to a new shape +// source, info +// +// Notes +// ----- +// Relevance is determined only roughly, by checking if the keywords occur +// in the function name, at the start of a docstring, etc. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([0, 1, 2]) -// >>> np.tile(a, 2) -// array([0, 1, 2, 0, 1, 2]) -// >>> np.tile(a, (2, 2)) -// array([[0, 1, 2, 0, 1, 2], -// [0, 1, 2, 0, 1, 2]]) -// >>> np.tile(a, (2, 1, 2)) -// array([[[0, 1, 2, 0, 1, 2]], -// [[0, 1, 2, 0, 1, 2]]]) +// >>> np.lookfor('binary representation') # doctest: +SKIP +// Search results for 'binary representation' +// ------------------------------------------ +// numpy.binary_repr +// Return the binary representation of the input number as a string. +// numpy.core.setup_common.long_double_representation +// Given a binary dump as given by GNU od -b, look for long double +// numpy.base_repr +// Return a string representation of a number in the given base system. +// ... // -// >>> b = np.array([[1, 2], [3, 4]]) -// >>> np.tile(b, 2) -// array([[1, 2, 1, 2], -// [3, 4, 3, 4]]) -// >>> np.tile(b, (2, 1)) -// array([[1, 2], -// [3, 4], -// [1, 2], -// [3, 4]]) // -// >>> c = np.array([1,2,3,4]) -// >>> np.tile(c,(4,1)) -// array([[1, 2, 3, 4], -// [1, 2, 3, 4], -// [1, 2, 3, 4], -// [1, 2, 3, 4]]) // +//go:linkname Lookfor py.lookfor +func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object // -//go:linkname Tile py.tile -func Tile(A *py.Object, reps *py.Object) *py.Object +// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. // -// Return the indices for the lower-triangle of an (n, m) array. +// .. warning:: Loading files that contain object arrays uses the ``pickle`` +// module, which is not secure against erroneous or maliciously +// constructed data. Consider passing ``allow_pickle=False`` to +// load data that is known not to contain object arrays for the +// safer handling of untrusted sources. // // Parameters // ---------- -// n : int -// The row dimension of the arrays for which the returned -// indices will be valid. -// k : int, optional -// Diagonal offset (see `tril` for details). -// m : int, optional -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. +// file : file-like object, string, or pathlib.Path +// The file to read. File-like objects must support 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 +// `numpy.memmap` for a detailed description of the modes). A +// memory-mapped array is kept on disk. However, it can be accessed +// and sliced like any ndarray. Memory mapping is especially useful +// for accessing small fragments of large files without reading the +// entire file into memory. +// allow_pickle : bool, optional +// Allow loading pickled object arrays stored in npy files. Reasons for +// disallowing pickles include security, as loading pickled data can +// execute arbitrary code. If pickles are disallowed, loading object +// arrays will fail. Default: False +// +// .. versionchanged:: 1.16.3 +// Made default False in response to CVE-2019-6446. +// +// fix_imports : bool, optional +// Only useful when loading Python 2 generated pickled files on Python 3, +// which includes npy/npz files containing object arrays. If `fix_imports` +// is True, pickle will try to map the old Python 2 names to the new names +// used in Python 3. +// encoding : str, optional +// What encoding to use when reading Python 2 strings. Only useful when +// loading Python 2 generated pickled files in Python 3, which includes +// 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:func:`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 +// ------- +// result : array, tuple, dict, etc. +// Data stored in the file. For ``.npz`` files, the returned instance +// of NpzFile class must be closed to avoid leaking file descriptors. +// +// Raises +// ------ +// OSError +// If the input file does not exist or cannot be read. +// UnpicklingError +// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. +// ValueError +// The file contains an object array, but ``allow_pickle=False`` given. +// EOFError +// When calling ``np.load`` multiple times on the same file handle, +// if all data has already been read +// +// See Also +// -------- +// save, savez, savez_compressed, loadtxt +// memmap : Create a memory-map to an array stored in a file on disk. +// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. // +// Notes +// ----- +// - If the file contains pickle data, then whatever object is stored +// in the pickle is returned. +// - If the file is a ``.npy`` file, then a single array is returned. +// - If the file is a ``.npz`` file, then a dictionary-like object is +// returned, containing ``{filename: array}`` key-value pairs, one for +// each file in the archive. +// - If the file is a ``.npz`` file, the returned value supports the +// context manager protocol in a similar fashion to the open function:: // -// Returns -// ------- -// inds : tuple of arrays -// The row and column indices, respectively. The row indices are sorted -// in non-decreasing order, and the correspdonding column indices are -// strictly increasing for each row. +// with load('foo.npz') as data: +// a = data['a'] // -// See also -// -------- -// triu_indices : similar function, for upper-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// tril, triu +// The underlying file descriptor is closed when exiting the 'with' +// block. // // Examples // -------- -// >>> import numpy as np +// Store data to disk, and load it again: // -// Compute two different sets of indices to access 4x4 arrays, one for the -// lower triangular part starting at the main diagonal, and one starting two -// diagonals further right: +// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) +// >>> np.load('/tmp/123.npy') +// array([[1, 2, 3], +// [4, 5, 6]]) // -// >>> il1 = np.tril_indices(4) -// >>> il1 -// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) +// Store compressed data to disk, and load it again: // -// Note that row indices (first array) are non-decreasing, and the corresponding -// column indices (second array) are strictly increasing for each row. -// Here is how they can be used with a sample array: +// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) +// >>> b=np.array([1, 2]) +// >>> np.savez('/tmp/123.npz', a=a, b=b) +// >>> data = np.load('/tmp/123.npz') +// >>> data['a'] +// array([[1, 2, 3], +// [4, 5, 6]]) +// >>> data['b'] +// array([1, 2]) +// >>> data.close() // -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) +// Mem-map the stored array, and then access the second row +// directly from disk: // -// Both for indexing: +// >>> X = np.load('/tmp/123.npy', mmap_mode='r') +// >>> X[1, :] +// memmap([4, 5, 6]) // -// >>> a[il1] -// array([ 0, 4, 5, ..., 13, 14, 15]) // -// And for assigning values: // -// >>> a[il1] = -1 -// >>> a -// array([[-1, 1, 2, 3], -// [-1, -1, 6, 7], -// [-1, -1, -1, 11], -// [-1, -1, -1, -1]]) +//go:linkname Load py.load +func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object // -// These cover almost the whole array (two diagonals right of the main one): +// Compute the histogram of a dataset. // -// >>> il2 = np.tril_indices(4, 2) -// >>> a[il2] = -10 -// >>> a -// array([[-10, -10, -10, 3], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10]]) +// Parameters +// ---------- +// a : array_like +// Input data. The histogram is computed over the flattened array. +// bins : int or sequence of scalars or str, optional +// If `bins` is an int, it defines the number of equal-width +// bins in the given range (10, by default). If `bins` is a +// sequence, it defines a monotonically increasing array of bin edges, +// including the rightmost edge, allowing for non-uniform bin widths. // +// .. versionadded:: 1.11.0 // +// If `bins` is a string, it defines the method used to calculate the +// optimal bin width, as defined by `histogram_bin_edges`. // -//go:linkname TrilIndices py.tril_indices -func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object +// range : (float, float), optional +// The lower and upper range of the bins. If not provided, range +// is simply ``(a.min(), a.max())``. Values outside the range are +// ignored. The first element of the range must be less than or +// equal to the second. `range` affects the automatic bin +// 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. +// 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 +// (instead of 1). If `density` is True, the weights are +// normalized, so that the integral of the density over the range +// remains 1. +// density : bool, optional +// If ``False``, the result will contain the number of samples in +// each bin. If ``True``, the result is the value of the +// probability *density* function at the bin, normalized such that +// the *integral* over the range is 1. Note that the sum of the +// histogram values will not be equal to 1 unless bins of unity +// width are chosen; it is not a probability *mass* function. // -// Get help information for an array, function, class, or module. +// Returns +// ------- +// hist : array +// The values of the histogram. See `density` and `weights` for a +// description of the possible semantics. +// bin_edges : array of dtype float +// Return the bin edges ``(length(hist)+1)``. // -// Parameters -// ---------- -// object : object or str, optional -// Input object or name to get information about. If `object` is -// an `ndarray` instance, information about the array is printed. -// If `object` is a numpy object, its docstring is given. If it is -// a string, available modules are searched for matching objects. -// If None, information about `info` itself is returned. -// maxwidth : int, optional -// Printing width. -// output : file like object, optional -// File like object that the output is written to, default is -// ``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. +// +// See Also +// -------- +// histogramdd, bincount, searchsorted, digitize, histogram_bin_edges // // Notes // ----- -// When used interactively with an object, ``np.info(obj)`` is equivalent -// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython -// prompt. +// All but the last (righthand-most) bin is half-open. In other words, +// if `bins` is:: +// +// [1, 2, 3, 4] +// +// then the first bin is ``[1, 2)`` (including 1, but excluding 2) and +// the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which +// *includes* 4. +// // // Examples // -------- -// >>> np.info(np.polyval) # doctest: +SKIP -// polyval(p, x) -// Evaluate the polynomial p at x. -// ... +// >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3]) +// (array([0, 2, 1]), array([0, 1, 2, 3])) +// >>> np.histogram(np.arange(4), bins=np.arange(5), density=True) +// (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4])) +// >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3]) +// (array([1, 4, 1]), array([0, 1, 2, 3])) // -// When using a string for `object` it is possible to get multiple results. +// >>> a = np.arange(5) +// >>> hist, bin_edges = np.histogram(a, density=True) +// >>> hist +// array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5]) +// >>> hist.sum() +// 2.4999999999999996 +// >>> np.sum(hist * np.diff(bin_edges)) +// 1.0 // -// >>> np.info('fft') # doctest: +SKIP -// *** Found in numpy *** -// Core FFT routines -// ... -// *** Found in numpy.fft *** -// fft(a, n=None, axis=-1) -// ... -// *** Repeat reference found in numpy.fft.fftpack *** -// *** Total of 3 references found. *** +// .. versionadded:: 1.11.0 // -// When the argument is an array, information about the array is printed. +// Automated Bin Selection Methods example, using 2 peak random data +// with 2000 points: // -// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) -// >>> np.info(a) -// class: ndarray -// shape: (2, 3) -// strides: (24, 8) -// itemsize: 8 -// aligned: True -// contiguous: True -// fortran: False -// data pointer: 0x562b6e0d2860 # may vary -// byteorder: little -// byteswap: False -// type: complex64 +// >>> import matplotlib.pyplot as plt +// >>> rng = np.random.RandomState(10) # deterministic random data +// >>> a = np.hstack((rng.normal(size=1000), +// ... rng.normal(loc=5, scale=2, size=1000))) +// >>> _ = plt.hist(a, bins='auto') # arguments are passed to np.histogram +// >>> plt.title("Histogram with 'auto' bins") +// Text(0.5, 1.0, "Histogram with 'auto' bins") +// >>> plt.show() // // // -//go:linkname Info py.info -func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object +//go:linkname Histogram py.histogram +func Histogram(a *py.Object, bins *py.Object, Range *py.Object, density *py.Object, weights *py.Object) *py.Object // -// Returns an array with axes transposed. +// Roll array elements along a given axis. // -// 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.atleast_2d(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]``. +// Elements that roll beyond the last position are re-introduced at +// the first. // // 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`. Negative -// indices can also be used to specify axes. 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. +// shift : int or tuple of ints +// The number of places by which elements are shifted. If a tuple, +// then `axis` must be a tuple of the same size, and each of the +// given axes is shifted by the corresponding number. If an int +// while `axis` is a tuple of ints, then the same value is used for +// all given axes. +// axis : int or tuple of ints, optional +// Axis or axes along which elements are shifted. By default, the +// array is flattened before shifting, after which the original +// shape is restored. // // Returns // ------- -// p : ndarray -// `a` with its axes permuted. A view is returned whenever possible. +// res : ndarray +// Output array, with the same shape as `a`. // // See Also // -------- -// ndarray.transpose : Equivalent method. -// moveaxis : Move axes of an array to new positions. -// argsort : Return the indices that would sort an array. +// rollaxis : Roll the specified axis backwards, until it lies in a +// given position. // // Notes // ----- -// Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors -// when using the `axes` keyword argument. +// .. versionadded:: 1.12.0 +// +// Supports rolling over multiple dimensions simultaneously. // // Examples // -------- -// >>> import numpy as np -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> a -// array([[1, 2], -// [3, 4]]) -// >>> np.transpose(a) -// array([[1, 3], -// [2, 4]]) -// -// >>> a = np.array([1, 2, 3, 4]) -// >>> a -// array([1, 2, 3, 4]) -// >>> np.transpose(a) -// array([1, 2, 3, 4]) -// -// >>> a = np.ones((1, 2, 3)) -// >>> np.transpose(a, (1, 0, 2)).shape -// (2, 1, 3) +// >>> x = np.arange(10) +// >>> np.roll(x, 2) +// array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) +// >>> np.roll(x, -2) +// array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]) // -// >>> a = np.ones((2, 3, 4, 5)) -// >>> np.transpose(a).shape -// (5, 4, 3, 2) +// >>> x2 = np.reshape(x, (2, 5)) +// >>> x2 +// array([[0, 1, 2, 3, 4], +// [5, 6, 7, 8, 9]]) +// >>> np.roll(x2, 1) +// array([[9, 0, 1, 2, 3], +// [4, 5, 6, 7, 8]]) +// >>> np.roll(x2, -1) +// array([[1, 2, 3, 4, 5], +// [6, 7, 8, 9, 0]]) +// >>> np.roll(x2, 1, axis=0) +// array([[5, 6, 7, 8, 9], +// [0, 1, 2, 3, 4]]) +// >>> np.roll(x2, -1, axis=0) +// array([[5, 6, 7, 8, 9], +// [0, 1, 2, 3, 4]]) +// >>> np.roll(x2, 1, axis=1) +// array([[4, 0, 1, 2, 3], +// [9, 5, 6, 7, 8]]) +// >>> np.roll(x2, -1, axis=1) +// array([[1, 2, 3, 4, 0], +// [6, 7, 8, 9, 5]]) +// >>> np.roll(x2, (1, 1), axis=(1, 0)) +// array([[9, 5, 6, 7, 8], +// [4, 0, 1, 2, 3]]) +// >>> np.roll(x2, (2, 1), axis=(1, 0)) +// array([[8, 9, 5, 6, 7], +// [3, 4, 0, 1, 2]]) // -// >>> a = np.arange(3*4*5).reshape((3, 4, 5)) -// >>> np.transpose(a, (-1, 0, -2)).shape -// (5, 3, 4) // // +//go:linkname Roll py.roll +func Roll(a *py.Object, shift *py.Object, axis *py.Object) *py.Object +// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -//go:linkname PermuteDims py.permute_dims -func PermuteDims(a *py.Object, axes *py.Object) *py.Object -// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// Compute the bit-wise XOR of two arrays element-wise. // -// Return the element-wise square of the input. +// Computes the bit-wise XOR of the underlying binary representation of +// the integers in the input arrays. This ufunc implements the C/Python +// operator ``^``. // // Parameters // ---------- -// x : array_like -// Input data. +// x1, x2 : array_like +// Only integer and boolean types are handled. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). // out : ndarray, None, or tuple of ndarray and None, optional // A location into which the result is stored. If provided, it must have // a shape that the inputs broadcast to. If not provided or None, @@ -27079,474 +26544,545 @@ func PermuteDims(a *py.Object, axes *py.Object) *py.Object // Returns // ------- // out : ndarray or scalar -// Element-wise `x*x`, of the same shape and dtype as `x`. -// This is a scalar if `x` is a scalar. +// Result. +// This is a scalar if both `x1` and `x2` are scalars. // // See Also // -------- -// numpy.linalg.matrix_power -// sqrt -// power +// logical_xor +// bitwise_and +// bitwise_or +// binary_repr : +// Return the binary representation of the input number as a string. // // Examples // -------- -// >>> import numpy as np -// >>> np.square([-1j, 1]) -// array([-1.-0.j, 1.+0.j]) +// The number 13 is represented by ``00001101``. Likewise, 17 is +// represented by ``00010001``. The bit-wise XOR of 13 and 17 is +// therefore ``00011100``, or 28: // -//go:linkname Square py.square -func Square(x *py.Object, out *py.Object) *py.Object +// >>> np.bitwise_xor(13, 17) +// 28 +// >>> np.binary_repr(28) +// '11100' // -// Return an array copy of the given object. +// >>> np.bitwise_xor(31, 5) +// 26 +// >>> np.bitwise_xor([31,3], 5) +// array([26, 6]) // -// Parameters -// ---------- -// a : array_like -// Input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Controls the memory layout of the copy. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. (Note that this function and :meth:`ndarray.copy` are very -// similar, but have different default values for their order= -// arguments.) -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise the -// returned array will be forced to be a base-class array (defaults to False). +// >>> np.bitwise_xor([31,3], [5,6]) +// array([26, 5]) +// >>> np.bitwise_xor([True, True], [False, True]) +// array([ True, False]) // -// Returns -// ------- -// arr : ndarray -// Array interpretation of `a`. +// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on +// ndarrays. // -// See Also -// -------- -// ndarray.copy : Preferred method for creating an array copy +// >>> x1 = np.array([True, True]) +// >>> x2 = np.array([False, True]) +// >>> x1 ^ x2 +// array([ True, False]) // -// Notes -// ----- -// This is equivalent to: +//go:linkname BitwiseXor py.bitwise_xor +func BitwiseXor(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // -// >>> np.array(a, copy=True) #doctest: +SKIP +// Divide arguments element-wise. +// +// Parameters +// ---------- +// x1 : array_like +// Dividend array. +// x2 : array_like +// Divisor array. +// If ``x1.shape != x2.shape``, they must be broadcastable to a common +// shape (which becomes the shape of the output). +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// The copy made of the data is shallow, i.e., for arrays with object dtype, -// the new array will point to the same objects. -// See Examples from `ndarray.copy`. +// Returns +// ------- +// y : ndarray or scalar +// The quotient ``x1/x2``, element-wise. +// This is a scalar if both `x1` and `x2` are scalars. // -// Examples -// -------- -// >>> import numpy as np +// See Also +// -------- +// seterr : Set whether to raise or warn on overflow, underflow and +// division by zero. // -// Create an array x, with a reference y and a copy z: +// Notes +// ----- +// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. // -// >>> x = np.array([1, 2, 3]) -// >>> y = x -// >>> z = np.copy(x) +// The ``true_divide(x1, x2)`` function is an alias for +// ``divide(x1, x2)``. // -// Note that, when we modify x, y changes, but not z: +// Examples +// -------- +// >>> np.divide(2.0, 4.0) +// 0.5 +// >>> 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. ]]) // -// >>> x[0] = 10 -// >>> x[0] == y[0] -// True -// >>> x[0] == z[0] -// False +// The ``/`` operator can be used as a shorthand for ``np.divide`` on +// ndarrays. // -// Note that, np.copy clears previously set WRITEABLE=False flag. +// >>> x1 = np.arange(9.0).reshape((3, 3)) +// >>> x2 = 2 * np.ones(3) +// >>> x1 / x2 +// array([[0. , 0.5, 1. ], +// [1.5, 2. , 2.5], +// [3. , 3.5, 4. ]]) // -// >>> a = np.array([1, 2, 3]) -// >>> a.flags["WRITEABLE"] = False -// >>> b = np.copy(a) -// >>> b.flags["WRITEABLE"] -// True -// >>> b[0] = 3 -// >>> b -// array([3, 2, 3]) +//go:linkname Divide py.divide +func Divide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object +// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // +// Test element-wise for positive or negative infinity. // -//go:linkname Copy py.copy -func Copy(a *py.Object, order *py.Object, subok *py.Object) *py.Object +// Returns a boolean array of the same shape as `x`, True where ``x == +// +/-inf``, otherwise False. // -// Unwrap by taking the complement of large deltas with respect to the period. +// Parameters +// ---------- +// x : array_like +// Input values +// out : ndarray, None, or tuple of ndarray and None, optional +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// where : array_like, optional +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// **kwargs +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. // -// This unwraps a signal `p` by changing elements which have an absolute -// difference from their predecessor of more than ``max(discont, period/2)`` -// to their `period`-complementary values. +// Returns +// ------- +// y : bool (scalar) or boolean ndarray +// True where ``x`` is positive or negative infinity, false otherwise. +// This is a scalar if `x` is a scalar. +// +// See Also +// -------- +// isneginf, isposinf, isnan, isfinite +// +// Notes +// ----- +// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic +// (IEEE 754). +// +// Errors result if the second argument is supplied when the first +// argument is a scalar, or if the first and second arguments have +// different shapes. +// +// Examples +// -------- +// >>> np.isinf(np.inf) +// True +// >>> np.isinf(np.nan) +// False +// >>> np.isinf(np.NINF) +// True +// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) +// array([ True, True, False, False]) +// +// >>> x = np.array([-np.inf, 0., np.inf]) +// >>> y = np.array([2, 2, 2]) +// >>> np.isinf(x, y) +// array([1, 0, 1]) +// >>> y +// array([1, 0, 1]) // -// For the default case where `period` is :math:`2\pi` and `discont` is -// :math:`\pi`, this unwraps a radian phase `p` such that adjacent differences -// are never greater than :math:`\pi` by adding :math:`2k\pi` for some -// integer :math:`k`. +//go:linkname Isinf py.isinf +func Isinf(x *py.Object, out *py.Object) *py.Object +// +// Determines whether the given object represents a scalar data-type. // // Parameters // ---------- -// p : array_like -// Input array. -// discont : float, optional -// Maximum discontinuity between values, default is ``period/2``. -// Values below ``period/2`` are treated as if they were ``period/2``. -// To have an effect different from the default, `discont` should be -// larger than ``period/2``. -// axis : int, optional -// Axis along which unwrap will operate, default is the last axis. -// period : float, optional -// Size of the range over which the input wraps. By default, it is -// ``2 pi``. -// -// .. versionadded:: 1.21.0 +// rep : any +// If `rep` is an instance of a scalar dtype, True is returned. If not, +// False is returned. // // Returns // ------- -// out : ndarray -// Output array. +// out : bool +// Boolean result of check whether `rep` is a scalar dtype. // // See Also // -------- -// rad2deg, deg2rad -// -// Notes -// ----- -// If the discontinuity in `p` is smaller than ``period/2``, -// but larger than `discont`, no unwrapping is done because taking -// the complement would only make the discontinuity larger. +// issubsctype, issubdtype, obj2sctype, sctype2char // // Examples // -------- -// >>> import numpy as np -// >>> phase = np.linspace(0, np.pi, num=5) -// >>> phase[3:] += np.pi -// >>> phase -// array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) # may vary -// >>> np.unwrap(phase) -// array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) # may vary -// >>> np.unwrap([0, 1, 2, -1, 0], period=4) -// array([0, 1, 2, 3, 4]) -// >>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6) -// array([1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4) -// array([2, 3, 4, 5, 6, 7, 8, 9]) -// >>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180 -// >>> np.unwrap(phase_deg, period=360) -// array([-180., -140., -100., -60., -20., 20., 60., 100., 140., -// 180., 220., 260., 300., 340., 380., 420., 460., 500., -// 540.]) +// >>> np.issctype(np.int32) +// True +// >>> np.issctype(list) +// False +// >>> np.issctype(1.1) +// False // +// Strings are also a scalar type: // -//go:linkname Unwrap py.unwrap -func Unwrap(p *py.Object, discont *py.Object, axis *py.Object) *py.Object +// >>> np.issctype(np.dtype('str')) +// True // -// Save an array to a binary file in NumPy ``.npy`` format. +// +// +//go:linkname Issctype py.issctype +func Issctype(rep *py.Object) *py.Object +// +// 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 // ---------- -// file : file, str, or pathlib.Path -// File or filename to which the data is saved. If file is a file-object, -// then the filename is unchanged. If file is a string or Path, -// a ``.npy`` extension will be appended to the filename if it does not -// already have one. -// arr : array_like -// Array data to be saved. -// allow_pickle : bool, optional -// Allow saving object arrays using Python pickles. Reasons for -// disallowing pickles include security (loading pickled data can execute -// arbitrary code) and portability (pickled objects may not be loadable -// on different Python installations, for example if the stored objects -// require libraries that are not available, and not all pickled data is -// compatible between different versions of Python). -// Default: True -// fix_imports : bool, optional -// The `fix_imports` flag is deprecated and has no effect. +// a : array_like +// Array to be sorted. // -// .. deprecated:: 2.1 -// This flag is ignored since NumPy 1.17 and was only needed to -// support loading in Python 2 some files written in Python 3. +// Returns +// ------- +// sorted_array : ndarray +// Array of the same type and shape as `a`. // // See Also // -------- -// savez : Save several arrays into a ``.npz`` archive -// savetxt, load +// sort // // Notes // ----- -// For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`. -// -// Any data saved to the file is appended to the end of the file. +// ``np.msort(a)`` is equivalent to ``np.sort(a, axis=0)``. // // Examples // -------- -// >>> import numpy as np -// -// >>> from tempfile import TemporaryFile -// >>> outfile = TemporaryFile() -// -// >>> x = np.arange(10) -// >>> np.save(outfile, x) -// -// >>> _ = outfile.seek(0) # Only needed to simulate closing & reopening file -// >>> np.load(outfile) -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// -// >>> with open('test.npy', 'wb') as f: -// ... np.save(f, np.array([1, 2])) -// ... np.save(f, np.array([1, 3])) -// >>> with open('test.npy', 'rb') as f: -// ... a = np.load(f) -// ... b = np.load(f) -// >>> print(a, b) -// # [1 2] [1 3] -// -// -//go:linkname Save py.save -func Save(__llgo_va_list ...interface{}) *py.Object +// >>> a = np.array([[1, 4], [3, 1]]) +// >>> np.msort(a) # sort along the first axis +// array([[1, 1], +// [3, 4]]) // -// Find the product of two polynomials. // -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. // -// Finds the polynomial resulting from the multiplication of the two input -// polynomials. Each input must be either a poly1d object or a 1D sequence -// of polynomial coefficients, from highest to lowest degree. +//go:linkname Msort py.msort +func Msort(a *py.Object) *py.Object // -// Parameters -// ---------- -// a1, a2 : array_like or poly1d object -// Input polynomials. +// Split array into multiple sub-arrays along the 3rd axis (depth). // -// Returns -// ------- -// out : ndarray or poly1d object -// The polynomial resulting from the multiplication of the inputs. If -// either inputs is a poly1d object, then the output is also a poly1d -// object. Otherwise, it is a 1D array of polynomial coefficients from -// highest to lowest degree. +// Please refer to the `split` documentation. `dsplit` is equivalent +// to `split` with ``axis=2``, the array is always split along the third +// axis provided the array dimension is greater than or equal to 3. // // See Also // -------- -// poly1d : A one-dimensional polynomial class. -// poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval -// convolve : Array convolution. Same output as polymul, but has parameter -// for overlap mode. +// split : Split an array into multiple sub-arrays of equal size. // // Examples // -------- -// >>> import numpy as np -// >>> np.polymul([1, 2, 3], [9, 5, 1]) -// array([ 9, 23, 38, 17, 3]) +// >>> x = np.arange(16.0).reshape(2, 2, 4) +// >>> x +// array([[[ 0., 1., 2., 3.], +// [ 4., 5., 6., 7.]], +// [[ 8., 9., 10., 11.], +// [12., 13., 14., 15.]]]) +// >>> np.dsplit(x, 2) +// [array([[[ 0., 1.], +// [ 4., 5.]], +// [[ 8., 9.], +// [12., 13.]]]), array([[[ 2., 3.], +// [ 6., 7.]], +// [[10., 11.], +// [14., 15.]]])] +// >>> np.dsplit(x, np.array([3, 6])) +// [array([[[ 0., 1., 2.], +// [ 4., 5., 6.]], +// [[ 8., 9., 10.], +// [12., 13., 14.]]]), +// array([[[ 3.], +// [ 7.]], +// [[11.], +// [15.]]]), +// array([], shape=(2, 2, 0), dtype=float64)] // -// Using poly1d objects: // -// >>> p1 = np.poly1d([1, 2, 3]) -// >>> p2 = np.poly1d([9, 5, 1]) -// >>> print(p1) -// 2 -// 1 x + 2 x + 3 -// >>> print(p2) -// 2 -// 9 x + 5 x + 1 -// >>> print(np.polymul(p1, p2)) -// 4 3 2 -// 9 x + 23 x + 38 x + 17 x + 3 +//go:linkname Dsplit py.dsplit +func Dsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object // +// Load data from a text file. // +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// dtype : data-type, optional +// Data-type of the resulting array; default: float. If this is a +// structured data-type, the resulting array will be 1-dimensional, and +// 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 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 character used to separate the values. For backwards compatibility, +// byte strings will be decoded as 'latin1'. The default is whitespace. // -//go:linkname Polymul py.polymul -func Polymul(a1 *py.Object, a2 *py.Object) *py.Object +// .. versionchanged:: 1.23.0 +// Only single character delimiters are supported. Newline characters +// cannot be used as the delimiter. // -// Return the real part of the complex argument. +// 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. // -// Parameters -// ---------- -// val : array_like -// Input array. +// .. versionchanged:: 1.23.0 +// The ability to pass a single callable to be applied to all columns +// was added. // -// Returns -// ------- -// out : ndarray or scalar -// The real component of the complex argument. If `val` is real, the type -// of `val` is used for the output. If `val` has complex elements, the -// returned type is float. +// skiprows : int, optional +// Skip the first `skiprows` lines, including comments; default: 0. +// usecols : int or sequence, optional +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. +// The default, None, results in all columns being read. // -// See Also -// -------- -// real_if_close, imag, angle +// .. versionchanged:: 1.11.0 +// When a single column has to be read it is possible to use +// an integer instead of a tuple. E.g ``usecols = 3`` reads the +// fourth column the same way as ``usecols = (3,)`` would. +// unpack : bool, optional +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = loadtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// ndmin : int, optional +// The returned array will have at least `ndmin` dimensions. +// Otherwise mono-dimensional axes will be squeezed. +// Legal values: 0 (default), 1 or 2. // -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.array([1+2j, 3+4j, 5+6j]) -// >>> a.real -// array([1., 3., 5.]) -// >>> a.real = 9 -// >>> a -// array([9.+2.j, 9.+4.j, 9.+6.j]) -// >>> a.real = np.array([9, 8, 7]) -// >>> a -// array([9.+2.j, 8.+4.j, 7.+6.j]) -// >>> np.real(1 + 1j) -// 1.0 +// .. versionadded:: 1.6.0 +// encoding : str, optional +// Encoding used to decode the inputfile. Does not apply to input streams. +// The special value 'bytes' enables backward compatibility workarounds +// that ensures you receive byte arrays as results if possible and passes +// 'latin1' encoded strings to converters. Override this value to receive +// unicode arrays and pass strings as input to converters. If set to None +// the system default is used. The default value is 'bytes'. // +// .. versionadded:: 1.14.0 +// max_rows : int, optional +// 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 // -//go:linkname Real py.real -func Real(val *py.Object) *py.Object +// .. 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. // -// Build a matrix object from a string, nested sequence, or array. +// If two consecutive instances of `quotechar` are found within a quoted +// field, the first is treated as an escape character. See examples. // -// Parameters -// ---------- -// obj : str or array_like -// Input data. If a string, variables in the current scope may be -// referenced by name. -// ldict : dict, optional -// A dictionary that replaces local operands in current frame. -// Ignored if `obj` is not a string or `gdict` is None. -// gdict : dict, optional -// A dictionary that replaces global operands in current frame. -// Ignored if `obj` is not a string. +// .. versionadded:: 1.23.0 +// 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 +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 // // Returns // ------- -// out : matrix -// Returns a matrix object, which is a specialized 2-D array. +// out : ndarray +// Data read from the text file. // // See Also // -------- -// block : -// A generalization of this function for N-d arrays, that returns normal -// ndarrays. +// load, fromstring, fromregex +// genfromtxt : Load data with missing values handled as specified. +// scipy.io.loadmat : reads MATLAB data files +// +// Notes +// ----- +// This function aims to be a fast reader for simply formatted files. The +// `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 +// input for floats. // // Examples // -------- -// >>> import numpy as np -// >>> A = np.asmatrix('1 1; 1 1') -// >>> B = np.asmatrix('2 2; 2 2') -// >>> C = np.asmatrix('3 4; 5 6') -// >>> D = np.asmatrix('7 8; 9 0') +// >>> from io import StringIO # StringIO behaves like a file object +// >>> c = StringIO("0 1\n2 3") +// >>> np.loadtxt(c) +// array([[0., 1.], +// [2., 3.]]) // -// All the following expressions construct the same block matrix: +// >>> d = StringIO("M 21 72\nF 35 58") +// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), +// ... 'formats': ('S1', 'i4', 'f4')}) +// array([(b'M', 21, 72.), (b'F', 35, 58.)], +// dtype=[('gender', 'S1'), ('age', '>> np.bmat([[A, B], [C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat('A,B; C,D') -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) +// >>> c = StringIO("1,0,2\n3,0,4") +// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) +// >>> x +// array([1., 3.]) +// >>> 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.]]) // -//go:linkname Bmat py.bmat -func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) +// `converters` can be a callable instead of a dictionary, in which case it +// is applied to all columns: // -// Return the complex conjugate, element-wise. +// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") +// >>> import functools +// >>> conv = functools.partial(int, base=16) +// >>> np.loadtxt(s, converters=conv) +// array([[222., 173.], +// [192., 222.]]) // -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. +// This example shows how `converters` can be used to convert a field +// with a trailing minus sign into a negative number. // -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> def conv(fld): +// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) +// ... +// >>> np.loadtxt(s, converters=conv) +// array([[ 10.01, -31.25], +// [ 19.22, 64.31], +// [-17.57, 63.94]]) // -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. +// Using a callable as the converter can be particularly useful for handling +// values with different formatting, e.g. floats with underscores: // -// Notes -// ----- -// `conj` is an alias for `conjugate`: +// >>> s = StringIO("1 2.7 100_000") +// >>> np.loadtxt(s, converters=float) +// array([1.e+00, 2.7e+00, 1.e+05]) // -// >>> np.conj is np.conjugate -// True +// This idea can be extended to automatically handle values specified in +// many different formats: // -// Examples -// -------- -// >>> import numpy as np -// >>> np.conjugate(1+2j) -// (1-2j) +// >>> 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]) // -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) +// 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`` // -//go:linkname Conjugate py.conjugate -func Conjugate(x *py.Object, out *py.Object) *py.Object +// >>> 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]]) // -// An array with ones at and below the given diagonal and zeros elsewhere. +// 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`: // -// Parameters -// ---------- -// N : int -// Number of rows in the array. -// M : int, optional -// Number of columns in the array. -// By default, `M` is taken equal to `N`. -// k : int, optional -// The sub-diagonal at and below which the array is filled. -// `k` = 0 is the main diagonal, while `k` < 0 is below it, -// and `k` > 0 is above. The default is 0. -// dtype : dtype, optional -// Data type of the returned array. The default is float. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. +// >>> 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', '>> 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', '>> import numpy as np -// >>> np.tri(3, 5, 2, dtype=int) -// array([[1, 1, 1, 0, 0], -// [1, 1, 1, 1, 0], -// [1, 1, 1, 1, 1]]) +// Two consecutive quote characters within a quoted field are treated as a +// single escaped character: // -// >>> np.tri(3, 5, -1) -// array([[0., 0., 0., 0., 0.], -// [1., 0., 0., 0., 0.], -// [1., 1., 0., 0., 0.]]) +// >>> 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.]]) // // // -//go:linkname Tri py.tri -func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object +//go:linkname Loadtxt py.loadtxt +func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object From cb6b0ee24851ea602d205693bb4797a316cf5a4a Mon Sep 17 00:00:00 2001 From: PengPengPeng717 <872462877.com> Date: Fri, 22 Aug 2025 16:48:42 +0800 Subject: [PATCH 3/5] fenzhi --- .github/workflows/verification.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/verification.yml b/.github/workflows/verification.yml index 9eeffa79..c4281d65 100644 --- a/.github/workflows/verification.yml +++ b/.github/workflows/verification.yml @@ -40,7 +40,7 @@ jobs: with: repository: 'toaction/llpyg' path: .llpyg - ref: presentation + ref: feat/v1 - name: Set up Go uses: actions/setup-go@v4 with: From 3c81bc37587588a691dbc8ff42ae75479f298673 Mon Sep 17 00:00:00 2001 From: PengPengPeng717 <872462877.com> Date: Fri, 22 Aug 2025 17:12:26 +0800 Subject: [PATCH 4/5] ver --- .github/workflows/verification.yml | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/.github/workflows/verification.yml b/.github/workflows/verification.yml index c4281d65..edcc3ea5 100644 --- a/.github/workflows/verification.yml +++ b/.github/workflows/verification.yml @@ -47,7 +47,15 @@ jobs: go-version: 1.24.x - name: Set up Tool run: | - go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@8_21 + git clone https://github.com/PengPengPeng717/llpkgstore.git + cd llpkgstore + git checkout 8_21 + # 临时修改 go.mod 中的模块路径 + sed -i 's|module github.com/goplus/llpkgstore|module github.com/PengPengPeng717/llpkgstore|' go.mod + go install -v ./cmd/llpkgstore + # - name: Set up Tool + # run: | + # go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@8_21 - name: Install dependencies if: startsWith(matrix.os, 'macos') run: | From fa5c6fb56bcd675f0d9da9d04cdfab54c014aba0 Mon Sep 17 00:00:00 2001 From: PengPengPeng717 <872462877.com> Date: Fri, 22 Aug 2025 17:13:44 +0800 Subject: [PATCH 5/5] 11 --- numpy/_demo/basic_test/main.go | 27 - numpy/go.mod | 5 - numpy/go.sum | 2 - numpy/llpkg.cfg | 15 - numpy/llpyg.cfg | 7 - numpy/numpy.go | 27088 ------------------------------- 6 files changed, 27144 deletions(-) delete mode 100644 numpy/_demo/basic_test/main.go delete mode 100644 numpy/go.mod delete mode 100644 numpy/go.sum delete mode 100644 numpy/llpkg.cfg delete mode 100644 numpy/llpyg.cfg delete mode 100644 numpy/numpy.go diff --git a/numpy/_demo/basic_test/main.go b/numpy/_demo/basic_test/main.go deleted file mode 100644 index c70be070..00000000 --- a/numpy/_demo/basic_test/main.go +++ /dev/null @@ -1,27 +0,0 @@ -package main - -import ( - "fmt" - - "numpy" - - "github.com/goplus/lib/py" - "github.com/goplus/lib/py/std" -) - -func main() { - fmt.Println("=== NumPy Basic Test Demo ===") - - // 测试1: 创建数组 - fmt.Println("\n1. 创建数组测试:") - - // 创建一个简单的数组 - arr1 := py.List(1.0, 2.0, 3.0, 4.0, 5.0) - arr2 := py.List(2.0, 4.0, 6.0, 8.0, 10.0) - - // 使用numpy进行数组运算 - arr3 := numpy.Add(arr1, arr2) - std.Print(py.Str("result:"), arr3) - - fmt.Println("\n=== 测试完成 ===") -} diff --git a/numpy/go.mod b/numpy/go.mod deleted file mode 100644 index fc2aaa3c..00000000 --- a/numpy/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module numpy - -go 1.24.5 - -require github.com/goplus/lib v0.2.0 diff --git a/numpy/go.sum b/numpy/go.sum deleted file mode 100644 index 512980a5..00000000 --- a/numpy/go.sum +++ /dev/null @@ -1,2 +0,0 @@ -github.com/goplus/lib v0.2.0 h1:AjqkN1XK5H23wZMMlpaUYAMCDAdSBQ2NMFrLtSh7W4g= -github.com/goplus/lib v0.2.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0= diff --git a/numpy/llpkg.cfg b/numpy/llpkg.cfg deleted file mode 100644 index fba1a7cf..00000000 --- a/numpy/llpkg.cfg +++ /dev/null @@ -1,15 +0,0 @@ -{ - "type": "python", - "upstream": { - "installer": { - "name": "pip", - "config": { - "options": "" - } - }, - "package": { - "name": "numpy", - "version": "1.26.4" - } - } -} \ No newline at end of file diff --git a/numpy/llpyg.cfg b/numpy/llpyg.cfg deleted file mode 100644 index 698ff6b4..00000000 --- a/numpy/llpyg.cfg +++ /dev/null @@ -1,7 +0,0 @@ -{ - "name": "numpy", - "libName": "numpy", - "modules": [ - "numpy" - ] -} diff --git a/numpy/numpy.go b/numpy/numpy.go deleted file mode 100644 index dc1217db..00000000 --- a/numpy/numpy.go +++ /dev/null @@ -1,27088 +0,0 @@ -package numpy - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -const LLGoPackage = "py.numpy" -// -// dot(a, b, out=None) -// -// Dot product of two arrays. Specifically, -// -// - If both `a` and `b` are 1-D arrays, it is inner product of vectors -// (without complex conjugation). -// -// - 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 `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`:: -// -// 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 -// First argument. -// b : array_like -// Second argument. -// out : ndarray, optional -// Output argument. This must have the exact kind that would be returned -// if it was not used. In particular, it must have the right type, must be -// C-contiguous, and its dtype must be the dtype that would be returned -// for `dot(a,b)`. This is a performance feature. Therefore, if these -// conditions are not met, an exception is raised, instead of attempting -// to be flexible. -// -// Returns -// ------- -// output : ndarray -// Returns the dot product of `a` and `b`. If `a` and `b` are both -// scalars or both 1-D arrays then a scalar is returned; otherwise -// an array is returned. -// If `out` is given, then it is returned. -// -// Raises -// ------ -// ValueError -// If the last dimension of `a` is not the same size as -// the second-to-last dimension of `b`. -// -// See Also -// -------- -// vdot : Complex-conjugating dot product. -// tensordot : Sum products over arbitrary axes. -// einsum : Einstein summation convention. -// matmul : '@' operator as method with out parameter. -// linalg.multi_dot : Chained dot product. -// -// Examples -// -------- -// >>> np.dot(3, 4) -// 12 -// -// Neither argument is complex-conjugated: -// -// >>> np.dot([2j, 3j], [2j, 3j]) -// (-13+0j) -// -// For 2-D arrays it is the matrix product: -// -// >>> a = [[1, 0], [0, 1]] -// >>> b = [[4, 1], [2, 2]] -// >>> np.dot(a, b) -// array([[4, 1], -// [2, 2]]) -// -// >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) -// >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) -// >>> np.dot(a, b)[2,3,2,1,2,2] -// 499128 -// >>> sum(a[2,3,2,:] * b[1,2,:,2]) -// 499128 -// -// -// -//go:linkname Dot py.dot -func Dot(a *py.Object, b *py.Object, out *py.Object) *py.Object -// -// Return a new array of given shape and type, filled with ones. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// The desired data-type for the array, e.g., `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: C -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of ones with the given shape, dtype, and order. -// -// See Also -// -------- -// ones_like : Return an array of ones with shape and type of input. -// empty : Return a new uninitialized array. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. -// -// -// Examples -// -------- -// >>> np.ones(5) -// array([1., 1., 1., 1., 1.]) -// -// >>> np.ones((5,), dtype=int) -// array([1, 1, 1, 1, 1]) -// -// >>> np.ones((2, 1)) -// array([[1.], -// [1.]]) -// -// >>> s = (2,2) -// >>> np.ones(s) -// array([[1., 1.], -// [1., 1.]]) -// -// -// -//go:linkname Ones py.ones -func Ones(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return selected slices of an array along given axis. -// -// When working along a given axis, a slice along that axis is returned in -// `output` for each index where `condition` evaluates to True. When -// working on a 1-D array, `compress` is equivalent to `extract`. -// -// Parameters -// ---------- -// condition : 1-D array of bools -// Array that selects which entries to return. If len(condition) -// is less than the size of `a` along the given axis, then output is -// truncated to the length of the condition array. -// a : array_like -// Array from which to extract a part. -// axis : int, optional -// Axis along which to take slices. If None (default), work on the -// flattened array. -// out : ndarray, optional -// Output array. Its type is preserved and it must be of the right -// shape to hold the output. -// -// Returns -// ------- -// compressed_array : ndarray -// A copy of `a` without the slices along axis for which `condition` -// is false. -// -// See Also -// -------- -// take, choose, diag, diagonal, select -// ndarray.compress : Equivalent method in ndarray -// extract : Equivalent method when working on 1-D arrays -// :ref:`ufuncs-output-type` -// -// Examples -// -------- -// >>> a = np.array([[1, 2], [3, 4], [5, 6]]) -// >>> a -// array([[1, 2], -// [3, 4], -// [5, 6]]) -// >>> np.compress([0, 1], a, axis=0) -// array([[3, 4]]) -// >>> np.compress([False, True, True], a, axis=0) -// array([[3, 4], -// [5, 6]]) -// >>> np.compress([False, True], a, axis=1) -// array([[2], -// [4], -// [6]]) -// -// Working on the flattened array does not return slices along an axis but -// selects elements. -// -// >>> np.compress([False, True], a) -// array([2]) -// -// -// -//go:linkname Compress py.compress -func Compress(condition *py.Object, a *py.Object, axis *py.Object, out *py.Object) *py.Object -// -// Return the cumulative sum of the elements along a given axis. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative sum is computed. The default -// (None) is to compute the cumsum over the flattened array. -// dtype : dtype, optional -// Type of the returned array and of the accumulator in which the -// elements are summed. If `dtype` is not specified, it defaults -// to the dtype of `a`, unless `a` has an integer dtype with a -// precision less than that of the default platform integer. In -// that case, the default platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type will be cast if necessary. See :ref:`ufuncs-output-type` for -// more details. -// -// Returns -// ------- -// cumsum_along_axis : ndarray. -// A new array holding the result is returned unless `out` is -// specified, in which case a reference to `out` is returned. The -// result has the same size as `a`, and the same shape as `a` if -// `axis` is not None or `a` is a 1-d array. -// -// See Also -// -------- -// sum : Sum array elements. -// trapz : Integration of array values using the composite trapezoidal rule. -// diff : Calculate the n-th discrete difference along given axis. -// -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. -// -// ``cumsum(a)[-1]`` may not be equal to ``sum(a)`` for floating-point -// values since ``sum`` may use a pairwise summation routine, reducing -// the roundoff-error. See `sum` for more information. -// -// Examples -// -------- -// >>> a = np.array([[1,2,3], [4,5,6]]) -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.cumsum(a) -// array([ 1, 3, 6, 10, 15, 21]) -// >>> np.cumsum(a, dtype=float) # specifies type of output value(s) -// array([ 1., 3., 6., 10., 15., 21.]) -// -// >>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns -// array([[1, 2, 3], -// [5, 7, 9]]) -// >>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows -// array([[ 1, 3, 6], -// [ 4, 9, 15]]) -// -// ``cumsum(b)[-1]`` may not be equal to ``sum(b)`` -// -// >>> b = np.array([1, 2e-9, 3e-9] * 1000000) -// >>> b.cumsum()[-1] -// 1000000.0050045159 -// >>> b.sum() -// 1000000.0050000029 -// -// -// -//go:linkname Cumsum py.cumsum -func Cumsum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object -// divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return element-wise quotient and remainder simultaneously. -// -// .. versionadded:: 1.13.0 -// -// ``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster -// because it avoids redundant work. It is used to implement the Python -// built-in function ``divmod`` on NumPy arrays. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out1 : ndarray -// Element-wise quotient resulting from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// out2 : ndarray -// Element-wise remainder from floor division. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent to Python's ``//`` operator. -// remainder : Equivalent to Python's ``%`` operator. -// modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return -// values switched. -// -// Examples -// -------- -// >>> np.divmod(np.arange(5), 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -// The `divmod` function can be used as a shorthand for ``np.divmod`` on -// ndarrays. -// -// >>> x = np.arange(5) -// >>> divmod(x, 3) -// (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1])) -// -//go:linkname Divmod py.divmod -func Divmod(x1 *py.Object, x2 *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object -// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the distance between x and the nearest adjacent number. -// -// Parameters -// ---------- -// x : array_like -// Values to find the spacing of. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The spacing of values of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// It can be considered as a generalization of EPS: -// ``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there -// should not be any representable number between ``x + spacing(x)`` and -// x for any finite x. -// -// Spacing of +- inf and NaN is NaN. -// -// Examples -// -------- -// >>> np.spacing(1) == np.finfo(np.float64).eps -// True -// -//go:linkname Spacing py.spacing -func Spacing(x *py.Object, out *py.Object) *py.Object -// -// View inputs as arrays with at least two dimensions. -// -// Parameters -// ---------- -// arys1, arys2, ... : array_like -// One or more array-like sequences. Non-array inputs are converted -// to arrays. Arrays that already have two or more dimensions are -// preserved. -// -// Returns -// ------- -// res, res2, ... : ndarray -// An array, or list of arrays, each with ``a.ndim >= 2``. -// Copies are avoided where possible, and views with two or more -// dimensions are returned. -// -// See Also -// -------- -// atleast_1d, atleast_3d -// -// Examples -// -------- -// >>> np.atleast_2d(3.0) -// array([[3.]]) -// -// >>> x = np.arange(3.0) -// >>> np.atleast_2d(x) -// array([[0., 1., 2.]]) -// >>> np.atleast_2d(x).base is x -// True -// -// >>> np.atleast_2d(1, [1, 2], [[1, 2]]) -// [array([[1]]), array([[1, 2]]), array([[1, 2]])] -// -// -// -//go:linkname Atleast2d py.atleast_2d -func Atleast2d(__llgo_va_list ...interface{}) *py.Object -// -// Return an array copy of the given object. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Controls the memory layout of the copy. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. (Note that this function and :meth:`ndarray.copy` are very -// similar, but have different default values for their order= -// arguments.) -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise the -// returned array will be forced to be a base-class array (defaults to False). -// -// .. versionadded:: 1.19.0 -// -// Returns -// ------- -// arr : ndarray -// Array interpretation of `a`. -// -// See Also -// -------- -// ndarray.copy : Preferred method for creating an array copy -// -// Notes -// ----- -// This is equivalent to: -// -// >>> np.array(a, copy=True) #doctest: +SKIP -// -// Examples -// -------- -// Create an array x, with a reference y and a copy z: -// -// >>> x = np.array([1, 2, 3]) -// >>> y = x -// >>> z = np.copy(x) -// -// Note that, when we modify x, y changes, but not z: -// -// >>> x[0] = 10 -// >>> x[0] == y[0] -// True -// >>> x[0] == z[0] -// False -// -// Note that, np.copy clears previously set WRITEABLE=False flag. -// -// >>> a = np.array([1, 2, 3]) -// >>> a.flags["WRITEABLE"] = False -// >>> b = np.copy(a) -// >>> b.flags["WRITEABLE"] -// True -// >>> 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 -// same object which may lead to surprises if that object can -// be modified (is mutable): -// -// >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) -// >>> b = np.copy(a) -// >>> b[2][0] = 10 -// >>> a -// array([1, 'm', list([10, 3, 4])], dtype=object) -// -// To ensure all elements within an ``object`` array are copied, -// use `copy.deepcopy`: -// -// >>> import copy -// >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) -// >>> c = copy.deepcopy(a) -// >>> c[2][0] = 10 -// >>> c -// array([1, 'm', list([10, 3, 4])], dtype=object) -// >>> a -// array([1, 'm', list([2, 3, 4])], dtype=object) -// -// -// -//go:linkname Copy py.copy -func Copy(a *py.Object, order *py.Object, subok *py.Object) *py.Object -// ascontiguousarray(a, dtype=None, *, like=None) -// -// Return a contiguous array (ndim >= 1) in memory (C order). -// -// Parameters -// ---------- -// a : array_like -// Input array. -// dtype : str or dtype object, optional -// Data-type of returned array. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Contiguous array of same shape and content as `a`, with type `dtype` -// if specified. -// -// See Also -// -------- -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// require : Return an ndarray that satisfies requirements. -// ndarray.flags : Information about the memory layout of the array. -// -// Examples -// -------- -// 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. -// -//go:linkname Ascontiguousarray py.ascontiguousarray -func Ascontiguousarray(a *py.Object, dtype *py.Object) *py.Object -// promote_types(type1, type2) -// -// 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 considered "canonical", this mainly -// means that the promoted dtype will always be in native byte order. -// -// This function is symmetric, but rarely associative. -// -// Parameters -// ---------- -// type1 : dtype or dtype specifier -// First data type. -// type2 : dtype or dtype specifier -// Second data type. -// -// Returns -// ------- -// out : dtype -// The promoted data type. -// -// 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 -// length when given an integer or float dtype as one argument and a string -// dtype as another argument. Previously it always returned the input string -// 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 -// -// Examples -// -------- -// >>> np.promote_types('f4', 'f8') -// dtype('float64') -// -// >>> np.promote_types('i8', 'f4') -// dtype('float64') -// -// >>> np.promote_types('>i8', '>> np.promote_types('i4', 'S8') -// dtype('S11') -// -// An example of a non-associative case: -// -// >>> p = np.promote_types -// >>> p('S', p('i1', 'u1')) -// dtype('S6') -// >>> p(p('S', 'i1'), 'u1') -// dtype('S4') -// -//go:linkname PromoteTypes py.promote_types -func PromoteTypes(type1 *py.Object, type2 *py.Object) *py.Object -// -// Return an array of zeros with the same shape and type as a given array. -// -// Parameters -// ---------- -// a : array_like -// The shape and data-type of `a` define these same attributes of -// the returned array. -// dtype : data-type, optional -// Overrides the data type of the result. -// -// .. versionadded:: 1.6.0 -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. -// -// .. versionadded:: 1.6.0 -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `a`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// out : ndarray -// Array of zeros with the same shape and type as `a`. -// -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// ones_like : Return an array of ones with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// zeros : Return a new array setting values to zero. -// -// Examples -// -------- -// >>> x = np.arange(6) -// >>> x = x.reshape((2, 3)) -// >>> x -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.zeros_like(x) -// array([[0, 0, 0], -// [0, 0, 0]]) -// -// >>> y = np.arange(3, dtype=float) -// >>> y -// array([0., 1., 2.]) -// >>> np.zeros_like(y) -// array([0., 0., 0.]) -// -// -// -//go:linkname ZerosLike py.zeros_like -func ZerosLike(__llgo_va_list ...interface{}) *py.Object -// -// may_share_memory(a, b, /, max_work=None) -// -// Determine if two arrays might share memory -// -// A return of True does not necessarily mean that the two arrays -// share any element. It just means that they *might*. -// -// Only the memory bounds of a and b are checked by default. -// -// Parameters -// ---------- -// a, b : ndarray -// Input arrays -// max_work : int, optional -// Effort to spend on solving the overlap problem. See -// `shares_memory` for details. Default for ``may_share_memory`` -// is to do a bounds check. -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// shares_memory -// -// Examples -// -------- -// >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9])) -// False -// >>> x = np.zeros([3, 4]) -// >>> np.may_share_memory(x[:,0], x[:,1]) -// True -// -// -// -//go:linkname MayShareMemory py.may_share_memory -func MayShareMemory(a *py.Object, b *py.Object, maxWork *py.Object) *py.Object -// -// Sum of array elements over a given axis. -// -// Parameters -// ---------- -// a : array_like -// Elements to sum. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a sum is performed. The default, -// axis=None, will sum all of the elements of the input array. If -// axis is negative it counts from the last to the first axis. -// -// .. versionadded:: 1.7.0 -// -// If axis is a tuple of ints, a sum is performed on all of the axes -// specified in the tuple instead of a single axis or all the axes as -// before. -// dtype : dtype, optional -// The type of the returned array and of the accumulator in which the -// elements are summed. The dtype of `a` is used by default unless `a` -// has an integer dtype of less precision than the default platform -// integer. In that case, if `a` is signed then the platform integer -// is used while if `a` is unsigned then an unsigned integer of the -// same precision as the platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output, but the type of the output -// values will be cast if necessary. -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `sum` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// initial : scalar, optional -// Starting value for the sum. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.15.0 -// -// where : array_like of bool, optional -// Elements to include in the sum. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// sum_along_axis : ndarray -// An array with the same shape as `a`, with the specified -// axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar -// is returned. If an output array is specified, a reference to -// `out` is returned. -// -// See Also -// -------- -// ndarray.sum : Equivalent method. -// -// add.reduce : Equivalent functionality of `add`. -// -// cumsum : Cumulative sum of array elements. -// -// trapz : Integration of array values using the composite trapezoidal rule. -// -// mean, average -// -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. -// -// The sum of an empty array is the neutral element 0: -// -// >>> np.sum([]) -// 0.0 -// -// For floating point numbers the numerical precision of sum (and -// ``np.add.reduce``) is in general limited by directly adding each number -// individually to the result causing rounding errors in every step. -// However, often numpy will use a numerically better approach (partial -// pairwise summation) leading to improved precision in many use-cases. -// This improved precision is always provided when no ``axis`` is given. -// When ``axis`` is given, it will depend on which axis is summed. -// Technically, to provide the best speed possible, the improved precision -// is only used when the summation is along the fast axis in memory. -// Note that the exact precision may vary depending on other parameters. -// In contrast to NumPy, Python's ``math.fsum`` function uses a slower but -// more precise approach to summation. -// Especially when summing a large number of lower precision floating point -// numbers, such as ``float32``, numerical errors can become significant. -// In such cases it can be advisable to use `dtype="float64"` to use a higher -// precision for the output. -// -// Examples -// -------- -// >>> np.sum([0.5, 1.5]) -// 2.0 -// >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32) -// 1 -// >>> np.sum([[0, 1], [0, 5]]) -// 6 -// >>> np.sum([[0, 1], [0, 5]], axis=0) -// array([0, 6]) -// >>> np.sum([[0, 1], [0, 5]], axis=1) -// array([1, 5]) -// >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1) -// array([1., 5.]) -// -// If the accumulator is too small, overflow occurs: -// -// >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8) -// -128 -// -// You can also start the sum with a value other than zero: -// -// >>> np.sum([10], initial=5) -// 15 -// -// -//go:linkname Sum py.sum -func Sum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly. -// -// The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is -// the signed angle in radians between the ray ending at the origin and -// passing through the point (1,0), and the ray ending at the origin and -// passing through the point (`x2`, `x1`). (Note the role reversal: the -// "`y`-coordinate" is the first function parameter, the "`x`-coordinate" -// is the second.) By IEEE convention, this function is defined for -// `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see -// Notes for specific values). -// -// This function is not defined for complex-valued arguments; for the -// so-called argument of complex values, use `angle`. -// -// Parameters -// ---------- -// x1 : array_like, real-valued -// `y`-coordinates. -// x2 : array_like, real-valued -// `x`-coordinates. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// Array of angles in radians, in the range ``[-pi, pi]``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// arctan, tan, angle -// -// Notes -// ----- -// *arctan2* is identical to the `atan2` function of the underlying -// C library. The following special values are defined in the C -// standard: [1]_ -// -// ====== ====== ================ -// `x1` `x2` `arctan2(x1,x2)` -// ====== ====== ================ -// +/- 0 +0 +/- 0 -// +/- 0 -0 +/- pi -// > 0 +/-inf +0 / +pi -// < 0 +/-inf -0 / -pi -// +/-inf +inf +/- (pi/4) -// +/-inf -inf +/- (3*pi/4) -// ====== ====== ================ -// -// Note that +0 and -0 are distinct floating point numbers, as are +inf -// and -inf. -// -// References -// ---------- -// .. [1] ISO/IEC standard 9899:1999, "Programming language C." -// -// Examples -// -------- -// Consider four points in different quadrants: -// -// >>> x = np.array([-1, +1, +1, -1]) -// >>> y = np.array([-1, -1, +1, +1]) -// >>> np.arctan2(y, x) * 180 / np.pi -// array([-135., -45., 45., 135.]) -// -// Note the order of the parameters. `arctan2` is defined also when `x2` = 0 -// and at several other special points, obtaining values in -// the range ``[-pi, pi]``: -// -// >>> 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]) -// -//go:linkname Arctan2 py.arctan2 -func Arctan2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Set printing options. -// -// These options determine the way floating point numbers, arrays and -// other NumPy objects are displayed. -// -// Parameters -// ---------- -// precision : int or None, optional -// Number of digits of precision for floating point output (default 8). -// May be None if `floatmode` is not `fixed`, to print as many digits as -// necessary to uniquely specify the value. -// threshold : int, optional -// Total number of array elements which trigger summarization -// rather than full repr (default 1000). -// To always use the full repr without summarization, pass `sys.maxsize`. -// edgeitems : int, optional -// Number of array items in summary at beginning and end of -// each dimension (default 3). -// linewidth : int, optional -// The number of characters per line for the purpose of inserting -// line breaks (default 75). -// suppress : bool, optional -// If True, always print floating point numbers using fixed point -// notation, in which case numbers equal to zero in the current precision -// will print as zero. If False, then scientific notation is used when -// absolute value of the smallest number is < 1e-4 or the ratio of the -// maximum absolute value to the minimum is > 1e3. The default is False. -// nanstr : str, optional -// String representation of floating point not-a-number (default nan). -// infstr : str, optional -// String representation of floating point infinity (default inf). -// sign : string, either '-', '+', or ' ', optional -// Controls printing of the sign of floating-point types. If '+', always -// print the sign of positive values. If ' ', always prints a space -// (whitespace character) in the sign position of positive values. If -// '-', omit the sign character of positive values. (default '-') -// formatter : dict of callables, optional -// If not None, the keys should indicate the type(s) that the respective -// formatting function applies to. Callables should return a string. -// Types that are not specified (by their corresponding keys) are handled -// by the default formatters. Individual types for which a formatter -// can be set are: -// -// - 'bool' -// - 'int' -// - 'timedelta' : a `numpy.timedelta64` -// - 'datetime' : a `numpy.datetime64` -// - 'float' -// - 'longfloat' : 128-bit floats -// - 'complexfloat' -// - 'longcomplexfloat' : composed of two 128-bit floats -// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` -// - 'object' : `np.object_` arrays -// -// Other keys that can be used to set a group of types at once are: -// -// - 'all' : sets all types -// - 'int_kind' : sets 'int' -// - 'float_kind' : sets 'float' and 'longfloat' -// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' -// - 'str_kind' : sets 'numpystr' -// floatmode : str, optional -// Controls the interpretation of the `precision` option for -// floating-point types. Can take the following values -// (default maxprec_equal): -// -// * 'fixed': Always print exactly `precision` fractional digits, -// even if this would print more or fewer digits than -// necessary to specify the value uniquely. -// * 'unique': Print the minimum number of fractional digits necessary -// to represent each value uniquely. Different elements may -// have a different number of digits. The value of the -// `precision` option is ignored. -// * 'maxprec': Print at most `precision` fractional digits, but if -// an element can be uniquely represented with fewer digits -// only print it with that many. -// * 'maxprec_equal': Print at most `precision` fractional digits, -// but if every element in the array can be uniquely -// represented with an equal number of fewer digits, use that -// many digits for all elements. -// legacy : string or `False`, optional -// If set to the string `'1.13'` enables 1.13 legacy printing mode. This -// approximates numpy 1.13 print output by including a space in the sign -// position of floats and different behavior for 0d arrays. This also -// enables 1.21 legacy printing mode (described below). -// -// If set to the string `'1.21'` enables 1.21 legacy printing mode. This -// approximates numpy 1.21 print output of complex structured dtypes -// by not inserting spaces after commas that separate fields and after -// colons. -// -// If set to `False`, disables legacy mode. -// -// Unrecognized strings will be ignored with a warning for forward -// compatibility. -// -// .. versionadded:: 1.14.0 -// .. versionchanged:: 1.22.0 -// -// See Also -// -------- -// get_printoptions, printoptions, set_string_function, array2string -// -// Notes -// ----- -// `formatter` is always reset with a call to `set_printoptions`. -// -// Use `printoptions` as a context manager to set the values temporarily. -// -// Examples -// -------- -// Floating point precision can be set: -// -// >>> np.set_printoptions(precision=4) -// >>> np.array([1.123456789]) -// [1.1235] -// -// Long arrays can be summarised: -// -// >>> np.set_printoptions(threshold=5) -// >>> np.arange(10) -// array([0, 1, 2, ..., 7, 8, 9]) -// -// Small results can be suppressed: -// -// >>> eps = np.finfo(float).eps -// >>> x = np.arange(4.) -// >>> x**2 - (x + eps)**2 -// array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) -// >>> np.set_printoptions(suppress=True) -// >>> x**2 - (x + eps)**2 -// array([-0., -0., 0., 0.]) -// -// A custom formatter can be used to display array elements as desired: -// -// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) -// >>> x = np.arange(3) -// >>> x -// array([int: 0, int: -1, int: -2]) -// >>> np.set_printoptions() # formatter gets reset -// >>> x -// array([0, 1, 2]) -// -// To put back the default options, you can use: -// -// >>> np.set_printoptions(edgeitems=3, infstr='inf', -// ... linewidth=75, nanstr='nan', precision=8, -// ... suppress=False, threshold=1000, formatter=None) -// -// Also to temporarily override options, use `printoptions` as a context manager: -// -// >>> with np.printoptions(precision=2, suppress=True, threshold=5): -// ... np.linspace(0, 10, 10) -// array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) -// -// -// -//go:linkname SetPrintoptions py.set_printoptions -func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *py.Object -// -// Compute the median along the specified axis. -// -// Returns the median of the array elements. -// -// Parameters -// ---------- -// a : array_like -// Input array or object that can be converted to an array. -// axis : {int, sequence of int, None}, optional -// Axis or axes along which the medians are computed. The default -// is to compute the median along a flattened version of the array. -// A sequence of axes is supported since version 1.9.0. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow use of memory of input array `a` for -// calculations. The input array will be modified by the call to -// `median`. This will save memory when you do not need to preserve -// the contents of the input array. Treat the input as undefined, -// but it will probably be fully or partially sorted. Default is -// False. If `overwrite_input` is ``True`` and `a` is not already an -// `ndarray`, an error will be raised. -// 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 `arr`. -// -// .. versionadded:: 1.9.0 -// -// Returns -// ------- -// median : ndarray -// A new array holding the result. If the input contains integers -// or floats smaller than ``float64``, then the output data-type is -// ``np.float64``. Otherwise, the data-type of the output is the -// same as that of the input. If `out` is specified, that array is -// returned instead. -// -// See Also -// -------- -// mean, percentile -// -// Notes -// ----- -// Given a vector ``V`` of length ``N``, the median of ``V`` is the -// middle value of a sorted copy of ``V``, ``V_sorted`` - i -// e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the -// two middle values of ``V_sorted`` when ``N`` is even. -// -// Examples -// -------- -// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) -// >>> a -// array([[10, 7, 4], -// [ 3, 2, 1]]) -// >>> np.median(a) -// 3.5 -// >>> np.median(a, axis=0) -// array([6.5, 4.5, 2.5]) -// >>> np.median(a, axis=1) -// array([7., 2.]) -// >>> m = np.median(a, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.median(a, axis=0, out=m) -// array([6.5, 4.5, 2.5]) -// >>> m -// array([6.5, 4.5, 2.5]) -// >>> b = a.copy() -// >>> np.median(b, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a==b) -// >>> b = a.copy() -// >>> np.median(b, axis=None, overwrite_input=True) -// 3.5 -// >>> assert not np.all(a==b) -// -// -// -//go:linkname Median py.median -func Median(a *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, keepdims *py.Object) *py.Object -// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// `y`-coordinate on the unit circle. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// angle : ndarray -// The inverse sine of each element in `x`, in radians and in the -// closed interval ``[-pi/2, pi/2]``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// sin, cos, arccos, tan, arctan, arctan2, emath.arcsin -// -// Notes -// ----- -// `arcsin` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that :math:`sin(z) = x`. The convention is to -// return the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, *arcsin* always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arcsin` is a complex analytic function that -// has, by convention, the branch cuts [-inf, -1] and [1, inf] and is -// continuous from above on the former and from below on the latter. -// -// The inverse sine is also known as `asin` or sin^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79ff. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// >>> np.arcsin(1) # pi/2 -// 1.5707963267948966 -// >>> np.arcsin(-1) # -pi/2 -// -1.5707963267948966 -// >>> np.arcsin(0) -// 0.0 -// -//go:linkname Arcsin py.arcsin -func Arcsin(x *py.Object, out *py.Object) *py.Object -// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Angles in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in radians. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : Convert angles from radians to degrees. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// ``deg2rad(x)`` is ``x * pi / 180``. -// -// Examples -// -------- -// >>> np.deg2rad(180) -// 3.1415926535897931 -// -//go:linkname Deg2rad py.deg2rad -func Deg2rad(x *py.Object, out *py.Object) *py.Object -// frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Decompose the elements of x into mantissa and twos 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. -// -// Parameters -// ---------- -// x : array_like -// Array of numbers to be decomposed. -// out1 : ndarray, optional -// Output array for the mantissa. Must have the same shape as `x`. -// out2 : ndarray, optional -// Output array for the exponent. Must have the same shape as `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// mantissa : ndarray -// Floating values between -1 and 1. -// This is a scalar if `x` is a scalar. -// exponent : ndarray -// Integer exponents of 2. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// Examples -// -------- -// >>> x = np.arange(9) -// >>> y1, y2 = np.frexp(x) -// >>> y1 -// array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875, -// 0.5 ]) -// >>> y2 -// array([0, 1, 2, 2, 3, 3, 3, 3, 4]) -// >>> y1 * 2**y2 -// array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.]) -// -//go:linkname Frexp py.frexp -func Frexp(x *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object -// -// Trim the leading and/or trailing zeros from a 1-D array or sequence. -// -// Parameters -// ---------- -// filt : 1-D array or sequence -// Input array. -// trim : str, optional -// A string with 'f' representing trim from front and 'b' to trim from -// back. Default is 'fb', trim zeros from both front and back of the -// array. -// -// Returns -// ------- -// trimmed : 1-D array or sequence -// The result of trimming the input. The input data type is preserved. -// -// Examples -// -------- -// >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0)) -// >>> np.trim_zeros(a) -// array([1, 2, 3, 0, 2, 1]) -// -// >>> np.trim_zeros(a, 'b') -// array([0, 0, 0, ..., 0, 2, 1]) -// -// The input data type is preserved, list/tuple in means list/tuple out. -// -// >>> np.trim_zeros([0, 1, 2, 0]) -// [1, 2] -// -// -// -//go:linkname TrimZeros py.trim_zeros -func TrimZeros(filt *py.Object, trim *py.Object) *py.Object -// -// Return the Hanning window. -// -// The Hanning window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray, shape(M,) -// The window, with the maximum value normalized to one (the value -// one appears only if `M` is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, kaiser -// -// Notes -// ----- -// The Hanning window is defined as -// -// .. 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. -// It is also known as the Cosine Bell. Some authors prefer that it be -// called a Hann window, to help avoid confusion with the very similar -// Hamming window. -// -// Most references to the Hanning window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 106-108. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hanning(12) -// array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037, -// 0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249, -// 0.07937323, 0. ]) -// -// Plot the window and its frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hanning(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hann window") -// Text(0.5, 1.0, 'Hann window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of the Hann window") -// Text(0.5, 1.0, 'Frequency response of the Hann window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hanning py.hanning -func Hanning(M *py.Object) *py.Object -// -// Create a two-dimensional array with the flattened input as a diagonal. -// -// Parameters -// ---------- -// v : array_like -// Input data, which is flattened and set as the `k`-th -// diagonal of the output. -// k : int, optional -// Diagonal to set; 0, the default, corresponds to the "main" diagonal, -// a positive (negative) `k` giving the number of the diagonal above -// (below) the main. -// -// Returns -// ------- -// out : ndarray -// The 2-D output array. -// -// See Also -// -------- -// diag : MATLAB work-alike for 1-D and 2-D arrays. -// diagonal : Return specified diagonals. -// trace : Sum along diagonals. -// -// Examples -// -------- -// >>> np.diagflat([[1,2], [3,4]]) -// array([[1, 0, 0, 0], -// [0, 2, 0, 0], -// [0, 0, 3, 0], -// [0, 0, 0, 4]]) -// -// >>> np.diagflat([1,2], 1) -// array([[0, 1, 0], -// [0, 0, 2], -// [0, 0, 0]]) -// -// -// -//go:linkname Diagflat py.diagflat -func Diagflat(v *py.Object, k *py.Object) *py.Object -// -// Generate a Vandermonde matrix. -// -// The columns of the output matrix are powers of the input vector. The -// order of the powers is determined by the `increasing` boolean argument. -// Specifically, when `increasing` is False, the `i`-th output column is -// the input vector raised element-wise to the power of ``N - i - 1``. Such -// a matrix with a geometric progression in each row is named for Alexandre- -// Theophile Vandermonde. -// -// Parameters -// ---------- -// x : array_like -// 1-D input array. -// N : int, optional -// Number of columns in the output. If `N` is not specified, a square -// array is returned (``N = len(x)``). -// increasing : bool, optional -// Order of the powers of the columns. If True, the powers increase -// from left to right, if False (the default) they are reversed. -// -// .. versionadded:: 1.9.0 -// -// Returns -// ------- -// out : ndarray -// Vandermonde matrix. If `increasing` is False, the first column is -// ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is -// True, the columns are ``x^0, x^1, ..., x^(N-1)``. -// -// See Also -// -------- -// polynomial.polynomial.polyvander -// -// Examples -// -------- -// >>> x = np.array([1, 2, 3, 5]) -// >>> N = 3 -// >>> np.vander(x, N) -// array([[ 1, 1, 1], -// [ 4, 2, 1], -// [ 9, 3, 1], -// [25, 5, 1]]) -// -// >>> np.column_stack([x**(N-1-i) for i in range(N)]) -// array([[ 1, 1, 1], -// [ 4, 2, 1], -// [ 9, 3, 1], -// [25, 5, 1]]) -// -// >>> x = np.array([1, 2, 3, 5]) -// >>> np.vander(x) -// array([[ 1, 1, 1, 1], -// [ 8, 4, 2, 1], -// [ 27, 9, 3, 1], -// [125, 25, 5, 1]]) -// >>> np.vander(x, increasing=True) -// array([[ 1, 1, 1, 1], -// [ 1, 2, 4, 8], -// [ 1, 3, 9, 27], -// [ 1, 5, 25, 125]]) -// -// The determinant of a square Vandermonde matrix is the product -// of the differences between the values of the input vector: -// -// >>> np.linalg.det(np.vander(x)) -// 48.000000000000043 # may vary -// >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1) -// 48 -// -// -// -//go:linkname Vander py.vander -func Vander(x *py.Object, N *py.Object, increasing *py.Object) *py.Object -// -// Return the indices for the upper-triangle of arr. -// -// See `triu_indices` for full details. -// -// Parameters -// ---------- -// arr : ndarray, shape(N, N) -// The indices will be valid for square arrays. -// k : int, optional -// Diagonal offset (see `triu` for details). -// -// Returns -// ------- -// triu_indices_from : tuple, shape(2) of ndarray, shape(N) -// Indices for the upper-triangle of `arr`. -// -// Examples -// -------- -// -// Create a 4 by 4 array. -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Pass the array to get the indices of the upper triangular elements. -// -// >>> triui = np.triu_indices_from(a) -// >>> triui -// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) -// -// >>> a[triui] -// array([ 0, 1, 2, 3, 5, 6, 7, 10, 11, 15]) -// -// This is syntactic sugar for triu_indices(). -// -// >>> np.triu_indices(a.shape[0]) -// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) -// -// Use the `k` parameter to return the indices for the upper triangular array -// from the k-th diagonal. -// -// >>> triuim1 = np.triu_indices_from(a, k=1) -// >>> a[triuim1] -// array([ 1, 2, 3, 6, 7, 11]) -// -// -// See Also -// -------- -// triu_indices, triu, tril_indices_from -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// -// -//go:linkname TriuIndicesFrom py.triu_indices_from -func TriuIndicesFrom(arr *py.Object, k *py.Object) *py.Object -// set_numeric_ops(op1=func1, op2=func2, ...) -// -// Set numerical operators for array objects. -// -// .. deprecated:: 1.16 -// -// For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`. -// For ndarray subclasses, define the ``__array_ufunc__`` method and -// override the relevant ufunc. -// -// Parameters -// ---------- -// op1, op2, ... : callable -// Each ``op = func`` pair describes an operator to be replaced. -// For example, ``add = lambda x, y: np.add(x, y) % 5`` would replace -// addition by modulus 5 addition. -// -// Returns -// ------- -// saved_ops : list of callables -// A list of all operators, stored before making replacements. -// -// Notes -// ----- -// .. warning:: -// Use with care! Incorrect usage may lead to memory errors. -// -// A function replacing an operator cannot make use of that operator. -// For example, when replacing add, you may not use ``+``. Instead, -// directly call ufuncs. -// -// Examples -// -------- -// >>> def add_mod5(x, y): -// ... return np.add(x, y) % 5 -// ... -// >>> old_funcs = np.set_numeric_ops(add=add_mod5) -// -// >>> x = np.arange(12).reshape((3, 4)) -// >>> x + x -// array([[0, 2, 4, 1], -// [3, 0, 2, 4], -// [1, 3, 0, 2]]) -// -// >>> ignore = np.set_numeric_ops(**old_funcs) # restore operators -// -//go:linkname SetNumericOps py.set_numeric_ops -func SetNumericOps(op1 *py.Object, op2 *py.Object) *py.Object -// -// Test whether any array element along a given axis evaluates to True. -// -// Returns single boolean if `axis` is ``None`` -// -// Parameters -// ---------- -// a : array_like -// Input array or object that can be converted to an array. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a logical OR reduction is performed. -// The default (``axis=None``) is to perform a logical OR over all -// the dimensions of the input array. `axis` may be negative, in -// which case it counts from the last to the first axis. -// -// .. versionadded:: 1.7.0 -// -// If this is a tuple of ints, a reduction is performed on multiple -// axes, instead of a single axis or all the axes as before. -// out : ndarray, optional -// Alternate output array in which to place the result. It must have -// the same shape as the expected output and its type is preserved -// (e.g., if it is of type float, then it will remain so, returning -// 1.0 for True and 0.0 for False, regardless of the type of `a`). -// See :ref:`ufuncs-output-type` for more details. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `any` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// where : array_like of bool, optional -// Elements to include in checking for any `True` values. -// See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// any : bool or ndarray -// A new boolean or `ndarray` is returned unless `out` is specified, -// in which case a reference to `out` is returned. -// -// See Also -// -------- -// ndarray.any : equivalent method -// -// all : Test whether all elements along a given axis evaluate to True. -// -// Notes -// ----- -// Not a Number (NaN), positive infinity and negative infinity evaluate -// to `True` because these are not equal to zero. -// -// Examples -// -------- -// >>> np.any([[True, False], [True, True]]) -// True -// -// >>> np.any([[True, False], [False, False]], axis=0) -// array([ True, False]) -// -// >>> np.any([-1, 0, 5]) -// True -// -// >>> np.any(np.nan) -// True -// -// >>> np.any([[True, False], [False, False]], where=[[False], [True]]) -// False -// -// >>> o=np.array(False) -// >>> z=np.any([-1, 4, 5], out=o) -// >>> z, o -// (array(True), array(True)) -// >>> # Check now that z is a reference to o -// >>> z is o -// True -// >>> id(z), id(o) # identity of z and o # doctest: +SKIP -// (191614240, 191614240) -// -// -// -//go:linkname Any py.any -func Any(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object) *py.Object -// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Multiply arguments element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays to be multiplied. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The product of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to `x1` * `x2` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.multiply(2.0, 4.0) -// 8.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.multiply(x1, x2) -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -// The ``*`` operator can be used as a shorthand for ``np.multiply`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 * x2 -// array([[ 0., 1., 4.], -// [ 0., 4., 10.], -// [ 0., 7., 16.]]) -// -//go:linkname Multiply py.multiply -func Multiply(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return the elements of an array that satisfy some condition. -// -// This is equivalent to ``np.compress(ravel(condition), ravel(arr))``. If -// `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``. -// -// Note that `place` does the exact opposite of `extract`. -// -// Parameters -// ---------- -// condition : array_like -// An array whose nonzero or True entries indicate the elements of `arr` -// to extract. -// arr : array_like -// Input array of the same size as `condition`. -// -// Returns -// ------- -// extract : ndarray -// Rank 1 array of values from `arr` where `condition` is True. -// -// See Also -// -------- -// take, put, copyto, compress, place -// -// Examples -// -------- -// >>> arr = np.arange(12).reshape((3, 4)) -// >>> arr -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11]]) -// >>> condition = np.mod(arr, 3)==0 -// >>> condition -// array([[ True, False, False, True], -// [False, False, True, False], -// [False, True, False, False]]) -// >>> np.extract(condition, arr) -// array([0, 3, 6, 9]) -// -// -// If `condition` is boolean: -// -// >>> arr[condition] -// array([0, 3, 6, 9]) -// -// -// -//go:linkname Extract py.extract -func Extract(condition *py.Object, arr *py.Object) *py.Object -// Convert the input to an array, checking for NaNs or Infs. -// -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes lists, lists of tuples, tuples, tuples of tuples, tuples -// of lists and ndarrays. Success requires no NaNs or Infs. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'C'. -// -// Returns -// ------- -// out : ndarray -// Array interpretation of `a`. No copy is performed if the input -// is already an ndarray. If `a` is a subclass of ndarray, a base -// class ndarray is returned. -// -// Raises -// ------ -// ValueError -// Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity). -// -// See Also -// -------- -// asarray : Create and array. -// asanyarray : Similar function which passes through subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfarray : Convert input to a floating point ndarray. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. -// -// Examples -// -------- -// Convert a list into an array. If all elements are finite -// ``asarray_chkfinite`` is identical to ``asarray``. -// -// >>> a = [1, 2] -// >>> np.asarray_chkfinite(a, dtype=float) -// array([1., 2.]) -// -// Raises ValueError if array_like contains Nans or Infs. -// -// >>> a = [1, 2, np.inf] -// >>> try: -// ... np.asarray_chkfinite(a) -// ... except ValueError: -// ... print('ValueError') -// ... -// ValueError -// -// -// -//go:linkname AsarrayChkfinite py.asarray_chkfinite -func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Extract a diagonal or construct a diagonal array. -// -// See the more detailed documentation for ``numpy.diagonal`` if you use this -// function to extract a diagonal and wish to write to the resulting array; -// whether it returns a copy or a view depends on what version of numpy you -// are using. -// -// Parameters -// ---------- -// v : array_like -// If `v` is a 2-D array, return a copy of its `k`-th diagonal. -// If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th -// diagonal. -// k : int, optional -// Diagonal in question. The default is 0. Use `k>0` for diagonals -// above the main diagonal, and `k<0` for diagonals below the main -// diagonal. -// -// Returns -// ------- -// out : ndarray -// The extracted diagonal or constructed diagonal array. -// -// See Also -// -------- -// diagonal : Return specified diagonals. -// diagflat : Create a 2-D array with the flattened input as a diagonal. -// trace : Sum along diagonals. -// triu : Upper triangle of an array. -// tril : Lower triangle of an array. -// -// Examples -// -------- -// >>> x = np.arange(9).reshape((3,3)) -// >>> x -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// -// >>> np.diag(x) -// array([0, 4, 8]) -// >>> np.diag(x, k=1) -// array([1, 5]) -// >>> np.diag(x, k=-1) -// array([3, 7]) -// -// >>> np.diag(np.diag(x)) -// array([[0, 0, 0], -// [0, 4, 0], -// [0, 0, 8]]) -// -// -// -//go:linkname Diag py.diag -func Diag(v *py.Object, k *py.Object) *py.Object -// -// Lower triangle of an array. -// -// Return a copy of an array with elements above the `k`-th diagonal zeroed. -// For arrays with ``ndim`` exceeding 2, `tril` will apply to the final two -// axes. -// -// Parameters -// ---------- -// m : array_like, shape (..., M, N) -// Input array. -// k : int, optional -// Diagonal above which to zero elements. `k = 0` (the default) is the -// main diagonal, `k < 0` is below it and `k > 0` is above. -// -// Returns -// ------- -// tril : ndarray, shape (..., M, N) -// Lower triangle of `m`, of same shape and data-type as `m`. -// -// See Also -// -------- -// triu : same thing, only for the upper triangle -// -// Examples -// -------- -// >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1) -// array([[ 0, 0, 0], -// [ 4, 0, 0], -// [ 7, 8, 0], -// [10, 11, 12]]) -// -// >>> np.tril(np.arange(3*4*5).reshape(3, 4, 5)) -// array([[[ 0, 0, 0, 0, 0], -// [ 5, 6, 0, 0, 0], -// [10, 11, 12, 0, 0], -// [15, 16, 17, 18, 0]], -// [[20, 0, 0, 0, 0], -// [25, 26, 0, 0, 0], -// [30, 31, 32, 0, 0], -// [35, 36, 37, 38, 0]], -// [[40, 0, 0, 0, 0], -// [45, 46, 0, 0, 0], -// [50, 51, 52, 0, 0], -// [55, 56, 57, 58, 0]]]) -// -// -// -//go:linkname Tril py.tril -func Tril(m *py.Object, k *py.Object) *py.Object -// -// Pad an array. -// -// Parameters -// ---------- -// array : array_like of rank N -// 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 -// for each axis. -// ``(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. -// -// 'constant' (default) -// Pads with a constant value. -// 'edge' -// Pads with the edge values of array. -// 'linear_ramp' -// Pads with the linear ramp between end_value and the -// array edge value. -// 'maximum' -// Pads with the maximum value of all or part of the -// vector along each axis. -// 'mean' -// Pads with the mean value of all or part of the -// vector along each axis. -// 'median' -// Pads with the median value of all or part of the -// vector along each axis. -// 'minimum' -// Pads with the minimum value of all or part of the -// vector along each axis. -// 'reflect' -// Pads with the reflection of the vector mirrored on -// the first and last values of the vector along each -// axis. -// 'symmetric' -// Pads with the reflection of the vector mirrored -// along the edge of the array. -// 'wrap' -// Pads with the wrap of the vector along the axis. -// The first values are used to pad the end and the -// end values are used to pad the beginning. -// 'empty' -// Pads with undefined values. -// -// .. versionadded:: 1.17 -// -// -// Padding function, see Notes. -// stat_length : sequence or int, optional -// 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 -// 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. -// -// Default is ``None``, to use the entire axis. -// constant_values : sequence or scalar, optional -// Used in 'constant'. The values to set the padded values for each -// axis. -// -// ``((before_1, after_1), ... (before_N, after_N))`` unique pad 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. -// -// Default is 0. -// end_values : sequence or scalar, optional -// Used in 'linear_ramp'. The values used for the ending value of the -// linear_ramp and that will form the edge of the padded array. -// -// ``((before_1, after_1), ... (before_N, after_N))`` unique 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. -// -// Default is 0. -// reflect_type : {'even', 'odd'}, optional -// Used in 'reflect', and 'symmetric'. The 'even' style is the -// default with an unaltered reflection around the edge value. For -// the 'odd' style, the extended part of the array is created by -// subtracting the reflected values from two times the edge value. -// -// Returns -// ------- -// pad : ndarray -// Padded array of rank equal to `array` with shape increased -// according to `pad_width`. -// -// Notes -// ----- -// .. versionadded:: 1.7.0 -// -// For an array with rank greater than 1, some of the padding of later -// axes is calculated from padding of previous axes. This is easiest to -// think about with a rank 2 array where the corners of the padded array -// are calculated by using padded values from the first axis. -// -// The padding function, if used, should modify a rank 1 array in-place. It -// has the following signature:: -// -// padding_func(vector, iaxis_pad_width, iaxis, kwargs) -// -// where -// -// vector : ndarray -// A rank 1 array already padded with zeros. Padded values are -// vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:]. -// iaxis_pad_width : tuple -// A 2-tuple of ints, iaxis_pad_width[0] represents the number of -// values padded at the beginning of vector where -// iaxis_pad_width[1] represents the number of values padded at -// the end of vector. -// iaxis : int -// The axis currently being calculated. -// kwargs : dict -// Any keyword arguments the function requires. -// -// Examples -// -------- -// >>> a = [1, 2, 3, 4, 5] -// >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6)) -// array([4, 4, 1, ..., 6, 6, 6]) -// -// >>> np.pad(a, (2, 3), 'edge') -// array([1, 1, 1, ..., 5, 5, 5]) -// -// >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4)) -// array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4]) -// -// >>> np.pad(a, (2,), 'maximum') -// array([5, 5, 1, 2, 3, 4, 5, 5, 5]) -// -// >>> np.pad(a, (2,), 'mean') -// array([3, 3, 1, 2, 3, 4, 5, 3, 3]) -// -// >>> np.pad(a, (2,), 'median') -// array([3, 3, 1, 2, 3, 4, 5, 3, 3]) -// -// >>> a = [[1, 2], [3, 4]] -// >>> np.pad(a, ((3, 2), (2, 3)), 'minimum') -// array([[1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1], -// [3, 3, 3, 4, 3, 3, 3], -// [1, 1, 1, 2, 1, 1, 1], -// [1, 1, 1, 2, 1, 1, 1]]) -// -// >>> a = [1, 2, 3, 4, 5] -// >>> np.pad(a, (2, 3), 'reflect') -// array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2]) -// -// >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd') -// array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8]) -// -// >>> np.pad(a, (2, 3), 'symmetric') -// array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3]) -// -// >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd') -// array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7]) -// -// >>> np.pad(a, (2, 3), 'wrap') -// array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3]) -// -// >>> def pad_with(vector, pad_width, iaxis, kwargs): -// ... pad_value = kwargs.get('padder', 10) -// ... vector[:pad_width[0]] = pad_value -// ... vector[-pad_width[1]:] = pad_value -// >>> a = np.arange(6) -// >>> a = a.reshape((2, 3)) -// >>> np.pad(a, 2, pad_with) -// array([[10, 10, 10, 10, 10, 10, 10], -// [10, 10, 10, 10, 10, 10, 10], -// [10, 10, 0, 1, 2, 10, 10], -// [10, 10, 3, 4, 5, 10, 10], -// [10, 10, 10, 10, 10, 10, 10], -// [10, 10, 10, 10, 10, 10, 10]]) -// >>> np.pad(a, 2, pad_with, padder=100) -// array([[100, 100, 100, 100, 100, 100, 100], -// [100, 100, 100, 100, 100, 100, 100], -// [100, 100, 0, 1, 2, 100, 100], -// [100, 100, 3, 4, 5, 100, 100], -// [100, 100, 100, 100, 100, 100, 100], -// [100, 100, 100, 100, 100, 100, 100]]) -// -// -//go:linkname Pad py.pad -func Pad(array *py.Object, padWidth *py.Object, mode *py.Object) *py.Object -// -// vdot(a, b, /) -// -// Return the dot product of two vectors. -// -// The vdot(`a`, `b`) function handles complex numbers differently than -// dot(`a`, `b`). If the first argument is complex the complex conjugate -// of the first argument is used for the calculation of the dot product. -// -// Note that `vdot` handles multidimensional arrays differently than `dot`: -// it does *not* perform a matrix product, but flattens input arguments -// to 1-D vectors first. Consequently, it should only be used for vectors. -// -// Parameters -// ---------- -// a : array_like -// If `a` is complex the complex conjugate is taken before calculation -// of the dot product. -// b : array_like -// Second argument to the dot product. -// -// Returns -// ------- -// output : ndarray -// Dot product of `a` and `b`. Can be an int, float, or -// complex depending on the types of `a` and `b`. -// -// See Also -// -------- -// dot : Return the dot product without using the complex conjugate of the -// first argument. -// -// Examples -// -------- -// >>> a = np.array([1+2j,3+4j]) -// >>> b = np.array([5+6j,7+8j]) -// >>> np.vdot(a, b) -// (70-8j) -// >>> np.vdot(b, a) -// (70+8j) -// -// Note that higher-dimensional arrays are flattened! -// -// >>> a = np.array([[1, 4], [5, 6]]) -// >>> b = np.array([[4, 1], [2, 2]]) -// >>> np.vdot(a, b) -// 30 -// >>> np.vdot(b, a) -// 30 -// >>> 1*4 + 4*1 + 5*2 + 6*2 -// 30 -// -// -// -//go:linkname Vdot py.vdot -func Vdot(a *py.Object, b *py.Object) *py.Object -// -// Replaces specified elements of an array with given values. -// -// The indexing works on the flattened target array. `put` is roughly -// equivalent to: -// -// :: -// -// a.flat[ind] = v -// -// Parameters -// ---------- -// a : ndarray -// Target array. -// ind : array_like -// Target indices, interpreted as integers. -// v : array_like -// Values to place in `a` at target indices. If `v` is shorter than -// `ind` it will be repeated as necessary. -// mode : {'raise', 'wrap', 'clip'}, optional -// Specifies how out-of-bounds indices will behave. -// -// * 'raise' -- raise an error (default) -// * 'wrap' -- wrap around -// * 'clip' -- clip to the range -// -// 'clip' mode means that all indices that are too large are replaced -// by the index that addresses the last element along that axis. Note -// that this disables indexing with negative numbers. In 'raise' mode, -// if an exception occurs the target array may still be modified. -// -// See Also -// -------- -// putmask, place -// put_along_axis : Put elements by matching the array and the index arrays -// -// Examples -// -------- -// >>> a = np.arange(5) -// >>> np.put(a, [0, 2], [-44, -55]) -// >>> a -// array([-44, 1, -55, 3, 4]) -// -// >>> a = np.arange(5) -// >>> np.put(a, 22, -5, mode='clip') -// >>> a -// array([ 0, 1, 2, 3, -5]) -// -// -// -//go:linkname Put py.put -func Put(a *py.Object, ind *py.Object, v *py.Object, mode *py.Object) *py.Object -// -// Return the size of the buffer used in ufuncs. -// -// Returns -// ------- -// getbufsize : int -// Size of ufunc buffer in bytes. -// -// -// -//go:linkname Getbufsize py.getbufsize -func Getbufsize() *py.Object -// -// Convert inputs to arrays with at least one dimension. -// -// Scalar inputs are converted to 1-dimensional arrays, whilst -// higher-dimensional inputs are preserved. -// -// Parameters -// ---------- -// arys1, arys2, ... : array_like -// One or more input arrays. -// -// Returns -// ------- -// ret : ndarray -// An array, or list of arrays, each with ``a.ndim >= 1``. -// Copies are made only if necessary. -// -// See Also -// -------- -// atleast_2d, atleast_3d -// -// Examples -// -------- -// >>> np.atleast_1d(1.0) -// array([1.]) -// -// >>> x = np.arange(9.0).reshape(3,3) -// >>> np.atleast_1d(x) -// array([[0., 1., 2.], -// [3., 4., 5.], -// [6., 7., 8.]]) -// >>> np.atleast_1d(x) is x -// True -// -// >>> np.atleast_1d(1, [3, 4]) -// [array([1]), array([3, 4])] -// -// -// -//go:linkname Atleast1d py.atleast_1d -func Atleast1d(__llgo_va_list ...interface{}) *py.Object -// -// View inputs as arrays with at least three dimensions. -// -// Parameters -// ---------- -// arys1, arys2, ... : array_like -// One or more array-like sequences. Non-array inputs are converted to -// arrays. Arrays that already have three or more dimensions are -// preserved. -// -// Returns -// ------- -// res1, res2, ... : ndarray -// An array, or list of arrays, each with ``a.ndim >= 3``. Copies are -// avoided where possible, and views with three or more dimensions are -// returned. For example, a 1-D array of shape ``(N,)`` becomes a view -// of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a -// view of shape ``(M, N, 1)``. -// -// See Also -// -------- -// atleast_1d, atleast_2d -// -// Examples -// -------- -// >>> np.atleast_3d(3.0) -// array([[[3.]]]) -// -// >>> x = np.arange(3.0) -// >>> np.atleast_3d(x).shape -// (1, 3, 1) -// -// >>> x = np.arange(12.0).reshape(4,3) -// >>> np.atleast_3d(x).shape -// (4, 3, 1) -// >>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself -// True -// -// >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]): -// ... print(arr, arr.shape) # doctest: +SKIP -// ... -// [[[1] -// [2]]] (1, 2, 1) -// [[[1] -// [2]]] (1, 2, 1) -// [[[1 2]]] (1, 1, 2) -// -// -// -//go:linkname Atleast3d py.atleast_3d -func Atleast3d(__llgo_va_list ...interface{}) *py.Object -// -// Stack arrays in sequence depth wise (along third axis). -// -// This is equivalent to concatenation along the third axis after 2-D arrays -// of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape -// `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by -// `dsplit`. -// -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// and r/g/b channels (third axis). The functions `concatenate`, `stack` and -// `block` provide more general stacking and concatenation operations. -// -// Parameters -// ---------- -// tup : sequence of arrays -// The arrays must have the same shape along all but the third axis. -// 1-D or 2-D arrays must have the same shape. -// -// Returns -// ------- -// stacked : ndarray -// The array formed by stacking the given arrays, will be at least 3-D. -// -// See Also -// -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// vstack : Stack arrays in sequence vertically (row wise). -// hstack : Stack arrays in sequence horizontally (column wise). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// dsplit : Split array along third axis. -// -// Examples -// -------- -// >>> a = np.array((1,2,3)) -// >>> b = np.array((2,3,4)) -// >>> np.dstack((a,b)) -// array([[[1, 2], -// [2, 3], -// [3, 4]]]) -// -// >>> a = np.array([[1],[2],[3]]) -// >>> b = np.array([[2],[3],[4]]) -// >>> np.dstack((a,b)) -// array([[[1, 2]], -// [[2, 3]], -// [[3, 4]]]) -// -// -// -//go:linkname Dstack py.dstack -func Dstack(tup *py.Object) *py.Object -// Find the wrapper for the array with the highest priority. -// -// In case of ties, leftmost wins. If no wrapper is found, return None -// -// -//go:linkname GetArrayWrap py.get_array_wrap -func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object -// -// Broadcast any number of arrays against each other. -// -// Parameters -// ---------- -// `*args` : array_likes -// The arrays to broadcast. -// -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise -// the returned arrays will be forced to be a base-class array (default). -// -// Returns -// ------- -// broadcasted : list of arrays -// These arrays are views on the original arrays. They are typically -// not contiguous. Furthermore, more than one element of a -// broadcasted array may refer to a single memory location. If you need -// to write to the arrays, make copies first. While you can set the -// ``writable`` flag True, writing to a single output value may end up -// changing more than one location in the output array. -// -// .. deprecated:: 1.17 -// The output is currently marked so that if written to, a deprecation -// warning will be emitted. A future version will set the -// ``writable`` flag False so writing to it will raise an error. -// -// See Also -// -------- -// broadcast -// broadcast_to -// broadcast_shapes -// -// Examples -// -------- -// >>> x = np.array([[1,2,3]]) -// >>> y = np.array([[4],[5]]) -// >>> np.broadcast_arrays(x, y) -// [array([[1, 2, 3], -// [1, 2, 3]]), array([[4, 4, 4], -// [5, 5, 5]])] -// -// Here is a useful idiom for getting contiguous copies instead of -// non-contiguous views. -// -// >>> [np.array(a) for a in np.broadcast_arrays(x, y)] -// [array([[1, 2, 3], -// [1, 2, 3]]), array([[4, 4, 4], -// [5, 5, 5]])] -// -// -// -//go:linkname BroadcastArrays py.broadcast_arrays -func BroadcastArrays(__llgo_va_list ...interface{}) *py.Object -// -// concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind") -// -// Join a sequence of arrays along an existing axis. -// -// Parameters -// ---------- -// a1, a2, ... : sequence of array_like -// The arrays must have the same shape, except in the dimension -// corresponding to `axis` (the first, by default). -// axis : int, optional -// The axis along which the arrays will be joined. If axis is None, -// arrays are flattened before use. Default is 0. -// out : ndarray, optional -// If provided, the destination to place the result. The shape must be -// correct, matching that of what concatenate 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.20.0 -// -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Defaults to 'same_kind'. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// res : ndarray -// The concatenated array. -// -// See Also -// -------- -// ma.concatenate : Concatenate function that preserves input masks. -// array_split : Split an array into multiple sub-arrays of equal or -// near-equal size. -// split : Split array into a list of multiple sub-arrays of equal size. -// hsplit : Split array into multiple sub-arrays horizontally (column wise). -// vsplit : Split array into multiple sub-arrays vertically (row wise). -// dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). -// stack : Stack a sequence of arrays along a new axis. -// block : Assemble arrays from blocks. -// hstack : Stack arrays in sequence horizontally (column wise). -// vstack : Stack arrays in sequence vertically (row wise). -// dstack : Stack arrays in sequence depth wise (along third dimension). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// -// Notes -// ----- -// When one or more of the arrays to be concatenated is a MaskedArray, -// this function will return a MaskedArray object instead of an ndarray, -// but the input masks are *not* preserved. In cases where a MaskedArray -// is expected as input, use the ma.concatenate function from the masked -// array module instead. -// -// Examples -// -------- -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> b = np.array([[5, 6]]) -// >>> np.concatenate((a, b), axis=0) -// array([[1, 2], -// [3, 4], -// [5, 6]]) -// >>> np.concatenate((a, b.T), axis=1) -// array([[1, 2, 5], -// [3, 4, 6]]) -// >>> np.concatenate((a, b), axis=None) -// array([1, 2, 3, 4, 5, 6]) -// -// This function will not preserve masking of MaskedArray inputs. -// -// >>> a = np.ma.arange(3) -// >>> a[1] = np.ma.masked -// >>> b = np.arange(2, 5) -// >>> a -// masked_array(data=[0, --, 2], -// mask=[False, True, False], -// fill_value=999999) -// >>> b -// array([2, 3, 4]) -// >>> np.concatenate([a, b]) -// masked_array(data=[0, 1, 2, 2, 3, 4], -// mask=False, -// fill_value=999999) -// >>> np.ma.concatenate([a, b]) -// masked_array(data=[0, --, 2, 2, 3, 4], -// mask=[False, True, False, False, False, False], -// fill_value=999999) -// -// -// -//go:linkname Concatenate py.concatenate -func Concatenate(list0 *py.Object, axis *py.Object, out *py.Object, dtype *py.Object, casting *py.Object) *py.Object -// -// can_cast(from_, to, casting='safe') -// -// Returns True if cast between data types can occur according to the -// casting rule. If from is a scalar or array scalar, also returns -// True if the scalar value can be cast without overflow or truncation -// to an integer. -// -// Parameters -// ---------- -// from_ : dtype, dtype specifier, scalar, or array -// Data type, scalar, or array to cast from. -// to : dtype or dtype specifier -// Data type to cast to. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. -// -// * 'no' means the data types should not be cast at all. -// * 'equiv' means only byte-order changes are allowed. -// * 'safe' means only casts which can preserve values are allowed. -// * 'same_kind' means only safe casts or casts within a kind, -// like float64 to float32, are allowed. -// * 'unsafe' means any data conversions may be done. -// -// Returns -// ------- -// out : bool -// True if cast can occur according to the casting rule. -// -// Notes -// ----- -// .. versionchanged:: 1.17.0 -// Casting between a simple data type and a structured one is possible only -// for "unsafe" casting. Casting to multiple fields is allowed, but -// casting from multiple fields is not. -// -// .. versionchanged:: 1.9.0 -// Casting from numeric to string types in 'safe' casting mode requires -// that the string dtype length is long enough to store the maximum -// integer/float value converted. -// -// See also -// -------- -// dtype, result_type -// -// Examples -// -------- -// Basic examples -// -// >>> np.can_cast(np.int32, np.int64) -// True -// >>> np.can_cast(np.float64, complex) -// True -// >>> np.can_cast(complex, float) -// False -// -// >>> np.can_cast('i8', 'f8') -// True -// >>> np.can_cast('i8', 'f4') -// False -// >>> np.can_cast('i4', 'S4') -// False -// -// Casting scalars -// -// >>> np.can_cast(100, 'i1') -// True -// >>> np.can_cast(150, 'i1') -// False -// >>> np.can_cast(150, 'u1') -// True -// -// >>> np.can_cast(3.5e100, np.float32) -// False -// >>> np.can_cast(1000.0, np.float32) -// True -// -// Array scalar checks the value, array does not -// -// >>> np.can_cast(np.array(1000.0), np.float32) -// True -// >>> np.can_cast(np.array([1000.0]), np.float32) -// False -// -// Using the casting rules -// -// >>> np.can_cast('i8', 'i8', 'no') -// True -// >>> np.can_cast('i8', 'no') -// False -// -// >>> np.can_cast('i8', 'equiv') -// True -// >>> np.can_cast('i8', 'equiv') -// False -// -// >>> np.can_cast('i8', 'safe') -// True -// >>> np.can_cast('i4', 'safe') -// False -// -// >>> np.can_cast('i4', 'same_kind') -// True -// >>> np.can_cast('u4', 'same_kind') -// False -// -// >>> np.can_cast('u4', 'unsafe') -// True -// -// -// -//go:linkname CanCast py.can_cast -func CanCast(from_ *py.Object, to *py.Object, casting *py.Object) *py.Object -// -// Return the identity array. -// -// The identity array is a square array with ones on -// the main diagonal. -// -// Parameters -// ---------- -// n : int -// Number of rows (and columns) in `n` x `n` output. -// dtype : data-type, optional -// Data-type of the output. Defaults to ``float``. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// `n` x `n` array with its main diagonal set to one, -// and all other elements 0. -// -// Examples -// -------- -// >>> np.identity(3) -// array([[1., 0., 0.], -// [0., 1., 0.], -// [0., 0., 1.]]) -// -// -// -//go:linkname Identity py.identity -func Identity(n *py.Object, dtype *py.Object) *py.Object -// -// Remove axes of length one from `a`. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// .. versionadded:: 1.7.0 -// -// Selects a subset of the entries of length one in the -// shape. If an axis is selected with shape entry greater than -// one, an error is raised. -// -// Returns -// ------- -// squeezed : ndarray -// The input array, but with all or a subset of the -// dimensions of length 1 removed. This is always `a` itself -// or a view into `a`. Note that if all axes are squeezed, -// the result is a 0d array and not a scalar. -// -// Raises -// ------ -// ValueError -// If `axis` is not None, and an axis being squeezed is not of length 1 -// -// See Also -// -------- -// expand_dims : The inverse operation, adding entries of length one -// reshape : Insert, remove, and combine dimensions, and resize existing ones -// -// Examples -// -------- -// >>> x = np.array([[[0], [1], [2]]]) -// >>> x.shape -// (1, 3, 1) -// >>> np.squeeze(x).shape -// (3,) -// >>> np.squeeze(x, axis=0).shape -// (3, 1) -// >>> np.squeeze(x, axis=1).shape -// Traceback (most recent call last): -// ... -// ValueError: cannot select an axis to squeeze out which has size not equal to one -// >>> np.squeeze(x, axis=2).shape -// (1, 3) -// >>> x = np.array([[1234]]) -// >>> x.shape -// (1, 1) -// >>> np.squeeze(x) -// array(1234) # 0d array -// >>> np.squeeze(x).shape -// () -// >>> np.squeeze(x)[()] -// 1234 -// -// -// -//go:linkname Squeeze py.squeeze -func Squeeze(a *py.Object, axis *py.Object) *py.Object -// cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic cosine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array of same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.cosh(0) -// 1.0 -// -// The hyperbolic cosine describes the shape of a hanging cable: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-4, 4, 1000) -// >>> plt.plot(x, np.cosh(x)) -// >>> plt.show() -// -//go:linkname Cosh py.cosh -func Cosh(x *py.Object, out *py.Object) *py.Object -// -// Return the indices for the lower-triangle of arr. -// -// See `tril_indices` for full details. -// -// Parameters -// ---------- -// arr : array_like -// The indices will be valid for square arrays whose dimensions are -// the same as arr. -// k : int, optional -// Diagonal offset (see `tril` for details). -// -// Examples -// -------- -// -// Create a 4 by 4 array. -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Pass the array to get the indices of the lower triangular elements. -// -// >>> trili = np.tril_indices_from(a) -// >>> trili -// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) -// -// >>> a[trili] -// array([ 0, 4, 5, 8, 9, 10, 12, 13, 14, 15]) -// -// This is syntactic sugar for tril_indices(). -// -// >>> np.tril_indices(a.shape[0]) -// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) -// -// Use the `k` parameter to return the indices for the lower triangular array -// up to the k-th diagonal. -// -// >>> trili1 = np.tril_indices_from(a, k=1) -// >>> a[trili1] -// array([ 0, 1, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15]) -// -// See Also -// -------- -// tril_indices, tril, triu_indices_from -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// -// -//go:linkname TrilIndicesFrom py.tril_indices_from -func TrilIndicesFrom(arr *py.Object, k *py.Object) *py.Object -// -// Difference (subtraction) of two polynomials. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// Given two polynomials `a1` and `a2`, returns ``a1 - a2``. -// `a1` and `a2` can be either array_like sequences of the polynomials' -// coefficients (including coefficients equal to zero), or `poly1d` objects. -// -// Parameters -// ---------- -// a1, a2 : array_like or poly1d -// Minuend and subtrahend polynomials, respectively. -// -// Returns -// ------- -// out : ndarray or poly1d -// Array or `poly1d` object of the difference polynomial's coefficients. -// -// See Also -// -------- -// polyval, polydiv, polymul, polyadd -// -// Examples -// -------- -// .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2) -// -// >>> np.polysub([2, 10, -2], [3, 10, -4]) -// array([-1, 0, 2]) -// -// -// -//go:linkname Polysub py.polysub -func Polysub(a1 *py.Object, a2 *py.Object) *py.Object -// -// Counts the number of non-zero values in the array ``a``. -// -// The word "non-zero" is in reference to the Python 2.x -// built-in method ``__nonzero__()`` (renamed ``__bool__()`` -// in Python 3.x) of Python objects that tests an object's -// "truthfulness". For example, any number is considered -// truthful if it is nonzero, whereas any string is considered -// truthful if it is not the empty string. Thus, this function -// (recursively) counts how many elements in ``a`` (and in -// sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()`` -// method evaluated to ``True``. -// -// Parameters -// ---------- -// a : array_like -// The array for which to count non-zeros. -// axis : int or tuple, optional -// Axis or tuple of axes along which to count non-zeros. -// Default is None, meaning that non-zeros will be counted -// along a flattened version of ``a``. -// -// .. versionadded:: 1.12.0 -// -// keepdims : bool, optional -// If this is set to True, the axes that are counted are left -// in the result as dimensions with size one. With this option, -// the result will broadcast correctly against the input array. -// -// .. versionadded:: 1.19.0 -// -// Returns -// ------- -// count : int or array of int -// Number of non-zero values in the array along a given axis. -// Otherwise, the total number of non-zero values in the array -// is returned. -// -// See Also -// -------- -// nonzero : Return the coordinates of all the non-zero values. -// -// Examples -// -------- -// >>> np.count_nonzero(np.eye(4)) -// 4 -// >>> a = np.array([[0, 1, 7, 0], -// ... [3, 0, 2, 19]]) -// >>> np.count_nonzero(a) -// 5 -// >>> np.count_nonzero(a, axis=0) -// array([1, 1, 2, 1]) -// >>> np.count_nonzero(a, axis=1) -// array([2, 3]) -// >>> np.count_nonzero(a, axis=1, keepdims=True) -// array([[2], -// [3]]) -// -// -//go:linkname CountNonzero py.count_nonzero -func CountNonzero(a *py.Object, axis *py.Object) *py.Object -// -// Return the product of array elements over a given axis. -// -// .. deprecated:: 1.25.0 -// ``product`` is deprecated as of NumPy 1.25.0, and will be -// removed in NumPy 2.0. Please use `prod` instead. -// -// See Also -// -------- -// prod : equivalent function; see for details. -// -// -//go:linkname Product py.product -func Product(__llgo_va_list ...interface{}) *py.Object -// -// Round an array to the given number of decimals. -// -// `~numpy.round_` is a disrecommended backwards-compatibility -// alias of `~numpy.around` and `~numpy.round`. -// -// .. deprecated:: 1.25.0 -// ``round_`` is deprecated as of NumPy 1.25.0, and will be -// removed in NumPy 2.0. Please use `round` instead. -// -// See Also -// -------- -// around : equivalent function; see for details. -// -// -//go:linkname Round_ py.round_ -func Round_(a *py.Object, decimals *py.Object, out *py.Object) *py.Object -// -// Return the shape of an array. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// -// Returns -// ------- -// shape : tuple of ints -// The elements of the shape tuple give the lengths of the -// corresponding array dimensions. -// -// See Also -// -------- -// 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, 3]]) -// (1, 2) -// >>> np.shape([0]) -// (1,) -// >>> np.shape(0) -// () -// -// >>> a = np.array([(1, 2), (3, 4), (5, 6)], -// ... dtype=[('x', 'i4'), ('y', 'i4')]) -// >>> np.shape(a) -// (3,) -// >>> a.shape -// (3,) -// -// -// -//go:linkname Shape py.shape -func Shape(a *py.Object) *py.Object -// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Natural logarithm, element-wise. -// -// The natural logarithm `log` is the inverse of the exponential function, -// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base -// `e`. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The natural logarithm of `x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log10, log2, log1p, emath.log -// -// Notes -// ----- -// 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]`. -// -// 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 -// yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log` is a complex analytical function that -// 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 -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log([1, np.e, np.e**2, 0]) -// array([ 0., 1., 2., -Inf]) -// -//go:linkname Log py.log -func Log(x *py.Object, out *py.Object) *py.Object -// -// Return the scalar type of highest precision of the same kind as the input. -// -// Parameters -// ---------- -// t : dtype or dtype specifier -// The input data type. This can be a `dtype` object or an object that -// is convertible to a `dtype`. -// -// Returns -// ------- -// out : dtype -// The highest precision data type of the same kind (`dtype.kind`) as `t`. -// -// See Also -// -------- -// obj2sctype, mintypecode, sctype2char -// dtype -// -// Examples -// -------- -// >>> np.maximum_sctype(int) -// -// >>> np.maximum_sctype(np.uint8) -// -// >>> np.maximum_sctype(complex) -// # may vary -// -// >>> np.maximum_sctype(str) -// -// -// >>> np.maximum_sctype('i2') -// -// >>> np.maximum_sctype('f4') -// # may vary -// -// -// -//go:linkname MaximumSctype py.maximum_sctype -func MaximumSctype(t *py.Object) *py.Object -// -// Return a description for the given data type code. -// -// Parameters -// ---------- -// char : str -// Data type code. -// -// Returns -// ------- -// out : str -// Description of the input data type code. -// -// See Also -// -------- -// dtype, typecodes -// -// Examples -// -------- -// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q', -// ... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q'] -// >>> for typechar in typechars: -// ... print(typechar, ' : ', np.typename(typechar)) -// ... -// S1 : character -// ? : bool -// B : unsigned char -// D : complex double precision -// G : complex long double precision -// F : complex single precision -// I : unsigned integer -// H : unsigned short -// L : unsigned long integer -// O : object -// Q : unsigned long long integer -// S : string -// U : unicode -// V : void -// b : signed char -// d : double precision -// g : long precision -// f : single precision -// i : integer -// h : short -// l : long integer -// q : long long integer -// -// -// -//go:linkname Typename py.typename -func Typename(char *py.Object) *py.Object -// -// Return the Kaiser window. -// -// The Kaiser window is a taper formed by using a Bessel function. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// beta : float -// Shape parameter for window. -// -// Returns -// ------- -// out : array -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hamming, hanning -// -// Notes -// ----- -// The Kaiser window is defined as -// -// .. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}} -// \right)/I_0(\beta) -// -// with -// -// .. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2}, -// -// where :math:`I_0` is the modified zeroth-order Bessel function. -// -// The Kaiser was named for Jim Kaiser, who discovered a simple -// approximation to the DPSS window based on Bessel functions. The Kaiser -// window is a very good approximation to the Digital Prolate Spheroidal -// Sequence, or Slepian window, which is the transform which maximizes the -// energy in the main lobe of the window relative to total energy. -// -// The Kaiser can approximate many other windows by varying the beta -// parameter. -// -// ==== ======================= -// beta Window shape -// ==== ======================= -// 0 Rectangular -// 5 Similar to a Hamming -// 6 Similar to a Hanning -// 8.6 Similar to a Blackman -// ==== ======================= -// -// A beta value of 14 is probably a good starting point. Note that as beta -// gets large, the window narrows, and so the number of samples needs to be -// large enough to sample the increasingly narrow spike, otherwise NaNs will -// get returned. -// -// Most references to the Kaiser window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. -// -// References -// ---------- -// .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by -// digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285. -// John Wiley and Sons, New York, (1966). -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 177-178. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.kaiser(12, 14) -// array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary -// 2.29737120e-01, 5.99885316e-01, 9.45674898e-01, -// 9.45674898e-01, 5.99885316e-01, 2.29737120e-01, -// 4.65200189e-02, 3.46009194e-03, 7.72686684e-06]) -// -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.kaiser(51, 14) -// >>> plt.plot(window) -// [] -// >>> plt.title("Kaiser window") -// Text(0.5, 1.0, 'Kaiser window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Kaiser window") -// Text(0.5, 1.0, 'Frequency response of Kaiser window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// (-0.5, 0.5, -100.0, ...) # may vary -// >>> plt.show() -// -// -// -//go:linkname Kaiser py.kaiser -func Kaiser(M *py.Object, beta *py.Object) *py.Object -// -// Return the minimum of an array or minimum along an axis. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to operate. By default, 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 : ndarray, optional -// Alternative output array in which to place the result. Must -// be of the same shape and buffer length as the expected output. -// See :ref:`ufuncs-output-type` for more details. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the ``min`` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// initial : scalar, optional -// The maximum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.15.0 -// -// where : array_like of bool, optional -// Elements to compare for the minimum. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// min : ndarray or scalar -// Minimum of `a`. If `axis` is None, the result is a scalar value. -// 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 -// -------- -// amax : -// The maximum value of an array along a given axis, propagating any NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignoring any NaNs. -// minimum : -// Element-wise minimum of two arrays, propagating any NaNs. -// fmin : -// Element-wise minimum of two arrays, ignoring any NaNs. -// argmin : -// Return the indices of the minimum values. -// -// nanmax, maximum, fmax -// -// Notes -// ----- -// NaN values are propagated, that is if at least one item is NaN, the -// corresponding min value will be NaN as well. To ignore NaN values -// (MATLAB behavior), please use nanmin. -// -// Don't use `~numpy.min` for element-wise comparison of 2 arrays; when -// ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than -// ``min(a, axis=0)``. -// -// Examples -// -------- -// >>> a = np.arange(4).reshape((2,2)) -// >>> a -// array([[0, 1], -// [2, 3]]) -// >>> np.min(a) # Minimum of the flattened array -// 0 -// >>> np.min(a, axis=0) # Minima along the first axis -// array([0, 1]) -// >>> np.min(a, axis=1) # Minima along the second axis -// array([0, 2]) -// >>> np.min(a, where=[False, True], initial=10, axis=0) -// array([10, 1]) -// -// >>> b = np.arange(5, dtype=float) -// >>> b[2] = np.NaN -// >>> np.min(b) -// nan -// >>> np.min(b, where=~np.isnan(b), initial=10) -// 0.0 -// >>> np.nanmin(b) -// 0.0 -// -// >>> np.min([[-50], [10]], axis=-1, initial=0) -// array([-50, 0]) -// -// Notice that the initial value is used as one of the elements for which the -// minimum is determined, unlike for the default argument Python's max -// function, which is only used for empty iterables. -// -// Notice that this isn't the same as Python's ``default`` argument. -// -// >>> np.min([6], initial=5) -// 5 -// >>> min([6], default=5) -// 6 -// -// -//go:linkname Min py.min -func Min(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// -// Compute the variance along the specified axis. -// -// Returns the variance of the array elements, a measure of the spread of a -// distribution. The variance is computed for the flattened array by -// default, otherwise over the specified axis. -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose variance is desired. If `a` is not an -// array, a conversion is attempted. -// axis : None or int or tuple of ints, optional -// Axis or axes along which the variance is computed. The default is to -// compute the variance of the flattened array. -// -// .. versionadded:: 1.7.0 -// -// If this is a tuple of ints, a variance is performed over multiple axes, -// instead of a single axis or all the axes as before. -// dtype : data-type, optional -// Type to use in computing the variance. For arrays of integer type -// the default is `float64`; for arrays of float types it is the same as -// the array type. -// out : ndarray, optional -// Alternate output array in which to place the result. It must have -// the same shape as the expected output, but the type is cast if -// necessary. -// ddof : int, optional -// "Delta Degrees of Freedom": the divisor used in the calculation is -// ``N - ddof``, where ``N`` represents the number of elements. By -// default `ddof` is zero. -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `var` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// where : array_like of bool, optional -// Elements to include in the variance. See `~numpy.ufunc.reduce` for -// details. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// variance : ndarray, see dtype parameter above -// If ``out=None``, returns a new array containing the variance; -// otherwise, a reference to the output array is returned. -// -// See Also -// -------- -// std, mean, nanmean, nanstd, nanvar -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// The variance is the average of the squared deviations from the mean, -// i.e., ``var = mean(x)``, where ``x = abs(a - a.mean())**2``. -// -// The mean is typically calculated as ``x.sum() / N``, where ``N = len(x)``. -// If, however, `ddof` is specified, the divisor ``N - ddof`` is used -// instead. In standard statistical practice, ``ddof=1`` provides an -// unbiased estimator of the variance of a hypothetical infinite population. -// ``ddof=0`` provides a maximum likelihood estimate of the variance for -// normally distributed variables. -// -// Note that for complex numbers, the absolute value is taken before -// squaring, so that the result is always real and nonnegative. -// -// For floating-point input, the variance is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for `float32` (see example -// below). Specifying a higher-accuracy accumulator using the ``dtype`` -// keyword can alleviate this issue. -// -// Examples -// -------- -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> np.var(a) -// 1.25 -// >>> np.var(a, axis=0) -// array([1., 1.]) -// >>> np.var(a, axis=1) -// array([0.25, 0.25]) -// -// In single precision, var() can be inaccurate: -// -// >>> a = np.zeros((2, 512*512), dtype=np.float32) -// >>> a[0, :] = 1.0 -// >>> a[1, :] = 0.1 -// >>> np.var(a) -// 0.20250003 -// -// Computing the variance in float64 is more accurate: -// -// >>> np.var(a, dtype=np.float64) -// 0.20249999932944759 # may vary -// >>> ((1-0.55)**2 + (0.1-0.55)**2)/2 -// 0.2025 -// -// Specifying a where argument: -// -// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) -// >>> np.var(a) -// 6.833333333333333 # may vary -// >>> np.var(a, where=[[True], [True], [False]]) -// 4.0 -// -// -// -//go:linkname Var py.var -func Var(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object -// -// Reverse the order of elements in an array along the given axis. -// -// The shape of the array is preserved, but the elements are reordered. -// -// .. versionadded:: 1.12.0 -// -// Parameters -// ---------- -// m : array_like -// Input array. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to flip over. The default, -// axis=None, will flip over all of the axes of the input array. -// If axis is negative it counts from the last to the first axis. -// -// If axis is a tuple of ints, flipping is performed on all of the axes -// specified in the tuple. -// -// .. versionchanged:: 1.15.0 -// None and tuples of axes are supported -// -// Returns -// ------- -// out : array_like -// A view of `m` with the entries of axis reversed. Since a view is -// returned, this operation is done in constant time. -// -// See Also -// -------- -// flipud : Flip an array vertically (axis=0). -// fliplr : Flip an array horizontally (axis=1). -// -// Notes -// ----- -// flip(m, 0) is equivalent to flipud(m). -// -// flip(m, 1) is equivalent to fliplr(m). -// -// flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n. -// -// flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all -// positions. -// -// flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at -// position 0 and position 1. -// -// Examples -// -------- -// >>> A = np.arange(8).reshape((2,2,2)) -// >>> A -// array([[[0, 1], -// [2, 3]], -// [[4, 5], -// [6, 7]]]) -// >>> np.flip(A, 0) -// array([[[4, 5], -// [6, 7]], -// [[0, 1], -// [2, 3]]]) -// >>> np.flip(A, 1) -// array([[[2, 3], -// [0, 1]], -// [[6, 7], -// [4, 5]]]) -// >>> np.flip(A) -// array([[[7, 6], -// [5, 4]], -// [[3, 2], -// [1, 0]]]) -// >>> np.flip(A, (0, 2)) -// array([[[5, 4], -// [7, 6]], -// [[1, 0], -// [3, 2]]]) -// >>> A = np.random.randn(3,4,5) -// >>> np.all(np.flip(A,2) == A[:,:,::-1,...]) -// True -// -// -//go:linkname Flip py.flip -func Flip(m *py.Object, axis *py.Object) *py.Object -// -// Split an array into multiple sub-arrays. -// -// Please refer to the ``split`` documentation. The only difference -// between these functions is that ``array_split`` allows -// `indices_or_sections` to be an integer that does *not* equally -// divide the axis. For an array of length l that should be split -// into n sections, it returns l % n sub-arrays of size l//n + 1 -// and the rest of size l//n. -// -// See Also -// -------- -// split : Split array into multiple sub-arrays of equal size. -// -// Examples -// -------- -// >>> x = np.arange(8.0) -// >>> np.array_split(x, 3) -// [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])] -// -// >>> x = np.arange(9) -// >>> np.array_split(x, 4) -// [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])] -// -// -// -//go:linkname ArraySplit py.array_split -func ArraySplit(ary *py.Object, indicesOrSections *py.Object, axis *py.Object) *py.Object -// -// Evaluate a polynomial at specific values. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// If `p` is of length N, this function returns the value: -// -// ``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]`` -// -// If `x` is a sequence, then ``p(x)`` is returned for each element of ``x``. -// If `x` is another polynomial then the composite polynomial ``p(x(t))`` -// is returned. -// -// Parameters -// ---------- -// p : array_like or poly1d object -// 1D array of polynomial coefficients (including coefficients equal -// to zero) from highest degree to the constant term, or an -// instance of poly1d. -// x : array_like or poly1d object -// A number, an array of numbers, or an instance of poly1d, at -// which to evaluate `p`. -// -// Returns -// ------- -// values : ndarray or poly1d -// If `x` is a poly1d instance, the result is the composition of the two -// polynomials, i.e., `x` is "substituted" in `p` and the simplified -// result is returned. In addition, the type of `x` - array_like or -// poly1d - governs the type of the output: `x` array_like => `values` -// array_like, `x` a poly1d object => `values` is also. -// -// See Also -// -------- -// poly1d: A polynomial class. -// -// Notes -// ----- -// Horner's scheme [1]_ is used to evaluate the polynomial. Even so, -// for polynomials of high degree the values may be inaccurate due to -// rounding errors. Use carefully. -// -// If `x` is a subtype of `ndarray` the return value will be of the same type. -// -// References -// ---------- -// .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng. -// trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand -// Reinhold Co., 1985, pg. 720. -// -// Examples -// -------- -// >>> np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1 -// 76 -// >>> np.polyval([3,0,1], np.poly1d(5)) -// poly1d([76]) -// >>> np.polyval(np.poly1d([3,0,1]), 5) -// 76 -// >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5)) -// poly1d([76]) -// -// -// -//go:linkname Polyval py.polyval -func Polyval(p *py.Object, x *py.Object) *py.Object -// -// Return the indices of the maximum values in the specified axis ignoring -// NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the -// results cannot be trusted if a slice contains only NaNs and -Infs. -// -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : int, optional -// Axis along which to operate. By default flattened input is used. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. -// -// .. versionadded:: 1.22.0 -// 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 array. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// index_array : ndarray -// An array of indices or a single index value. -// -// See Also -// -------- -// argmax, nanargmin -// -// Examples -// -------- -// >>> a = np.array([[np.nan, 4], [2, 3]]) -// >>> np.argmax(a) -// 0 -// >>> np.nanargmax(a) -// 1 -// >>> np.nanargmax(a, axis=0) -// array([1, 0]) -// >>> np.nanargmax(a, axis=1) -// array([1, 1]) -// -// -// -//go:linkname Nanargmax py.nanargmax -func Nanargmax(a *py.Object, axis *py.Object, out *py.Object) *py.Object -// -// Move axes of an array to new positions. -// -// Other axes remain in their original order. -// -// .. versionadded:: 1.11.0 -// -// Parameters -// ---------- -// a : np.ndarray -// The array whose axes should be reordered. -// source : int or sequence of int -// Original positions of the axes to move. These must be unique. -// destination : int or sequence of int -// Destination positions for each of the original axes. These must also be -// unique. -// -// Returns -// ------- -// result : np.ndarray -// Array with moved axes. This array is a view of the input array. -// -// See Also -// -------- -// transpose : Permute the dimensions of an array. -// swapaxes : Interchange two axes of an array. -// -// Examples -// -------- -// >>> x = np.zeros((3, 4, 5)) -// >>> np.moveaxis(x, 0, -1).shape -// (4, 5, 3) -// >>> np.moveaxis(x, -1, 0).shape -// (5, 3, 4) -// -// These all achieve the same result: -// -// >>> np.transpose(x).shape -// (5, 4, 3) -// >>> np.swapaxes(x, 0, -1).shape -// (5, 4, 3) -// >>> np.moveaxis(x, [0, 1], [-1, -2]).shape -// (5, 4, 3) -// >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape -// (5, 4, 3) -// -// -// -//go:linkname Moveaxis py.moveaxis -func Moveaxis(a *py.Object, source *py.Object, destination *py.Object) *py.Object -// -// Replace NaN with zero and infinity with large finite numbers (default -// 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 -// value in `neginf` keyword. -// -// For complex dtypes, the above is applied to each of the real and -// imaginary components of `x` separately. -// -// If `x` is not inexact, then no replacements are made. -// -// Parameters -// ---------- -// x : scalar or array_like -// Input data. -// copy : bool, optional -// Whether to create a copy of `x` (True) or to replace values -// 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 -// 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 -// 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 -// passed then negative infinity values will be replaced with a very -// small (or negative) number. -// -// .. versionadded:: 1.17 -// -// -// -// Returns -// ------- -// out : ndarray -// `x`, with the non-finite values replaced. If `copy` is False, this may -// be `x` itself. -// -// See Also -// -------- -// isinf : Shows which elements are positive or negative infinity. -// isneginf : Shows which elements are negative infinity. -// isposinf : Shows which elements are positive infinity. -// isnan : Shows which elements are Not a Number (NaN). -// isfinite : Shows which elements are finite (not NaN, not infinity) -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// -// Examples -// -------- -// >>> np.nan_to_num(np.inf) -// 1.7976931348623157e+308 -// >>> np.nan_to_num(-np.inf) -// -1.7976931348623157e+308 -// >>> np.nan_to_num(np.nan) -// 0.0 -// >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128]) -// >>> np.nan_to_num(x) -// 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, -// -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 -// -1.28000000e+002, 1.28000000e+002]) -// >>> np.nan_to_num(y) -// array([ 1.79769313e+308 +0.00000000e+000j, # may vary -// 0.00000000e+000 +0.00000000e+000j, -// 0.00000000e+000 +1.79769313e+308j]) -// >>> np.nan_to_num(y, nan=111111, posinf=222222) -// array([222222.+111111.j, 111111. +0.j, 111111.+222222.j]) -// -// -//go:linkname NanToNum py.nan_to_num -func NanToNum(x *py.Object, copy *py.Object, nan *py.Object, posinf *py.Object, neginf *py.Object) *py.Object -// -// Return the Hamming window. -// -// The Hamming window is a taper formed by using a weighted cosine. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value -// one appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, blackman, hanning, kaiser -// -// Notes -// ----- -// The Hamming window is defined as -// -// .. 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 -// and is described in Blackman and Tukey. It was recommended for -// smoothing the truncated autocovariance function in the time domain. -// Most references to the Hamming window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. -// -// References -// ---------- -// .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power -// spectra, Dover Publications, New York. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The -// University of Alberta Press, 1975, pp. 109-110. -// .. [3] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 425. -// -// Examples -// -------- -// >>> np.hamming(12) -// array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary -// 0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909, -// 0.15302337, 0.08 ]) -// -// Plot the window and the frequency response: -// -// >>> import matplotlib.pyplot as plt -// >>> from numpy.fft import fft, fftshift -// >>> window = np.hamming(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Hamming window") -// Text(0.5, 1.0, 'Hamming window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> response = 20 * np.log10(mag) -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Hamming window") -// Text(0.5, 1.0, 'Frequency response of Hamming window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> plt.axis('tight') -// ... -// >>> plt.show() -// -// -// -//go:linkname Hamming py.hamming -func Hamming(M *py.Object) *py.Object -// -// Return the indices of the minimum values in the specified axis ignoring -// NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results -// cannot be trusted if a slice contains only NaNs and Infs. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : int, optional -// Axis along which to operate. By default flattened input is used. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. -// -// .. versionadded:: 1.22.0 -// 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 array. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// index_array : ndarray -// An array of indices or a single index value. -// -// See Also -// -------- -// argmin, nanargmax -// -// Examples -// -------- -// >>> a = np.array([[np.nan, 4], [2, 3]]) -// >>> np.argmin(a) -// 0 -// >>> np.nanargmin(a) -// 2 -// >>> np.nanargmin(a, axis=0) -// array([1, 1]) -// >>> np.nanargmin(a, axis=1) -// array([1, 0]) -// -// -// -//go:linkname Nanargmin py.nanargmin -func Nanargmin(a *py.Object, axis *py.Object, out *py.Object) *py.Object -// -// copyto(dst, src, casting='same_kind', where=True) -// -// Copies values from one array to another, broadcasting as necessary. -// -// Raises a TypeError if the `casting` rule is violated, and if -// `where` is provided, it selects which elements to copy. -// -// .. versionadded:: 1.7.0 -// -// Parameters -// ---------- -// dst : ndarray -// The array into which values are copied. -// src : array_like -// The array from which values are copied. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur when copying. -// -// * 'no' means the data types should not be cast at all. -// * 'equiv' means only byte-order changes are allowed. -// * 'safe' means only casts which can preserve values are allowed. -// * 'same_kind' means only safe casts or casts within a kind, -// like float64 to float32, are allowed. -// * 'unsafe' means any data conversions may be done. -// where : array_like of bool, optional -// 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]]) -// -// -// -//go:linkname Copyto py.copyto -func Copyto(dst *py.Object, src *py.Object, casting *py.Object, where *py.Object) *py.Object -// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 AND x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical AND operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or, logical_not, logical_xor -// bitwise_and -// -// Examples -// -------- -// >>> np.logical_and(True, False) -// False -// >>> np.logical_and([True, False], [False, False]) -// array([False, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_and(x>1, x<4) -// array([False, False, True, True, False]) -// -// -// The ``&`` operator can be used as a shorthand for ``np.logical_and`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a & b -// array([False, False]) -// -//go:linkname LogicalAnd py.logical_and -func LogicalAnd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical negative, element-wise. -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = -x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.negative([1.,-1.]) -// array([-1., 1.]) -// -// The unary ``-`` operator can be used as a shorthand for ``np.negative`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> -x1 -// array([-1., 1.]) -// -//go:linkname Negative py.negative -func Negative(x *py.Object, out *py.Object) *py.Object -// right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the right. -// -// Bits are shifted to the right `x2`. Because the internal -// representation of numbers is in binary format, this operation is -// equivalent to dividing `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like, int -// Input values. -// x2 : array_like, int -// Number of bits to remove at the right of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray, int -// Return `x1` with bits shifted `x2` times to the right. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// left_shift : Shift the bits of an integer to the left. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(10) -// '1010' -// >>> np.right_shift(10, 1) -// 5 -// >>> np.binary_repr(5) -// '101' -// -// >>> np.right_shift(10, [1,2,3]) -// array([5, 2, 1]) -// -// The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on -// ndarrays. -// -// >>> x1 = 10 -// >>> x2 = np.array([1,2,3]) -// >>> x1 >> x2 -// array([5, 2, 1]) -// -//go:linkname RightShift py.right_shift -func RightShift(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Set how floating-point errors are handled. -// -// Note that operations on integer scalar types (such as `int16`) are -// handled like floating point, and are affected by these settings. -// -// Parameters -// ---------- -// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Set treatment for all types of floating-point errors at once: -// -// - ignore: Take no action when the exception occurs. -// - warn: Print a `RuntimeWarning` (via the Python `warnings` module). -// - raise: Raise a `FloatingPointError`. -// - call: Call a function specified using the `seterrcall` function. -// - print: Print a warning directly to ``stdout``. -// - log: Record error in a Log object specified by `seterrcall`. -// -// The default is not to change the current behavior. -// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for division by zero. -// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point overflow. -// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for floating-point underflow. -// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional -// Treatment for invalid floating-point operation. -// -// Returns -// ------- -// old_settings : dict -// Dictionary containing the old settings. -// -// See also -// -------- -// seterrcall : Set a callback function for the 'call' mode. -// geterr, geterrcall, errstate -// -// Notes -// ----- -// The floating-point exceptions are defined in the IEEE 754 standard [1]_: -// -// - Division by zero: infinite result obtained from finite numbers. -// - Overflow: result too large to be expressed. -// - Underflow: result so close to zero that some precision -// was lost. -// - Invalid operation: result is not an expressible number, typically -// indicates that a NaN was produced. -// -// .. [1] https://en.wikipedia.org/wiki/IEEE_754 -// -// Examples -// -------- -// >>> old_settings = np.seterr(all='ignore') #seterr to known value -// >>> np.seterr(over='raise') -// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} -// >>> np.seterr(**old_settings) # reset to default -// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} -// -// >>> np.int16(32000) * np.int16(3) -// 30464 -// >>> old_settings = np.seterr(all='warn', over='raise') -// >>> np.int16(32000) * np.int16(3) -// Traceback (most recent call last): -// File "", line 1, in -// FloatingPointError: overflow encountered in scalar multiply -// -// >>> old_settings = np.seterr(all='print') -// >>> np.geterr() -// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} -// >>> np.int16(32000) * np.int16(3) -// 30464 -// -// -// -//go:linkname Seterr py.seterr -func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *py.Object -// -// Assemble an nd-array from nested lists of blocks. -// -// Blocks in the innermost lists are concatenated (see `concatenate`) along -// the last dimension (-1), then these are concatenated along the -// second-last dimension (-2), and so on until the outermost list is reached. -// -// Blocks can be of any dimension, but will not be broadcasted using the normal -// rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim`` -// the same for all blocks. This is primarily useful for working with scalars, -// and means that code like ``np.block([v, 1])`` is valid, where -// ``v.ndim == 1``. -// -// When the nested list is two levels deep, this allows block matrices to be -// constructed from their components. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// arrays : nested list of array_like or scalars (but not tuples) -// If passed a single ndarray or scalar (a nested list of depth 0), this -// is returned unmodified (and not copied). -// -// Elements shapes must match along the appropriate axes (without -// broadcasting), but leading 1s will be prepended to the shape as -// necessary to make the dimensions match. -// -// Returns -// ------- -// block_array : ndarray -// The array assembled from the given blocks. -// -// The dimensionality of the output is equal to the greatest of: -// * the dimensionality of all the inputs -// * the depth to which the input list is nested -// -// Raises -// ------ -// ValueError -// * If list depths are mismatched - for instance, ``[[a, b], c]`` is -// illegal, and should be spelt ``[[a, b], [c]]`` -// * If lists are empty - for instance, ``[[a, b], []]`` -// -// See Also -// -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// vstack : Stack arrays in sequence vertically (row wise). -// hstack : Stack arrays in sequence horizontally (column wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// vsplit : Split an array into multiple sub-arrays vertically (row-wise). -// -// Notes -// ----- -// -// When called with only scalars, ``np.block`` is equivalent to an ndarray -// call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to -// ``np.array([[1, 2], [3, 4]])``. -// -// This function does not enforce that the blocks lie on a fixed grid. -// ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form:: -// -// AAAbb -// AAAbb -// cccDD -// -// But is also allowed to produce, for some ``a, b, c, d``:: -// -// AAAbb -// AAAbb -// cDDDD -// -// Since concatenation happens along the last axis first, `block` is _not_ -// capable of producing the following directly:: -// -// AAAbb -// cccbb -// cccDD -// -// Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is -// equivalent to ``np.block([[A, B, ...], [p, q, ...]])``. -// -// Examples -// -------- -// The most common use of this function is to build a block matrix -// -// >>> A = np.eye(2) * 2 -// >>> B = np.eye(3) * 3 -// >>> np.block([ -// ... [A, np.zeros((2, 3))], -// ... [np.ones((3, 2)), B ] -// ... ]) -// array([[2., 0., 0., 0., 0.], -// [0., 2., 0., 0., 0.], -// [1., 1., 3., 0., 0.], -// [1., 1., 0., 3., 0.], -// [1., 1., 0., 0., 3.]]) -// -// With a list of depth 1, `block` can be used as `hstack` -// -// >>> np.block([1, 2, 3]) # hstack([1, 2, 3]) -// array([1, 2, 3]) -// -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.block([a, b, 10]) # hstack([a, b, 10]) -// array([ 1, 2, 3, 4, 5, 6, 10]) -// -// >>> A = np.ones((2, 2), int) -// >>> B = 2 * A -// >>> np.block([A, B]) # hstack([A, B]) -// array([[1, 1, 2, 2], -// [1, 1, 2, 2]]) -// -// With a list of depth 2, `block` can be used in place of `vstack`: -// -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.block([[a], [b]]) # vstack([a, b]) -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// >>> A = np.ones((2, 2), int) -// >>> B = 2 * A -// >>> np.block([[A], [B]]) # vstack([A, B]) -// array([[1, 1], -// [1, 1], -// [2, 2], -// [2, 2]]) -// -// It can also be used in places of `atleast_1d` and `atleast_2d` -// -// >>> a = np.array(0) -// >>> b = np.array([1]) -// >>> np.block([a]) # atleast_1d(a) -// array([0]) -// >>> np.block([b]) # atleast_1d(b) -// array([1]) -// -// >>> np.block([[a]]) # atleast_2d(a) -// array([[0]]) -// >>> np.block([[b]]) # atleast_2d(b) -// array([[1]]) -// -// -// -// -//go:linkname Block py.block -func Block(arrays *py.Object) *py.Object -// -// One-dimensional linear interpolation for monotonically increasing sample points. -// -// Returns the one-dimensional piecewise linear interpolant to a function -// with given discrete data points (`xp`, `fp`), evaluated at `x`. -// -// Parameters -// ---------- -// x : array_like -// The x-coordinates at which to evaluate the interpolated values. -// -// xp : 1-D sequence of floats -// The x-coordinates of the data points, must be increasing if argument -// `period` is not specified. Otherwise, `xp` is internally sorted after -// normalizing the periodic boundaries with ``xp = xp % period``. -// -// fp : 1-D sequence of float or complex -// The y-coordinates of the data points, same length as `xp`. -// -// left : optional float or complex corresponding to fp -// Value to return for `x < xp[0]`, default is `fp[0]`. -// -// right : optional float or complex corresponding to fp -// Value to return for `x > xp[-1]`, default is `fp[-1]`. -// -// period : None or float, optional -// A period for the x-coordinates. This parameter allows the proper -// interpolation of angular x-coordinates. Parameters `left` and `right` -// are ignored if `period` is specified. -// -// .. versionadded:: 1.10.0 -// -// Returns -// ------- -// y : float or complex (corresponding to fp) or ndarray -// The interpolated values, same shape as `x`. -// -// Raises -// ------ -// ValueError -// If `xp` and `fp` have different length -// If `xp` or `fp` are not 1-D sequences -// If `period == 0` -// -// See Also -// -------- -// scipy.interpolate -// -// Warnings -// -------- -// The x-coordinate sequence is expected to be increasing, but this is not -// explicitly enforced. However, if the sequence `xp` is non-increasing, -// interpolation results are meaningless. -// -// Note that, since NaN is unsortable, `xp` also cannot contain NaNs. -// -// A simple check for `xp` being strictly increasing is:: -// -// np.all(np.diff(xp) > 0) -// -// Examples -// -------- -// >>> xp = [1, 2, 3] -// >>> fp = [3, 2, 0] -// >>> np.interp(2.5, xp, fp) -// 1.0 -// >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp) -// array([3. , 3. , 2.5 , 0.56, 0. ]) -// >>> UNDEF = -99.0 -// >>> np.interp(3.14, xp, fp, right=UNDEF) -// -99.0 -// -// Plot an interpolant to the sine function: -// -// >>> x = np.linspace(0, 2*np.pi, 10) -// >>> y = np.sin(x) -// >>> xvals = np.linspace(0, 2*np.pi, 50) -// >>> yinterp = np.interp(xvals, x, y) -// >>> import matplotlib.pyplot as plt -// >>> plt.plot(x, y, 'o') -// [] -// >>> plt.plot(xvals, yinterp, '-x') -// [] -// >>> plt.show() -// -// Interpolation with periodic x-coordinates: -// -// >>> x = [-180, -170, -185, 185, -10, -5, 0, 365] -// >>> xp = [190, -190, 350, -350] -// >>> fp = [5, 10, 3, 4] -// >>> np.interp(x, xp, fp, period=360) -// array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75]) -// -// Complex interpolation: -// -// >>> x = [1.5, 4.0] -// >>> xp = [2,3,5] -// >>> fp = [1.0j, 0, 2+3j] -// >>> np.interp(x, xp, fp) -// array([0.+1.j , 1.+1.5j]) -// -// -// -//go:linkname Interp py.interp -func Interp(x *py.Object, xp *py.Object, fp *py.Object, left *py.Object, right *py.Object, period *py.Object) *py.Object -// -// Put values into the destination array by matching 1d index and data slices. -// -// This iterates over matching 1d slices oriented along the specified axis in -// the index and data arrays, and uses the former to place values into the -// latter. These slices can be different lengths. -// -// Functions returning an index along an axis, like `argsort` and -// `argpartition`, produce suitable indices for this function. -// -// .. versionadded:: 1.15.0 -// -// Parameters -// ---------- -// arr : ndarray (Ni..., M, Nk...) -// Destination array. -// indices : ndarray (Ni..., J, Nk...) -// Indices to change along each 1d slice of `arr`. This must match the -// dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast -// against `arr`. -// values : array_like (Ni..., J, Nk...) -// values to insert at those indices. Its shape and dimension are -// broadcast to match that of `indices`. -// axis : int -// The axis to take 1d slices along. If axis is None, the destination -// array is treated as if a flattened 1d view had been created of it. -// -// Notes -// ----- -// This is equivalent to (but faster than) the following use of `ndindex` and -// `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: -// -// Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] -// J = indices.shape[axis] # Need not equal M -// -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// a_1d = a [ii + s_[:,] + kk] -// indices_1d = indices[ii + s_[:,] + kk] -// values_1d = values [ii + s_[:,] + kk] -// for j in range(J): -// a_1d[indices_1d[j]] = values_1d[j] -// -// Equivalently, eliminating the inner loop, the last two lines would be:: -// -// a_1d[indices_1d] = values_1d -// -// See Also -// -------- -// take_along_axis : -// Take values from the input array by matching 1d index and data slices -// -// Examples -// -------- -// -// For this sample array -// -// >>> a = np.array([[10, 30, 20], [60, 40, 50]]) -// -// We can replace the maximum values with: -// -// >>> ai = np.argmax(a, axis=1, keepdims=True) -// >>> ai -// array([[1], -// [0]]) -// >>> np.put_along_axis(a, ai, 99, axis=1) -// >>> a -// array([[10, 99, 20], -// [99, 40, 50]]) -// -// -// -//go:linkname PutAlongAxis py.put_along_axis -func PutAlongAxis(arr *py.Object, indices *py.Object, values *py.Object, axis *py.Object) *py.Object -// -// Return the minimum of an array or minimum along an axis. -// -// `amin` is an alias of `~numpy.min`. -// -// See Also -// -------- -// min : alias of this function -// ndarray.min : equivalent method -// -// -//go:linkname Amin py.amin -func Amin(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// -// Return the maximum of an array or maximum along an axis. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to operate. By default, 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 : ndarray, optional -// Alternative output array in which to place the result. Must -// be of the same shape and buffer length as the expected output. -// See :ref:`ufuncs-output-type` for more details. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the ``max`` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// initial : scalar, optional -// The minimum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.15.0 -// -// where : array_like of bool, optional -// Elements to compare for the maximum. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// max : ndarray or scalar -// Maximum of `a`. If `axis` is None, the result is a scalar value. -// 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 -// -------- -// amin : -// The minimum value of an array along a given axis, propagating any NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignoring any NaNs. -// maximum : -// Element-wise maximum of two arrays, propagating any NaNs. -// fmax : -// Element-wise maximum of two arrays, ignoring any NaNs. -// argmax : -// Return the indices of the maximum values. -// -// nanmin, minimum, fmin -// -// Notes -// ----- -// NaN values are propagated, that is if at least one item is NaN, the -// corresponding max value will be NaN as well. To ignore NaN values -// (MATLAB behavior), please use nanmax. -// -// Don't use `~numpy.max` for element-wise comparison of 2 arrays; when -// ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than -// ``max(a, axis=0)``. -// -// Examples -// -------- -// >>> a = np.arange(4).reshape((2,2)) -// >>> a -// array([[0, 1], -// [2, 3]]) -// >>> np.max(a) # Maximum of the flattened array -// 3 -// >>> np.max(a, axis=0) # Maxima along the first axis -// array([2, 3]) -// >>> np.max(a, axis=1) # Maxima along the second axis -// array([1, 3]) -// >>> np.max(a, where=[False, True], initial=-1, axis=0) -// array([-1, 3]) -// >>> b = np.arange(5, dtype=float) -// >>> b[2] = np.NaN -// >>> np.max(b) -// nan -// >>> np.max(b, where=~np.isnan(b), initial=-1) -// 4.0 -// >>> np.nanmax(b) -// 4.0 -// -// You can use an initial value to compute the maximum of an empty slice, or -// to initialize it to a different value: -// -// >>> np.max([[-50], [10]], axis=-1, initial=0) -// array([ 0, 10]) -// -// Notice that the initial value is used as one of the elements for which the -// maximum is determined, unlike for the default argument Python's max -// function, which is only used for empty iterables. -// -// >>> np.max([5], initial=6) -// 6 -// >>> max([5], default=6) -// 5 -// -// -//go:linkname Max py.max -func Max(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// -// Test element-wise for negative infinity, return result as bool array. -// -// Parameters -// ---------- -// x : array_like -// The input array. -// out : array_like, optional -// A location into which the result is stored. If provided, it must have a -// shape that the input broadcasts to. If not provided or None, a -// freshly-allocated boolean array is returned. -// -// Returns -// ------- -// out : ndarray -// A boolean array with the same dimensions as the input. -// If second argument is not supplied then a numpy boolean array is -// returned with values True where the corresponding element of the -// input is negative infinity and values False where the element of -// the input is not negative infinity. -// -// If a second argument is supplied the result is stored there. If the -// type of that array is a numeric type the result is represented as -// zeros and ones, if the type is boolean then as False and True. The -// return value `out` is then a reference to that array. -// -// See Also -// -------- -// isinf, isposinf, isnan, isfinite -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). -// -// Errors result if the second argument is also supplied when x is a scalar -// input, if first and second arguments have different shapes, or if the -// first argument has complex values. -// -// Examples -// -------- -// >>> np.isneginf(np.NINF) -// True -// >>> np.isneginf(np.inf) -// False -// >>> np.isneginf(np.PINF) -// False -// >>> np.isneginf([-np.inf, 0., np.inf]) -// array([ True, False, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isneginf(x, y) -// array([1, 0, 0]) -// >>> y -// array([1, 0, 0]) -// -// -// -//go:linkname Isneginf py.isneginf -func Isneginf(x *py.Object, out *py.Object) *py.Object -// -// Returns the quotient and remainder of polynomial division. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// The input arrays are the coefficients (including any coefficients -// equal to zero) of the "numerator" (dividend) and "denominator" -// (divisor) polynomials, respectively. -// -// Parameters -// ---------- -// u : array_like or poly1d -// Dividend polynomial's coefficients. -// -// v : array_like or poly1d -// Divisor polynomial's coefficients. -// -// Returns -// ------- -// q : ndarray -// Coefficients, including those equal to zero, of the quotient. -// r : ndarray -// Coefficients, including those equal to zero, of the remainder. -// -// See Also -// -------- -// poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub -// polyval -// -// Notes -// ----- -// Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need -// not equal `v.ndim`. In other words, all four possible combinations - -// ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``, -// ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work. -// -// Examples -// -------- -// .. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25 -// -// >>> x = np.array([3.0, 5.0, 2.0]) -// >>> y = np.array([2.0, 1.0]) -// >>> np.polydiv(x, y) -// (array([1.5 , 1.75]), array([0.25])) -// -// -// -//go:linkname Polydiv py.polydiv -func Polydiv(u *py.Object, v *py.Object) *py.Object -// -// Determine if a class is a subclass of a second class. -// -// `issubclass_` is equivalent to the Python built-in ``issubclass``, -// except that it returns False instead of raising a TypeError if one -// of the arguments is not a class. -// -// Parameters -// ---------- -// arg1 : class -// Input class. True is returned if `arg1` is a subclass of `arg2`. -// arg2 : class or tuple of classes. -// Input class. If a tuple of classes, True is returned if `arg1` is a -// subclass of any of the tuple elements. -// -// Returns -// ------- -// out : bool -// Whether `arg1` is a subclass of `arg2` or not. -// -// See Also -// -------- -// issubsctype, issubdtype, issctype -// -// Examples -// -------- -// >>> np.issubclass_(np.int32, int) -// False -// >>> np.issubclass_(np.int32, float) -// False -// >>> np.issubclass_(np.float64, float) -// True -// -// -// -//go:linkname Issubclass_ py.issubclass_ -func Issubclass_(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Determine if the first argument is a subclass of the second argument. -// -// Parameters -// ---------- -// arg1, arg2 : dtype or dtype specifier -// Data-types. -// -// Returns -// ------- -// out : bool -// The result. -// -// See Also -// -------- -// issctype, issubdtype, obj2sctype -// -// Examples -// -------- -// >>> np.issubsctype('S8', str) -// False -// >>> np.issubsctype(np.array([1]), int) -// True -// >>> np.issubsctype(np.array([1]), float) -// False -// -// -// -//go:linkname Issubsctype py.issubsctype -func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// Return the maximum of an array or maximum along an axis, ignoring any -// NaNs. When all-NaN slices are encountered a ``RuntimeWarning`` is -// raised and NaN is returned for that slice. -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose maximum is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the maximum is computed. The default is to compute -// the maximum of the flattened array. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. -// -// .. versionadded:: 1.8.0 -// 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`. -// -// If the value is anything but the default, then -// `keepdims` will be passed through to the `max` method -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// -// .. versionadded:: 1.8.0 -// initial : scalar, optional -// The minimum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to compare for the maximum. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// nanmax : ndarray -// An array with the same shape as `a`, with the specified axis removed. -// If `a` is a 0-d array, or if axis is None, an ndarray scalar is -// returned. The same dtype as `a` is returned. -// -// See Also -// -------- -// nanmin : -// The minimum value of an array along a given axis, ignoring any NaNs. -// amax : -// The maximum value of an array along a given axis, propagating any NaNs. -// fmax : -// Element-wise maximum of two arrays, ignoring any NaNs. -// maximum : -// Element-wise maximum of two arrays, propagating any NaNs. -// isnan : -// Shows which elements are Not a Number (NaN). -// isfinite: -// Shows which elements are neither NaN nor infinity. -// -// amin, fmin, minimum -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// Positive infinity is treated as a very large number and negative -// infinity is treated as a very small (i.e. negative) number. -// -// If the input has a integer type the function is equivalent to np.max. -// -// Examples -// -------- -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nanmax(a) -// 3.0 -// >>> np.nanmax(a, axis=0) -// array([3., 2.]) -// >>> np.nanmax(a, axis=1) -// array([2., 3.]) -// -// When positive infinity and negative infinity are present: -// -// >>> np.nanmax([1, 2, np.nan, np.NINF]) -// 2.0 -// >>> np.nanmax([1, 2, np.nan, np.inf]) -// inf -// -// -// -//go:linkname Nanmax py.nanmax -func Nanmax(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// -// Compute the arithmetic mean along the specified axis, ignoring NaNs. -// -// Returns the average of the array elements. The average is taken over -// the flattened array by default, otherwise over the specified axis. -// `float64` intermediate and return values are used for integer inputs. -// -// For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised. -// -// .. versionadded:: 1.8.0 -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose mean is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the means are computed. The default is to compute -// the mean of the flattened array. -// dtype : data-type, optional -// Type to use in computing the mean. For integer inputs, the default -// is `float64`; for inexact inputs, it is the same as the input -// dtype. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. -// 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`. -// -// If the value is anything but the default, then -// `keepdims` will be passed through to the `mean` or `sum` methods -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// where : array_like of bool, optional -// Elements to include in the mean. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// m : ndarray, see dtype parameter above -// If `out=None`, returns a new array containing the mean values, -// otherwise a reference to the output array is returned. Nan is -// returned for slices that contain only NaNs. -// -// See Also -// -------- -// average : Weighted average -// mean : Arithmetic mean taken while not ignoring NaNs -// var, nanvar -// -// Notes -// ----- -// The arithmetic mean is the sum of the non-NaN elements along the axis -// divided by the number of non-NaN elements. -// -// Note that for floating-point input, the mean is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for `float32`. Specifying a -// higher-precision accumulator using the `dtype` keyword can alleviate -// this issue. -// -// Examples -// -------- -// >>> a = np.array([[1, np.nan], [3, 4]]) -// >>> np.nanmean(a) -// 2.6666666666666665 -// >>> np.nanmean(a, axis=0) -// array([2., 4.]) -// >>> np.nanmean(a, axis=1) -// array([1., 3.5]) # may vary -// -// -// -//go:linkname Nanmean py.nanmean -func Nanmean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object) *py.Object -// -// putmask(a, mask, values) -// -// Changes elements of an array based on conditional and input values. -// -// Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``. -// -// If `values` is not the same size as `a` and `mask` then it will repeat. -// This gives behavior different from ``a[mask] = values``. -// -// Parameters -// ---------- -// a : ndarray -// Target array. -// mask : array_like -// Boolean mask array. It has to be the same shape as `a`. -// values : array_like -// Values to put into `a` where `mask` is True. If `values` is smaller -// than `a` it will be repeated. -// -// See Also -// -------- -// place, put, take, copyto -// -// Examples -// -------- -// >>> x = np.arange(6).reshape(2, 3) -// >>> np.putmask(x, x>2, x**2) -// >>> x -// array([[ 0, 1, 2], -// [ 9, 16, 25]]) -// -// If `values` is smaller than `a` it is repeated: -// -// >>> x = np.arange(5) -// >>> np.putmask(x, x>1, [-33, -44]) -// >>> x -// array([ 0, 1, -33, -44, -33]) -// -// -// -//go:linkname Putmask py.putmask -func Putmask(a *py.Object, mask *py.Object, values *py.Object) *py.Object -// -// Returns the indices that would sort an array. -// -// Perform an indirect sort along the given axis using the algorithm specified -// by the `kind` keyword. It returns an array of indices of the same shape as -// `a` that index data along the given axis in sorted order. -// -// Parameters -// ---------- -// a : array_like -// Array to sort. -// axis : int or None, optional -// Axis along which to sort. The default is -1 (the last axis). If None, -// the flattened array is used. -// kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional -// Sorting algorithm. The default is 'quicksort'. Note that both 'stable' -// and 'mergesort' use timsort under the covers and, in general, the -// actual implementation will vary with data type. The 'mergesort' option -// is retained for backwards compatibility. -// -// .. versionchanged:: 1.15.0. -// The 'stable' option was added. -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument specifies -// which fields to compare first, second, etc. A single field can -// be specified as a string, and not all fields need be specified, -// but unspecified fields will still be used, in the order in which -// they come up in the dtype, to break ties. -// -// Returns -// ------- -// index_array : ndarray, int -// Array of indices that sort `a` along the specified `axis`. -// If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`. -// More generally, ``np.take_along_axis(a, index_array, axis=axis)`` -// always yields the sorted `a`, irrespective of dimensionality. -// -// See Also -// -------- -// sort : Describes sorting algorithms used. -// lexsort : Indirect stable sort with multiple keys. -// ndarray.sort : Inplace sort. -// argpartition : Indirect partial sort. -// take_along_axis : Apply ``index_array`` from argsort -// to an array as if by calling sort. -// -// Notes -// ----- -// See `sort` for notes on the different sorting algorithms. -// -// As of NumPy 1.4.0 `argsort` works with real/complex arrays containing -// nan values. The enhanced sort order is documented in `sort`. -// -// Examples -// -------- -// One dimensional array: -// -// >>> x = np.array([3, 1, 2]) -// >>> np.argsort(x) -// array([1, 2, 0]) -// -// Two-dimensional array: -// -// >>> x = np.array([[0, 3], [2, 2]]) -// >>> x -// array([[0, 3], -// [2, 2]]) -// -// >>> ind = np.argsort(x, axis=0) # sorts along first axis (down) -// >>> ind -// array([[0, 1], -// [1, 0]]) -// >>> np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0) -// array([[0, 2], -// [2, 3]]) -// -// >>> ind = np.argsort(x, axis=1) # sorts along last axis (across) -// >>> ind -// array([[0, 1], -// [0, 1]]) -// >>> np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1) -// array([[0, 3], -// [2, 2]]) -// -// Indices of the sorted elements of a N-dimensional array: -// -// >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape) -// >>> ind -// (array([0, 1, 1, 0]), array([0, 0, 1, 1])) -// >>> x[ind] # same as np.sort(x, axis=None) -// array([0, 2, 2, 3]) -// -// Sorting with keys: -// -// >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '>> x -// array([(1, 0), (0, 1)], -// dtype=[('x', '>> np.argsort(x, order=('x','y')) -// array([1, 0]) -// -// >>> np.argsort(x, order=('y','x')) -// array([0, 1]) -// -// -// -//go:linkname Argsort py.argsort -func Argsort(a *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object -// hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Given the "legs" of a right triangle, return its hypotenuse. -// -// Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. If `x1` or -// `x2` is scalar_like (i.e., unambiguously cast-able to a scalar type), -// it is broadcast for use with each element of the other argument. -// (See Examples) -// -// Parameters -// ---------- -// x1, x2 : array_like -// Leg of the triangle(s). -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// z : ndarray -// The hypotenuse of the triangle(s). -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -// Example showing broadcast of scalar_like argument: -// -// >>> np.hypot(3*np.ones((3, 3)), [4]) -// array([[ 5., 5., 5.], -// [ 5., 5., 5.], -// [ 5., 5., 5.]]) -// -//go:linkname Hypot py.hypot -func Hypot(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Test element-wise for positive infinity, return result as bool array. -// -// Parameters -// ---------- -// x : array_like -// The input array. -// out : array_like, optional -// A location into which the result is stored. If provided, it must have a -// shape that the input broadcasts to. If not provided or None, a -// freshly-allocated boolean array is returned. -// -// Returns -// ------- -// out : ndarray -// A boolean array with the same dimensions as the input. -// If second argument is not supplied then a boolean array is returned -// with values True where the corresponding element of the input is -// positive infinity and values False where the element of the input is -// not positive infinity. -// -// If a second argument is supplied the result is stored there. If the -// type of that array is a numeric type the result is represented as zeros -// and ones, if the type is boolean then as False and True. -// The return value `out` is then a reference to that array. -// -// See Also -// -------- -// isinf, isneginf, isfinite, isnan -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). -// -// Errors result if the second argument is also supplied when x is a scalar -// input, if first and second arguments have different shapes, or if the -// first argument has complex values -// -// Examples -// -------- -// >>> np.isposinf(np.PINF) -// True -// >>> np.isposinf(np.inf) -// True -// >>> np.isposinf(np.NINF) -// False -// >>> np.isposinf([-np.inf, 0., np.inf]) -// array([False, False, True]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isposinf(x, y) -// array([0, 0, 1]) -// >>> y -// array([0, 0, 1]) -// -// -// -//go:linkname Isposinf py.isposinf -func Isposinf(x *py.Object, out *py.Object) *py.Object -// -// Returns True if two arrays are element-wise equal within a tolerance. -// -// The tolerance values are positive, typically very small numbers. The -// relative difference (`rtol` * abs(`b`)) and the absolute difference -// `atol` are added together to compare against the absolute difference -// between `a` and `b`. -// -// NaNs are treated as equal if they are in the same place and if -// ``equal_nan=True``. Infs are treated as equal if they are in the same -// place and of the same sign in both arrays. -// -// Parameters -// ---------- -// a, b : array_like -// Input arrays to compare. -// rtol : float -// The relative tolerance parameter (see Notes). -// atol : float -// The absolute tolerance parameter (see Notes). -// equal_nan : bool -// Whether to compare NaN's as equal. If True, NaN's in `a` will be -// considered equal to NaN's in `b` in the output array. -// -// .. versionadded:: 1.10.0 -// -// Returns -// ------- -// allclose : bool -// Returns True if the two arrays are equal within the given -// tolerance; False otherwise. -// -// See Also -// -------- -// isclose, all, any, equal -// -// Notes -// ----- -// If the following equation is element-wise True, then allclose returns -// True. -// -// absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`)) -// -// The above equation is not symmetric in `a` and `b`, so that -// ``allclose(a, b)`` might be different from ``allclose(b, a)`` in -// some rare cases. -// -// The comparison of `a` and `b` uses standard broadcasting, which -// means that `a` and `b` need not have the same shape in order for -// ``allclose(a, b)`` to evaluate to True. The same is true for -// `equal` but not `array_equal`. -// -// `allclose` is not defined for non-numeric data types. -// `bool` is considered a numeric data-type for this purpose. -// -// Examples -// -------- -// >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8]) -// False -// >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9]) -// True -// >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9]) -// False -// >>> np.allclose([1.0, np.nan], [1.0, np.nan]) -// False -// >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) -// True -// -// -// -//go:linkname Allclose py.allclose -func Allclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object -// -// Compute the variance along the specified axis, while ignoring NaNs. -// -// Returns the variance of the array elements, a measure of the spread of -// a distribution. The variance is computed for the flattened array by -// default, otherwise over the specified axis. -// -// For all-NaN slices or slices with zero degrees of freedom, NaN is -// returned and a `RuntimeWarning` is raised. -// -// .. versionadded:: 1.8.0 -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose variance is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the variance is computed. The default is to compute -// the variance of the flattened array. -// dtype : data-type, optional -// Type to use in computing the variance. For arrays of integer type -// the default is `float64`; for arrays of float types it is the same as -// the array type. -// out : ndarray, optional -// Alternate output array in which to place the result. It must have -// the same shape as the expected output, but the type is cast if -// necessary. -// ddof : int, optional -// "Delta Degrees of Freedom": the divisor used in the calculation is -// ``N - ddof``, where ``N`` represents the number of non-NaN -// elements. By default `ddof` is zero. -// 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`. -// where : array_like of bool, optional -// Elements to include in the variance. See `~numpy.ufunc.reduce` for -// details. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// variance : ndarray, see dtype parameter above -// If `out` is None, return a new array containing the variance, -// otherwise return a reference to the output array. If ddof is >= the -// number of non-NaN elements in a slice or the slice contains only -// NaNs, then the result for that slice is NaN. -// -// See Also -// -------- -// std : Standard deviation -// mean : Average -// var : Variance while not ignoring NaNs -// nanstd, nanmean -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// The variance is the average of the squared deviations from the mean, -// i.e., ``var = mean(abs(x - x.mean())**2)``. -// -// The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``. -// If, however, `ddof` is specified, the divisor ``N - ddof`` is used -// instead. In standard statistical practice, ``ddof=1`` provides an -// unbiased estimator of the variance of a hypothetical infinite -// population. ``ddof=0`` provides a maximum likelihood estimate of the -// variance for normally distributed variables. -// -// Note that for complex numbers, the absolute value is taken before -// squaring, so that the result is always real and nonnegative. -// -// For floating-point input, the variance is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for `float32` (see example -// below). Specifying a higher-accuracy accumulator using the ``dtype`` -// keyword can alleviate this issue. -// -// For this function to work on sub-classes of ndarray, they must define -// `sum` with the kwarg `keepdims` -// -// Examples -// -------- -// >>> a = np.array([[1, np.nan], [3, 4]]) -// >>> np.nanvar(a) -// 1.5555555555555554 -// >>> np.nanvar(a, axis=0) -// array([1., 0.]) -// >>> np.nanvar(a, axis=1) -// array([0., 0.25]) # may vary -// -// -// -//go:linkname Nanvar py.nanvar -func Nanvar(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object -// -// Cross-correlation of two 1-dimensional sequences. -// -// This function computes the correlation as generally defined in signal -// processing texts: -// -// .. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n -// -// with a and v sequences being zero-padded where necessary and -// :math:`\overline x` denoting complex conjugation. -// -// Parameters -// ---------- -// a, v : array_like -// Input sequences. -// mode : {'valid', 'same', 'full'}, optional -// Refer to the `convolve` docstring. Note that the default -// is 'valid', unlike `convolve`, which uses 'full'. -// old_behavior : bool -// `old_behavior` was removed in NumPy 1.10. If you need the old -// behavior, use `multiarray.correlate`. -// -// Returns -// ------- -// out : ndarray -// Discrete cross-correlation of `a` and `v`. -// -// See Also -// -------- -// convolve : Discrete, linear convolution of two one-dimensional sequences. -// multiarray.correlate : Old, no conjugate, version of correlate. -// scipy.signal.correlate : uses FFT which has superior performance on large arrays. -// -// Notes -// ----- -// The definition of correlation above is not unique and sometimes correlation -// may be defined differently. Another common definition is: -// -// .. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+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 -// be preferable. -// -// -// Examples -// -------- -// >>> np.correlate([1, 2, 3], [0, 1, 0.5]) -// array([3.5]) -// >>> np.correlate([1, 2, 3], [0, 1, 0.5], "same") -// array([2. , 3.5, 3. ]) -// >>> np.correlate([1, 2, 3], [0, 1, 0.5], "full") -// array([0.5, 2. , 3.5, 3. , 0. ]) -// -// Using complex sequences: -// -// >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full') -// 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 -// (: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]) -// -// -// -//go:linkname Correlate py.correlate -func Correlate(a *py.Object, v *py.Object, mode *py.Object) *py.Object -// -// Compute the arithmetic mean along the specified axis. -// -// Returns the average of the array elements. The average is taken over -// the flattened array by default, otherwise over the specified axis. -// `float64` intermediate and return values are used for integer inputs. -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose mean is desired. If `a` is not an -// array, a conversion is attempted. -// axis : None or int or tuple of ints, optional -// Axis or axes along which the means are computed. The default is to -// compute the mean of the flattened array. -// -// .. versionadded:: 1.7.0 -// -// If this is a tuple of ints, a mean is performed over multiple axes, -// instead of a single axis or all the axes as before. -// dtype : data-type, optional -// Type to use in computing the mean. For integer inputs, the default -// is `float64`; for floating point inputs, it is the same as the -// input dtype. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. -// See :ref:`ufuncs-output-type` for more details. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `mean` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// where : array_like of bool, optional -// Elements to include in the mean. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// m : ndarray, see dtype parameter above -// If `out=None`, returns a new array containing the mean values, -// otherwise a reference to the output array is returned. -// -// See Also -// -------- -// average : Weighted average -// std, var, nanmean, nanstd, nanvar -// -// Notes -// ----- -// The arithmetic mean is the sum of the elements along the axis divided -// by the number of elements. -// -// Note that for floating-point input, the mean is computed using the -// same precision the input has. Depending on the input data, this can -// cause the results to be inaccurate, especially for `float32` (see -// example below). Specifying a higher-precision accumulator using the -// `dtype` keyword can alleviate this issue. -// -// By default, `float16` results are computed using `float32` intermediates -// for extra precision. -// -// Examples -// -------- -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> np.mean(a) -// 2.5 -// >>> np.mean(a, axis=0) -// array([2., 3.]) -// >>> np.mean(a, axis=1) -// array([1.5, 3.5]) -// -// In single precision, `mean` can be inaccurate: -// -// >>> a = np.zeros((2, 512*512), dtype=np.float32) -// >>> a[0, :] = 1.0 -// >>> a[1, :] = 0.1 -// >>> np.mean(a) -// 0.54999924 -// -// Computing the mean in float64 is more accurate: -// -// >>> np.mean(a, dtype=np.float64) -// 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 -// >>> np.mean(a, where=[[True], [False], [False]]) -// 9.0 -// -// -// -//go:linkname Mean py.mean -func Mean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object) *py.Object -// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic sine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `arcsinh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that `sinh(z) = x`. The convention is to return the -// `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arcsinh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, it -// returns ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arccos` is a complex analytical function that -// has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from -// the right on the former and from the left on the latter. -// -// The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arcsinh -// -// Examples -// -------- -// >>> np.arcsinh(np.array([np.e, 10.0])) -// array([ 1.72538256, 2.99822295]) -// -//go:linkname Arcsinh py.arcsinh -func Arcsinh(x *py.Object, out *py.Object) *py.Object -// floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the floor of the input, element-wise. -// -// The floor of the scalar `x` is the largest integer `i`, such that -// `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The floor of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, trunc, rint, fix -// -// Notes -// ----- -// Some spreadsheet programs calculate the "floor-towards-zero", where -// ``floor(-2.5) == -2``. NumPy instead uses the definition of -// `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" -// function is called ``fix`` in NumPy. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.floor(a) -// array([-2., -2., -1., 0., 1., 1., 2.]) -// -//go:linkname Floor py.floor -func Floor(x *py.Object, out *py.Object) *py.Object -// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the non-negative square-root of an array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// The values whose square-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the positive -// square-root of each element in `x`. If any element in `x` is -// complex, a complex array is returned (and the square-roots of -// negative reals are calculated). If all of the elements in `x` -// are real, so is `y`, with negative elements returning ``nan``. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.sqrt -// A version which returns complex numbers when given negative reals. -// Note that 0.0 and -0.0 are handled differently for complex inputs. -// -// Notes -// ----- -// *sqrt* has--consistent with common convention--as its branch cut the -// real "interval" [`-inf`, 0), and is continuous from above on it. -// A branch cut is a curve in the complex plane across which a given -// complex function fails to be continuous. -// -// Examples -// -------- -// >>> np.sqrt([1,4,9]) -// array([ 1., 2., 3.]) -// -// >>> np.sqrt([4, -1, -3+4J]) -// array([ 2.+0.j, 0.+1.j, 1.+2.j]) -// -// >>> np.sqrt([4, -1, np.inf]) -// array([ 2., nan, inf]) -// -//go:linkname Sqrt py.sqrt -func Sqrt(x *py.Object, out *py.Object) *py.Object -// -// Return numbers spaced evenly on a log scale. -// -// In linear space, the sequence starts at ``base ** start`` -// (`base` to the power of `start`) and ends with ``base ** stop`` -// (see `endpoint` below). -// -// .. versionchanged:: 1.16.0 -// Non-scalar `start` and `stop` are now supported. -// -// .. versionchanged:: 1.25.0 -// Non-scalar 'base` is now supported -// -// Parameters -// ---------- -// start : array_like -// ``base ** start`` is the starting value of the sequence. -// stop : array_like -// ``base ** stop`` is the final value of the sequence, unless `endpoint` -// is False. In that case, ``num + 1`` values are spaced over the -// interval in log-space, of which all but the last (a sequence of -// length `num`) are returned. -// num : integer, optional -// Number of samples to generate. Default is 50. -// endpoint : boolean, optional -// If true, `stop` is the last sample. Otherwise, it is not included. -// Default is True. -// base : array_like, optional -// The base of the log space. The step size between the elements in -// ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform. -// Default is 10.0. -// dtype : dtype -// The type of the output array. If `dtype` is not given, the data type -// is inferred from `start` and `stop`. The inferred type will never be -// an integer; `float` is chosen even if the arguments would produce an -// array of integers. -// axis : int, optional -// The axis in the result to store the samples. Relevant only if start, -// stop, or base are array-like. By default (0), the samples will be -// along a new axis inserted at the beginning. Use -1 to get an axis at -// the end. -// -// .. versionadded:: 1.16.0 -// -// -// Returns -// ------- -// samples : ndarray -// `num` samples, equally spaced on a log scale. -// -// See Also -// -------- -// arange : Similar to linspace, with the step size specified instead of the -// number of samples. Note that, when used with a float endpoint, the -// endpoint may or may not be included. -// 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 -// ----- -// If base is a scalar, logspace is equivalent to the code -// -// >>> y = np.linspace(start, stop, num=num, endpoint=endpoint) -// ... # doctest: +SKIP -// >>> power(base, y).astype(dtype) -// ... # doctest: +SKIP -// -// Examples -// -------- -// >>> np.logspace(2.0, 3.0, num=4) -// array([ 100. , 215.443469 , 464.15888336, 1000. ]) -// >>> np.logspace(2.0, 3.0, num=4, endpoint=False) -// array([100. , 177.827941 , 316.22776602, 562.34132519]) -// >>> np.logspace(2.0, 3.0, num=4, base=2.0) -// array([4. , 5.0396842 , 6.34960421, 8. ]) -// >>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1) -// array([[ 4. , 5.0396842 , 6.34960421, 8. ], -// [ 9. , 12.98024613, 18.72075441, 27. ]]) -// -// Graphical illustration: -// -// >>> import matplotlib.pyplot as plt -// >>> N = 10 -// >>> x1 = np.logspace(0.1, 1, N, endpoint=True) -// >>> x2 = np.logspace(0.1, 1, N, endpoint=False) -// >>> y = np.zeros(N) -// >>> plt.plot(x1, y, 'o') -// [] -// >>> plt.plot(x2, y + 0.5, 'o') -// [] -// >>> plt.ylim([-0.5, 1]) -// (-0.5, 1) -// >>> plt.show() -// -// -// -//go:linkname Logspace py.logspace -func Logspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, base *py.Object, dtype *py.Object, axis *py.Object) *py.Object -// -// Return a scalar type which is common to the input arrays. -// -// The return type will always be an inexact (i.e. floating point) scalar -// type, even if all the arrays are integer arrays. If one of the inputs is -// an integer array, the minimum precision type that is returned is a -// 64-bit floating point dtype. -// -// All input arrays except int64 and uint64 can be safely cast to the -// returned dtype without loss of information. -// -// Parameters -// ---------- -// array1, array2, ... : ndarrays -// Input arrays. -// -// Returns -// ------- -// out : data type code -// Data type code. -// -// See Also -// -------- -// dtype, mintypecode -// -// Examples -// -------- -// >>> np.common_type(np.arange(2, dtype=np.float32)) -// -// >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2)) -// -// >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0])) -// -// -// -// -//go:linkname CommonType py.common_type -func CommonType(__llgo_va_list ...interface{}) *py.Object -// -// 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. -// -// Please refer to the documentation for `tril` for further details. -// -// See Also -// -------- -// tril : lower triangle of an array -// -// Examples -// -------- -// >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1) -// array([[ 1, 2, 3], -// [ 4, 5, 6], -// [ 0, 8, 9], -// [ 0, 0, 12]]) -// -// >>> np.triu(np.arange(3*4*5).reshape(3, 4, 5)) -// array([[[ 0, 1, 2, 3, 4], -// [ 0, 6, 7, 8, 9], -// [ 0, 0, 12, 13, 14], -// [ 0, 0, 0, 18, 19]], -// [[20, 21, 22, 23, 24], -// [ 0, 26, 27, 28, 29], -// [ 0, 0, 32, 33, 34], -// [ 0, 0, 0, 38, 39]], -// [[40, 41, 42, 43, 44], -// [ 0, 46, 47, 48, 49], -// [ 0, 0, 52, 53, 54], -// [ 0, 0, 0, 58, 59]]]) -// -// -// -//go:linkname Triu py.triu -func Triu(m *py.Object, k *py.Object) *py.Object -// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate ``exp(x) - 1`` for all elements in the array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise exponential minus one: ``out = exp(x) - 1``. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log1p : ``log(1 + x)``, the inverse of expm1. -// -// -// Notes -// ----- -// This function provides greater precision than ``exp(x) - 1`` -// for small values of ``x``. -// -// Examples -// -------- -// The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to -// about 32 significant digits. This example shows the superiority of -// expm1 in this case. -// -// >>> np.expm1(1e-10) -// 1.00000000005e-10 -// >>> np.exp(1e-10) - 1 -// 1.000000082740371e-10 -// -//go:linkname Expm1 py.expm1 -func Expm1(x *py.Object, out *py.Object) *py.Object -// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the natural logarithm of one plus the input array, element-wise. -// -// Calculates ``log(1 + x)``. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Natural logarithm of `1 + x`, element-wise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : ``exp(x) - 1``, the inverse of `log1p`. -// -// Notes -// ----- -// For real-valued input, `log1p` is accurate also for `x` so small -// that `1 + x == 1` in floating-point accuracy. -// -// Logarithm is a multivalued function: for each `x` there is an infinite -// number of `z` such that `exp(z) = 1 + x`. The convention is to return -// the `z` whose imaginary part lies in `[-pi, pi]`. -// -// For real-valued input data types, `log1p` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log1p` is a complex analytical function that -// has a branch cut `[-inf, -1]` and is continuous from above on it. -// `log1p` handles the floating-point negative zero as an infinitesimal -// negative number, conforming to the C99 standard. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log1p(1e-99) -// 1e-99 -// >>> np.log(1 + 1e-99) -// 0.0 -// -//go:linkname Log1p py.log1p -func Log1p(x *py.Object, out *py.Object) *py.Object -// power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in -// `x2`. `x1` and `x2` must be broadcastable to the same shape. -// -// An integer type raised to a negative integer power will raise a -// ``ValueError``. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// float_power : power function that promotes integers to float -// -// Examples -// -------- -// Cube each element in an array. -// -// >>> x1 = np.arange(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.power(x1, 3) -// array([ 0, 1, 8, 27, 64, 125]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.power(x1, x2) -// array([[ 0, 1, 8, 27, 16, 5], -// [ 0, 1, 8, 27, 16, 5]]) -// -// The ``**`` operator can be used as a shorthand for ``np.power`` on -// ndarrays. -// -// >>> x2 = np.array([1, 2, 3, 3, 2, 1]) -// >>> x1 = np.arange(6) -// >>> x1 ** x2 -// array([ 0, 1, 8, 27, 16, 5]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1.0, -4.0]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname Power py.power -func Power(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return a 2-D array with ones on the diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the output. -// M : int, optional -// Number of columns in the output. If None, defaults to `N`. -// k : int, optional -// Index of the diagonal: 0 (the default) refers to the main diagonal, -// a positive value refers to an upper diagonal, and a negative value -// to a lower diagonal. -// dtype : data-type, optional -// Data-type of the returned array. -// order : {'C', 'F'}, optional -// Whether the output should be stored in row-major (C-style) or -// column-major (Fortran-style) order in memory. -// -// .. versionadded:: 1.14.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// I : ndarray of shape (N,M) -// An array where all elements are equal to zero, except for the `k`-th -// diagonal, whose values are equal to one. -// -// See Also -// -------- -// identity : (almost) equivalent function -// diag : diagonal 2-D array from a 1-D array specified by the user. -// -// Examples -// -------- -// >>> np.eye(2, dtype=int) -// array([[1, 0], -// [0, 1]]) -// >>> np.eye(3, k=1) -// array([[0., 1., 0.], -// [0., 0., 1.], -// [0., 0., 0.]]) -// -// -// -//go:linkname Eye py.eye -func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Save an array to a binary file in NumPy ``.npy`` format. -// -// Parameters -// ---------- -// file : file, str, or pathlib.Path -// File or filename to which the data is saved. If file is a file-object, -// then the filename is unchanged. If file is a string or Path, a ``.npy`` -// extension will be appended to the filename if it does not already -// have one. -// arr : array_like -// Array data to be saved. -// allow_pickle : bool, optional -// Allow saving object arrays using Python pickles. Reasons for disallowing -// pickles include security (loading pickled data can execute arbitrary -// code) and portability (pickled objects may not be loadable on different -// Python installations, for example if the stored objects require libraries -// that are not available, and not all pickled data is compatible between -// Python 2 and Python 3). -// Default: True -// fix_imports : bool, optional -// Only useful in forcing objects in object arrays on Python 3 to be -// pickled in a Python 2 compatible way. If `fix_imports` is True, pickle -// will try to map the new Python 3 names to the old module names used in -// Python 2, so that the pickle data stream is readable with Python 2. -// -// See Also -// -------- -// savez : Save several arrays into a ``.npz`` archive -// savetxt, load -// -// Notes -// ----- -// For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`. -// -// Any data saved to the file is appended to the end of the file. -// -// Examples -// -------- -// >>> from tempfile import TemporaryFile -// >>> outfile = TemporaryFile() -// -// >>> x = np.arange(10) -// >>> np.save(outfile, x) -// -// >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file -// >>> np.load(outfile) -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// -// >>> with open('test.npy', 'wb') as f: -// ... np.save(f, np.array([1, 2])) -// ... np.save(f, np.array([1, 3])) -// >>> with open('test.npy', 'rb') as f: -// ... a = np.load(f) -// ... b = np.load(f) -// >>> print(a, b) -// # [1 2] [1 3] -// -// -//go:linkname Save py.save -func Save(file *py.Object, arr *py.Object, allowPickle *py.Object, fixImports *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Mat py.mat -func Mat(data *py.Object, dtype *py.Object) *py.Object -// -// Return a new array of given shape and type, filled with `fill_value`. -// -// Parameters -// ---------- -// shape : int or sequence of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// fill_value : scalar or array_like -// Fill value. -// dtype : data-type, optional -// The desired data-type for the array The default, None, means -// ``np.array(fill_value).dtype``. -// order : {'C', 'F'}, optional -// Whether to store multidimensional data in C- or Fortran-contiguous -// (row- or column-wise) order in memory. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of `fill_value` with the given shape, dtype, and order. -// -// See Also -// -------- -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// -// Examples -// -------- -// >>> np.full((2, 2), np.inf) -// array([[inf, inf], -// [inf, inf]]) -// >>> np.full((2, 2), 10) -// array([[10, 10], -// [10, 10]]) -// -// >>> np.full((2, 2), [1, 2]) -// array([[1, 2], -// [1, 2]]) -// -// -// -//go:linkname Full py.full -func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conjugate py.conjugate -func Conjugate(x *py.Object, out *py.Object) *py.Object -// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Subtract arguments, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays to be subtracted from each other. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The difference of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// Equivalent to ``x1 - x2`` in terms of array broadcasting. -// -// Examples -// -------- -// >>> np.subtract(1.0, 4.0) -// -3.0 -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> np.subtract(x1, x2) -// array([[ 0., 0., 0.], -// [ 3., 3., 3.], -// [ 6., 6., 6.]]) -// -// The ``-`` operator can be used as a shorthand for ``np.subtract`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = np.arange(3.0) -// >>> x1 - x2 -// array([[0., 0., 0.], -// [3., 3., 3.], -// [6., 6., 6.]]) -// -//go:linkname Subtract py.subtract -func Subtract(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// bincount(x, /, weights=None, minlength=0) -// -// Count number of occurrences of each value in array of non-negative ints. -// -// The number of bins (of size 1) is one larger than the largest value in -// `x`. If `minlength` is specified, there will be at least this number -// of bins in the output array (though it will be longer if necessary, -// depending on the contents of `x`). -// Each bin gives the number of occurrences of its index value in `x`. -// If `weights` is specified the input array is weighted by it, i.e. if a -// value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead -// of ``out[n] += 1``. -// -// Parameters -// ---------- -// x : array_like, 1 dimension, nonnegative ints -// Input array. -// weights : array_like, optional -// Weights, array of the same shape as `x`. -// minlength : int, optional -// A minimum number of bins for the output array. -// -// .. versionadded:: 1.6.0 -// -// Returns -// ------- -// out : ndarray of ints -// The result of binning the input array. -// The length of `out` is equal to ``np.amax(x)+1``. -// -// Raises -// ------ -// ValueError -// If the input is not 1-dimensional, or contains elements with negative -// values, or if `minlength` is negative. -// TypeError -// If the type of the input is float or complex. -// -// See Also -// -------- -// histogram, digitize, unique -// -// Examples -// -------- -// >>> np.bincount(np.arange(5)) -// array([1, 1, 1, 1, 1]) -// >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) -// array([1, 3, 1, 1, 0, 0, 0, 1]) -// -// >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) -// >>> np.bincount(x).size == np.amax(x)+1 -// True -// -// The input array needs to be of integer dtype, otherwise a -// TypeError is raised: -// -// >>> np.bincount(np.arange(5, dtype=float)) -// Traceback (most recent call last): -// ... -// TypeError: Cannot cast array data from dtype('float64') to dtype('int64') -// according to the rule 'safe' -// -// A possible use of ``bincount`` is to perform sums over -// variable-size chunks of an array, using the ``weights`` keyword. -// -// >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights -// >>> x = np.array([0, 1, 1, 2, 2, 2]) -// >>> np.bincount(x, weights=w) -// array([ 0.3, 0.7, 1.1]) -// -// -// -//go:linkname Bincount py.bincount -func Bincount(x *py.Object, weights *py.Object, minlength *py.Object) *py.Object -// -// The differences between consecutive elements of an array. -// -// Parameters -// ---------- -// ary : array_like -// If necessary, will be flattened before the differences are taken. -// to_end : array_like, optional -// Number(s) to append at the end of the returned differences. -// to_begin : array_like, optional -// Number(s) to prepend at the beginning of the returned differences. -// -// Returns -// ------- -// ediff1d : ndarray -// The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``. -// -// See Also -// -------- -// diff, gradient -// -// Notes -// ----- -// When applied to masked arrays, this function drops the mask information -// if the `to_begin` and/or `to_end` parameters are used. -// -// Examples -// -------- -// >>> x = np.array([1, 2, 4, 7, 0]) -// >>> np.ediff1d(x) -// array([ 1, 2, 3, -7]) -// -// >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) -// array([-99, 1, 2, ..., -7, 88, 99]) -// -// The returned array is always 1D. -// -// >>> y = [[1, 2, 4], [1, 6, 24]] -// >>> np.ediff1d(y) -// array([ 1, 2, -3, 5, 18]) -// -// -// -//go:linkname Ediff1d py.ediff1d -func Ediff1d(ary *py.Object, toEnd *py.Object, toBegin *py.Object) *py.Object -// -// Compute the standard deviation along the specified axis, while -// ignoring NaNs. -// -// Returns the standard deviation, a measure of the spread of a -// distribution, of the non-NaN array elements. The standard deviation is -// computed for the flattened array by default, otherwise over the -// specified axis. -// -// For all-NaN slices or slices with zero degrees of freedom, NaN is -// returned and a `RuntimeWarning` is raised. -// -// .. versionadded:: 1.8.0 -// -// Parameters -// ---------- -// a : array_like -// Calculate the standard deviation of the non-NaN values. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the standard deviation is computed. The default is -// to compute the standard deviation of the flattened array. -// dtype : dtype, optional -// Type to use in computing the standard deviation. For arrays of -// integer type the default is float64, for arrays of float types it -// is the same as the array type. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output but the type (of the -// calculated values) will be cast if necessary. -// ddof : int, optional -// Means Delta Degrees of Freedom. The divisor used in calculations -// is ``N - ddof``, where ``N`` represents the number of non-NaN -// elements. By default `ddof` is zero. -// -// 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`. -// -// If this value is anything but the default it is passed through -// as-is to the relevant functions of the sub-classes. If these -// functions do not have a `keepdims` kwarg, a RuntimeError will -// be raised. -// where : array_like of bool, optional -// Elements to include in the standard deviation. -// See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// standard_deviation : ndarray, see dtype parameter above. -// If `out` is None, return a new array containing the standard -// deviation, otherwise return a reference to the output array. If -// ddof is >= the number of non-NaN elements in a slice or the slice -// contains only NaNs, then the result for that slice is NaN. -// -// See Also -// -------- -// var, mean, std -// nanvar, nanmean -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// The standard deviation is the square root of the average of the squared -// deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``. -// -// The average squared deviation is normally calculated as -// ``x.sum() / N``, where ``N = len(x)``. If, however, `ddof` is -// specified, the divisor ``N - ddof`` is used instead. In standard -// statistical practice, ``ddof=1`` provides an unbiased estimator of the -// variance of the infinite population. ``ddof=0`` provides a maximum -// likelihood estimate of the variance for normally distributed variables. -// The standard deviation computed in this function is the square root of -// the estimated variance, so even with ``ddof=1``, it will not be an -// unbiased estimate of the standard deviation per se. -// -// Note that, for complex numbers, `std` takes the absolute value before -// squaring, so that the result is always real and nonnegative. -// -// For floating-point input, the *std* is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for float32 (see example -// below). Specifying a higher-accuracy accumulator using the `dtype` -// keyword can alleviate this issue. -// -// Examples -// -------- -// >>> a = np.array([[1, np.nan], [3, 4]]) -// >>> np.nanstd(a) -// 1.247219128924647 -// >>> np.nanstd(a, axis=0) -// array([1., 0.]) -// >>> np.nanstd(a, axis=1) -// array([0., 0.5]) # may vary -// -// -// -//go:linkname Nanstd py.nanstd -func Nanstd(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object -// -// Compute the multidimensional histogram of some data. -// -// Parameters -// ---------- -// sample : (N, D) array, or (N, D) array_like -// The data to be histogrammed. -// -// Note the unusual interpretation of sample when an array_like: -// -// * When an array, each row is a coordinate in a D-dimensional space - -// such as ``histogramdd(np.array([p1, p2, p3]))``. -// * When an array_like, each element is the list of values for single -// coordinate - such as ``histogramdd((X, Y, Z))``. -// -// The first form should be preferred. -// -// bins : sequence or int, optional -// The bin specification: -// -// * A sequence of arrays describing the monotonically increasing bin -// edges along each dimension. -// * The number of bins for each dimension (nx, ny, ... =bins) -// * The number of bins for all dimensions (nx=ny=...=bins). -// -// range : sequence, optional -// A sequence of length D, each an optional (lower, upper) tuple giving -// the outer bin edges to be used if the edges are not given explicitly in -// `bins`. -// An entry of None in the sequence results in the minimum and maximum -// values being used for the corresponding dimension. -// The default, None, is equivalent to passing a tuple of D None values. -// density : bool, optional -// 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``. -// 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 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 density and weights -// for the different possible semantics. -// edges : list -// A list of D arrays describing the bin edges for each dimension. -// -// See Also -// -------- -// histogram: 1-D histogram -// histogram2d: 2-D histogram -// -// Examples -// -------- -// >>> r = np.random.randn(100,3) -// >>> H, edges = np.histogramdd(r, bins = (5, 8, 4)) -// >>> H.shape, edges[0].size, edges[1].size, edges[2].size -// ((5, 8, 4), 6, 9, 5) -// -// -// -//go:linkname Histogramdd py.histogramdd -func Histogramdd(sample *py.Object, bins *py.Object, Range *py.Object, density *py.Object, weights *py.Object) *py.Object -// -// Interpret the input as a matrix. -// -// Unlike `matrix`, `asmatrix` does not make a copy if the input is already -// a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``. -// -// Parameters -// ---------- -// data : array_like -// Input data. -// dtype : data-type -// Data-type of the output matrix. -// -// Returns -// ------- -// mat : matrix -// `data` interpreted as a matrix. -// -// Examples -// -------- -// >>> x = np.array([[1, 2], [3, 4]]) -// -// >>> m = np.asmatrix(x) -// -// >>> x[0,0] = 5 -// -// >>> m -// matrix([[5, 2], -// [3, 4]]) -// -// -// -//go:linkname Asmatrix py.asmatrix -func Asmatrix(data *py.Object, dtype *py.Object) *py.Object -// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) -// -// Matrix product of two arrays. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays, scalars not allowed. -// out : ndarray, optional -// A location into which the result is stored. If provided, it must have -// a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not -// provided or None, a freshly-allocated array is returned. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// .. versionadded:: 1.16 -// Now handles ufunc kwargs -// -// Returns -// ------- -// y : ndarray -// The matrix product of the inputs. -// This is a scalar only when both x1, x2 are 1-d vectors. -// -// Raises -// ------ -// ValueError -// If the last dimension of `x1` is not the same size as -// the second-to-last dimension of `x2`. -// -// If a scalar value is passed in. -// -// See Also -// -------- -// vdot : Complex-conjugating dot product. -// tensordot : Sum products over arbitrary axes. -// einsum : Einstein summation convention. -// dot : alternative matrix product with different broadcasting rules. -// -// Notes -// ----- -// -// The behavior depends on the arguments in the following way. -// -// - If both arguments are 2-D they are multiplied like conventional -// matrices. -// - If either argument is N-D, N > 2, it is treated as a stack of -// matrices residing in the last two indexes and broadcast accordingly. -// - If the first argument is 1-D, it is promoted to a matrix by -// prepending a 1 to its dimensions. After matrix multiplication -// the prepended 1 is removed. -// - If the second argument is 1-D, it is promoted to a matrix by -// appending a 1 to its dimensions. After matrix multiplication -// the appended 1 is removed. -// -// ``matmul`` differs from ``dot`` in two important ways: -// -// - Multiplication by scalars is not allowed, use ``*`` instead. -// - Stacks of matrices are broadcast together as if the matrices -// were elements, respecting the signature ``(n,k),(k,m)->(n,m)``: -// -// >>> a = np.ones([9, 5, 7, 4]) -// >>> c = np.ones([9, 5, 4, 3]) -// >>> np.dot(a, c).shape -// (9, 5, 7, 9, 5, 3) -// >>> np.matmul(a, c).shape -// (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`. -// -// It uses an optimized BLAS library when possible (see `numpy.linalg`). -// -// Examples -// -------- -// For 2-D arrays it is the matrix product: -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([[4, 1], -// ... [2, 2]]) -// >>> np.matmul(a, b) -// array([[4, 1], -// [2, 2]]) -// -// For 2-D mixed with 1-D, the result is the usual. -// -// >>> a = np.array([[1, 0], -// ... [0, 1]]) -// >>> b = np.array([1, 2]) -// >>> np.matmul(a, b) -// array([1, 2]) -// >>> np.matmul(b, a) -// array([1, 2]) -// -// -// Broadcasting is conventional for stacks of arrays -// -// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) -// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) -// >>> np.matmul(a,b).shape -// (2, 2, 2) -// >>> np.matmul(a, b)[0, 1, 1] -// 98 -// >>> sum(a[0, 1, :] * b[0 , :, 1]) -// 98 -// -// Vector, vector returns the scalar inner product, but neither argument -// is complex-conjugated: -// -// >>> np.matmul([2j, 3j], [2j, 3j]) -// (-13+0j) -// -// Scalar multiplication raises an error. -// -// >>> np.matmul([1,2], 3) -// Traceback (most recent call last): -// ... -// ValueError: matmul: Input operand 1 does not have enough dimensions ... -// -// The ``@`` operator can be used as a shorthand for ``np.matmul`` on -// ndarrays. -// -// >>> x1 = np.array([2j, 3j]) -// >>> x2 = np.array([2j, 3j]) -// >>> x1 @ x2 -// (-13+0j) -// -// .. versionadded:: 1.10.0 -// -//go:linkname Matmul py.matmul -func Matmul(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Check if all elements of input array are true. -// -// .. deprecated:: 1.25.0 -// ``alltrue`` is deprecated as of NumPy 1.25.0, and will be -// removed in NumPy 2.0. Please use `all` instead. -// -// See Also -// -------- -// numpy.all : Equivalent function; see for details. -// -// -//go:linkname Alltrue py.alltrue -func Alltrue(__llgo_va_list ...interface{}) *py.Object -// -// is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None) -// -// Calculates which of the given dates are valid days, and which are not. -// -// .. versionadded:: 1.7.0 -// -// Parameters -// ---------- -// dates : array_like of datetime64[D] -// The array of dates to process. -// weekmask : str or array_like of bool, optional -// A seven-element array indicating which of Monday through Sunday are -// valid days. May be specified as a length-seven list or array, like -// [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string -// like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for -// weekdays, optionally separated by white space. Valid abbreviations -// are: Mon Tue Wed Thu Fri Sat Sun -// holidays : array_like of datetime64[D], optional -// An array of dates to consider as invalid dates. They may be -// specified in any order, and NaT (not-a-time) dates are ignored. -// This list is saved in a normalized form that is suited for -// fast calculations of valid days. -// busdaycal : busdaycalendar, optional -// A `busdaycalendar` object which specifies the valid days. If this -// parameter is provided, neither weekmask nor holidays may be -// provided. -// out : array of bool, optional -// If provided, this array is filled with the result. -// -// Returns -// ------- -// out : array of bool -// An array with the same shape as ``dates``, containing True for -// each valid day, and False for each invalid day. -// -// See Also -// -------- -// busdaycalendar : An object that specifies a custom set of valid days. -// busday_offset : Applies an offset counted in valid days. -// busday_count : Counts how many valid days are in a half-open date range. -// -// Examples -// -------- -// >>> # The weekdays are Friday, Saturday, and Monday -// ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'], -// ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) -// array([False, False, True]) -// -// -//go:linkname IsBusday py.is_busday -func IsBusday(dates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object -// -// Return a string representation of the data in an array. -// -// The data in the array is returned as a single string. This function is -// similar to `array_repr`, the difference being that `array_repr` also -// returns information on the kind of array and its data type. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// max_line_width : int, optional -// Inserts newlines if text is longer than `max_line_width`. -// Defaults to ``numpy.get_printoptions()['linewidth']``. -// precision : int, optional -// Floating point precision. -// Defaults to ``numpy.get_printoptions()['precision']``. -// suppress_small : bool, optional -// Represent numbers "very close" to zero as zero; default is False. -// Very close is defined by precision: if the precision is 8, e.g., -// numbers smaller (in absolute value) than 5e-9 are represented as -// zero. -// Defaults to ``numpy.get_printoptions()['suppress']``. -// -// See Also -// -------- -// array2string, array_repr, set_printoptions -// -// Examples -// -------- -// >>> np.array_str(np.arange(3)) -// '[0 1 2]' -// -// -// -//go:linkname ArrayStr py.array_str -func ArrayStr(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object -// -// Expand the shape of an array. -// -// Insert a new axis that will appear at the `axis` position in the expanded -// array shape. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int or tuple of ints -// Position in the expanded axes where the new axis (or axes) is placed. -// -// .. deprecated:: 1.13.0 -// Passing an axis where ``axis > a.ndim`` will be treated as -// ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will -// be treated as ``axis == 0``. This behavior is deprecated. -// -// .. versionchanged:: 1.18.0 -// A tuple of axes is now supported. Out of range axes as -// described above are now forbidden and raise an `AxisError`. -// -// Returns -// ------- -// result : ndarray -// View of `a` with the number of dimensions increased. -// -// See Also -// -------- -// squeeze : The inverse operation, removing singleton dimensions -// reshape : Insert, remove, and combine dimensions, and resize existing ones -// doc.indexing, atleast_1d, atleast_2d, atleast_3d -// -// Examples -// -------- -// >>> x = np.array([1, 2]) -// >>> x.shape -// (2,) -// -// The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``: -// -// >>> y = np.expand_dims(x, axis=0) -// >>> y -// array([[1, 2]]) -// >>> y.shape -// (1, 2) -// -// The following is equivalent to ``x[:, np.newaxis]``: -// -// >>> y = np.expand_dims(x, axis=1) -// >>> y -// array([[1], -// [2]]) -// >>> y.shape -// (2, 1) -// -// ``axis`` may also be a tuple: -// -// >>> y = np.expand_dims(x, axis=(0, 1)) -// >>> y -// array([[[1, 2]]]) -// -// >>> y = np.expand_dims(x, axis=(2, 0)) -// >>> y -// array([[[1], -// [2]]]) -// -// Note that some examples may use ``None`` instead of ``np.newaxis``. These -// are the same objects: -// -// >>> np.newaxis is None -// True -// -// -// -//go:linkname ExpandDims py.expand_dims -func ExpandDims(a *py.Object, axis *py.Object) *py.Object -// -// Return an array of ones with the same shape and type as a given array. -// -// Parameters -// ---------- -// a : array_like -// The shape and data-type of `a` define these same attributes of -// the returned array. -// dtype : data-type, optional -// Overrides the data type of the result. -// -// .. versionadded:: 1.6.0 -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. -// -// .. versionadded:: 1.6.0 -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `a`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// out : ndarray -// Array of ones with the same shape and type as `a`. -// -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// ones : Return a new array setting values to one. -// -// Examples -// -------- -// >>> x = np.arange(6) -// >>> x = x.reshape((2, 3)) -// >>> x -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.ones_like(x) -// array([[1, 1, 1], -// [1, 1, 1]]) -// -// >>> y = np.arange(3, dtype=float) -// >>> y -// array([0., 1., 2.]) -// >>> np.ones_like(y) -// array([1., 1., 1.]) -// -// -// -//go:linkname OnesLike py.ones_like -func OnesLike(__llgo_va_list ...interface{}) *py.Object -// -// Return True if x is a not complex type or an array of complex numbers. -// -// The type of the input is checked, not the value. So even if the input -// has an imaginary part equal to zero, `isrealobj` evaluates to False -// if the data type is complex. -// -// Parameters -// ---------- -// x : any -// The input can be of any type and shape. -// -// Returns -// ------- -// y : bool -// The return value, False if `x` is of a complex type. -// -// See Also -// -------- -// iscomplexobj, isreal -// -// Notes -// ----- -// The function is only meant for arrays with numerical values but it -// accepts all other objects. Since it assumes array input, the return -// value of other objects may be True. -// -// >>> np.isrealobj('A string') -// True -// >>> np.isrealobj(False) -// True -// >>> np.isrealobj(None) -// True -// -// Examples -// -------- -// >>> np.isrealobj(1) -// True -// >>> np.isrealobj(1+0j) -// False -// >>> np.isrealobj([3, 1+0j, True]) -// False -// -// -// -//go:linkname Isrealobj py.isrealobj -func Isrealobj(x *py.Object) *py.Object -// -// Sort a complex array using the real part first, then the imaginary part. -// -// Parameters -// ---------- -// a : array_like -// Input array -// -// Returns -// ------- -// out : complex ndarray -// Always returns a sorted complex array. -// -// Examples -// -------- -// >>> np.sort_complex([5, 3, 6, 2, 1]) -// array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j]) -// -// >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]) -// array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j]) -// -// -// -//go:linkname SortComplex py.sort_complex -func SortComplex(a *py.Object) *py.Object -// -// Return the Blackman window. -// -// The Blackman window is a taper formed by using the first three -// terms of a summation of cosines. It was designed to have close to the -// minimal leakage possible. It is close to optimal, only slightly worse -// than a Kaiser window. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an empty -// array is returned. -// -// Returns -// ------- -// out : ndarray -// The window, with the maximum value normalized to one (the value one -// appears only if the number of samples is odd). -// -// See Also -// -------- -// bartlett, hamming, hanning, kaiser -// -// Notes -// ----- -// The Blackman window is defined as -// -// .. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M) -// -// Most references to the Blackman window come from the signal processing -// literature, where it is used as one of many windowing functions for -// smoothing values. 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. It is known as a -// "near optimal" tapering function, almost as good (by some measures) -// as the kaiser window. -// -// References -// ---------- -// Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, -// Dover Publications, New York. -// -// Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. -// Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.blackman(12) -// array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary -// 4.14397981e-01, 7.36045180e-01, 9.67046769e-01, -// 9.67046769e-01, 7.36045180e-01, 4.14397981e-01, -// 1.59903635e-01, 3.26064346e-02, -1.38777878e-17]) -// -// Plot the window and the frequency response: -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.blackman(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Blackman window") -// Text(0.5, 1.0, 'Blackman window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Blackman window") -// Text(0.5, 1.0, 'Frequency response of Blackman window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Blackman py.blackman -func Blackman(M *py.Object) *py.Object -// -// Broadcast the input shapes into a single shape. -// -// :ref:`Learn more about broadcasting here `. -// -// .. versionadded:: 1.20.0 -// -// Parameters -// ---------- -// `*args` : tuples of ints, or ints -// The shapes to be broadcast against each other. -// -// Returns -// ------- -// tuple -// Broadcasted shape. -// -// Raises -// ------ -// ValueError -// If the shapes are not compatible and cannot be broadcast according -// to NumPy's broadcasting rules. -// -// See Also -// -------- -// broadcast -// broadcast_arrays -// broadcast_to -// -// Examples -// -------- -// >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) -// (3, 2) -// -// >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) -// (5, 6, 7) -// -// -//go:linkname BroadcastShapes py.broadcast_shapes -func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object -// -// Find the union of two arrays. -// -// Return the unique, sorted array of values that are in either of the two -// input arrays. -// -// Parameters -// ---------- -// ar1, ar2 : array_like -// Input arrays. They are flattened if they are not already 1D. -// -// Returns -// ------- -// union1d : ndarray -// Unique, sorted union of the input arrays. -// -// See Also -// -------- -// numpy.lib.arraysetops : Module with a number of other functions for -// performing set operations on arrays. -// -// Examples -// -------- -// >>> np.union1d([-1, 0, 1], [-2, 0, 2]) -// array([-2, -1, 0, 1, 2]) -// -// To find the union of more than two arrays, use functools.reduce: -// -// >>> from functools import reduce -// >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) -// array([1, 2, 3, 4, 6]) -// -// -//go:linkname Union1d py.union1d -func Union1d(ar1 *py.Object, ar2 *py.Object) *py.Object -// -// Find the indices of array elements that are non-zero, grouped by element. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// -// Returns -// ------- -// index_array : (N, a.ndim) ndarray -// Indices of elements that are non-zero. Indices are grouped by element. -// This array will have shape ``(N, a.ndim)`` where ``N`` is the number of -// non-zero items. -// -// See Also -// -------- -// where, nonzero -// -// Notes -// ----- -// ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``, -// but produces a result of the correct shape for a 0D array. -// -// The output of ``argwhere`` is not suitable for indexing arrays. -// For this purpose use ``nonzero(a)`` instead. -// -// Examples -// -------- -// >>> x = np.arange(6).reshape(2,3) -// >>> x -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.argwhere(x>1) -// array([[0, 2], -// [1, 0], -// [1, 1], -// [1, 2]]) -// -// -// -//go:linkname Argwhere py.argwhere -func Argwhere(a *py.Object) *py.Object -// -// True if two arrays have the same shape and elements, False otherwise. -// -// Parameters -// ---------- -// a1, a2 : array_like -// Input arrays. -// equal_nan : bool -// Whether to compare NaN's as equal. If the dtype of a1 and a2 is -// complex, values will be considered equal if either the real or the -// imaginary component of a given value is ``nan``. -// -// .. versionadded:: 1.19.0 -// -// Returns -// ------- -// b : bool -// Returns True if the arrays are equal. -// -// See Also -// -------- -// allclose: Returns True if two arrays are element-wise equal within a -// tolerance. -// array_equiv: Returns True if input arrays are shape consistent and all -// elements equal. -// -// Examples -// -------- -// >>> np.array_equal([1, 2], [1, 2]) -// True -// >>> np.array_equal(np.array([1, 2]), np.array([1, 2])) -// True -// >>> np.array_equal([1, 2], [1, 2, 3]) -// False -// >>> np.array_equal([1, 2], [1, 4]) -// False -// >>> a = np.array([1, np.nan]) -// >>> np.array_equal(a, a) -// False -// >>> np.array_equal(a, a, equal_nan=True) -// True -// -// When ``equal_nan`` is True, complex values with nan components are -// considered equal if either the real *or* the imaginary components are nan. -// -// >>> a = np.array([1 + 1j]) -// >>> b = a.copy() -// >>> a.real = np.nan -// >>> b.imag = np.nan -// >>> np.array_equal(a, b, equal_nan=True) -// True -// -// -//go:linkname ArrayEqual py.array_equal -func ArrayEqual(a1 *py.Object, a2 *py.Object, equalNan *py.Object) *py.Object -// -// Join a sequence of arrays along a new axis. -// -// The ``axis`` parameter specifies the index of the new axis in the -// dimensions of the result. For example, if ``axis=0`` it will be the first -// dimension and if ``axis=-1`` it will be the last dimension. -// -// .. versionadded:: 1.10.0 -// -// Parameters -// ---------- -// arrays : sequence of array_like -// Each array must have the same shape. -// -// axis : int, optional -// The axis in the result array along which the input arrays are stacked. -// -// out : ndarray, optional -// If provided, the destination to place the result. The shape must be -// 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 -// The stacked array has one more dimension than the input arrays. -// -// See Also -// -------- -// concatenate : Join a sequence of arrays along an existing axis. -// block : Assemble an nd-array from nested lists of blocks. -// split : Split array into a list of multiple sub-arrays of equal size. -// -// Examples -// -------- -// >>> arrays = [np.random.randn(3, 4) for _ in range(10)] -// >>> np.stack(arrays, axis=0).shape -// (10, 3, 4) -// -// >>> np.stack(arrays, axis=1).shape -// (3, 10, 4) -// -// >>> np.stack(arrays, axis=2).shape -// (3, 4, 10) -// -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.stack((a, b)) -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// >>> np.stack((a, b), axis=-1) -// array([[1, 4], -// [2, 5], -// [3, 6]]) -// -// -// -//go:linkname Stack py.stack -func Stack(arrays *py.Object, axis *py.Object, out *py.Object) *py.Object -// -// Returns a bool array, where True if input element is complex. -// -// What is tested is whether the input has a non-zero imaginary part, not if -// the input type is complex. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// -// Returns -// ------- -// out : ndarray of bools -// Output array. -// -// See Also -// -------- -// isreal -// iscomplexobj : Return True if x is a complex type or an array of complex -// numbers. -// -// Examples -// -------- -// >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]) -// array([ True, False, False, False, False, True]) -// -// -// -//go:linkname Iscomplex py.iscomplex -func Iscomplex(x *py.Object) *py.Object -// -// Return an array converted to a float type. -// -// Parameters -// ---------- -// a : array_like -// The input array. -// dtype : str or dtype object, optional -// Float type code to coerce input array `a`. If `dtype` is one of the -// 'int' dtypes, it is replaced with float64. -// -// Returns -// ------- -// out : ndarray -// The input `a` as a float ndarray. -// -// Examples -// -------- -// >>> np.asfarray([2, 3]) -// array([2., 3.]) -// >>> np.asfarray([2, 3], dtype='float') -// array([2., 3.]) -// >>> np.asfarray([2, 3], dtype='int8') -// array([2., 3.]) -// -// -// -//go:linkname Asfarray py.asfarray -func Asfarray(a *py.Object, dtype *py.Object) *py.Object -// -// Rotate an array by 90 degrees in the plane specified by axes. -// -// Rotation direction is from the first towards the second axis. -// This means for a 2D array with the default `k` and `axes`, the -// rotation will be counterclockwise. -// -// Parameters -// ---------- -// m : array_like -// Array of two or more dimensions. -// k : integer -// Number of times the array is rotated by 90 degrees. -// axes : (2,) array_like -// The array is rotated in the plane defined by the axes. -// Axes must be different. -// -// .. versionadded:: 1.12.0 -// -// Returns -// ------- -// y : ndarray -// A rotated view of `m`. -// -// See Also -// -------- -// flip : Reverse the order of elements in an array along the given axis. -// fliplr : Flip an array horizontally. -// flipud : Flip an array vertically. -// -// Notes -// ----- -// ``rot90(m, k=1, axes=(1,0))`` is the reverse of -// ``rot90(m, k=1, axes=(0,1))`` -// -// ``rot90(m, k=1, axes=(1,0))`` is equivalent to -// ``rot90(m, k=-1, axes=(0,1))`` -// -// Examples -// -------- -// >>> m = np.array([[1,2],[3,4]], int) -// >>> m -// array([[1, 2], -// [3, 4]]) -// >>> np.rot90(m) -// array([[2, 4], -// [1, 3]]) -// >>> np.rot90(m, 2) -// array([[4, 3], -// [2, 1]]) -// >>> m = np.arange(8).reshape((2,2,2)) -// >>> np.rot90(m, 1, (1,2)) -// array([[[1, 3], -// [0, 2]], -// [[5, 7], -// [4, 6]]]) -// -// -// -//go:linkname Rot90 py.rot90 -func Rot90(m *py.Object, k *py.Object, axes *py.Object) *py.Object -// -// Return a new array with sub-arrays along an axis deleted. For a one -// dimensional array, this returns those entries not returned by -// `arr[obj]`. -// -// Parameters -// ---------- -// arr : array_like -// Input array. -// obj : slice, int or array of ints -// Indicate indices of sub-arrays to remove along the specified axis. -// -// .. versionchanged:: 1.19.0 -// Boolean indices are now treated as a mask of elements to remove, -// rather than being cast to the integers 0 and 1. -// -// axis : int, optional -// The axis along which to delete the subarray defined by `obj`. -// If `axis` is None, `obj` is applied to the flattened array. -// -// Returns -// ------- -// out : ndarray -// A copy of `arr` with the elements specified by `obj` removed. Note -// that `delete` does not occur in-place. If `axis` is None, `out` is -// a flattened array. -// -// See Also -// -------- -// insert : Insert elements into an array. -// append : Append elements at the end of an array. -// -// Notes -// ----- -// Often it is preferable to use a boolean mask. For example: -// -// >>> arr = np.arange(12) + 1 -// >>> mask = np.ones(len(arr), dtype=bool) -// >>> mask[[0,2,4]] = False -// >>> result = arr[mask,...] -// -// Is equivalent to ``np.delete(arr, [0,2,4], axis=0)``, but allows further -// use of `mask`. -// -// Examples -// -------- -// >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) -// >>> arr -// array([[ 1, 2, 3, 4], -// [ 5, 6, 7, 8], -// [ 9, 10, 11, 12]]) -// >>> np.delete(arr, 1, 0) -// array([[ 1, 2, 3, 4], -// [ 9, 10, 11, 12]]) -// -// >>> np.delete(arr, np.s_[::2], 1) -// array([[ 2, 4], -// [ 6, 8], -// [10, 12]]) -// >>> np.delete(arr, [1,3,5], None) -// array([ 1, 3, 5, 7, 8, 9, 10, 11, 12]) -// -// -// -//go:linkname Delete py.delete -func Delete(arr *py.Object, obj *py.Object, axis *py.Object) *py.Object -// -// Return the product of array elements over a given axis treating Not a -// Numbers (NaNs) as ones. -// -// One is returned for slices that are all-NaN or empty. -// -// .. versionadded:: 1.10.0 -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose product is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the product is computed. The default is to compute -// the product of the flattened array. -// dtype : data-type, optional -// The type of the returned array and of the accumulator in which the -// elements are summed. By default, the dtype of `a` is used. An -// exception is when `a` has an integer type with less precision than -// the platform (u)intp. In that case, the default will be either -// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 -// bits. For inexact inputs, dtype must be inexact. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``. If provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. The casting of NaN to integer -// can yield unexpected results. -// keepdims : bool, optional -// If 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 `arr`. -// initial : scalar, optional -// The starting value for this product. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to include in the product. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// nanprod : ndarray -// A new array holding the result is returned unless `out` is -// specified, in which case it is returned. -// -// See Also -// -------- -// numpy.prod : Product across array propagating NaNs. -// isnan : Show which elements are NaN. -// -// Examples -// -------- -// >>> np.nanprod(1) -// 1 -// >>> np.nanprod([1]) -// 1 -// >>> np.nanprod([1, np.nan]) -// 1.0 -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nanprod(a) -// 6.0 -// >>> np.nanprod(a, axis=0) -// array([3., 2.]) -// -// -// -//go:linkname Nanprod py.nanprod -func Nanprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// -// Returns True if input arrays are shape consistent and all elements equal. -// -// Shape consistent means they are either the same shape, or one input array -// can be broadcasted to create the same shape as the other one. -// -// Parameters -// ---------- -// a1, a2 : array_like -// Input arrays. -// -// Returns -// ------- -// out : bool -// True if equivalent, False otherwise. -// -// Examples -// -------- -// >>> np.array_equiv([1, 2], [1, 2]) -// True -// >>> np.array_equiv([1, 2], [1, 3]) -// False -// -// Showing the shape equivalence: -// -// >>> np.array_equiv([1, 2], [[1, 2], [1, 2]]) -// True -// >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]]) -// False -// -// >>> np.array_equiv([1, 2], [[1, 2], [1, 3]]) -// False -// -// -// -//go:linkname ArrayEquiv py.array_equiv -func ArrayEquiv(a1 *py.Object, a2 *py.Object) *py.Object -// -// Return the binary representation of the input number as a string. -// -// For negative numbers, if width is not given, a minus sign is added to the -// front. If width is given, the two's complement of the number is -// returned, with respect to that width. -// -// In a two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit two's-complement -// system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// num : int -// Only an integer decimal number can be used. -// width : int, optional -// The length of the returned string if `num` is positive, or the length -// of the two's complement if `num` is negative, provided that `width` is -// at least a sufficient number of bits for `num` to be represented in the -// designated form. -// -// If the `width` value is insufficient, it will be ignored, and `num` will -// be returned in binary (`num` > 0) or two's complement (`num` < 0) form -// with its width equal to the minimum number of bits needed to represent -// the number in the designated form. This behavior is deprecated and will -// later raise an error. -// -// .. deprecated:: 1.12.0 -// -// Returns -// ------- -// bin : str -// Binary representation of `num` or two's complement of `num`. -// -// See Also -// -------- -// base_repr: Return a string representation of a number in the given base -// system. -// bin: Python's built-in binary representation generator of an integer. -// -// Notes -// ----- -// `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x -// faster. -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// >>> np.binary_repr(3) -// '11' -// >>> np.binary_repr(-3) -// '-11' -// >>> np.binary_repr(3, width=4) -// '0011' -// -// The two's complement is returned when the input number is negative and -// width is specified: -// -// >>> np.binary_repr(-3, width=3) -// '101' -// >>> np.binary_repr(-3, width=5) -// '11101' -// -// -// -//go:linkname BinaryRepr py.binary_repr -func BinaryRepr(num *py.Object, width *py.Object) *py.Object -// -// Test whether all array elements along a given axis evaluate to True. -// -// Parameters -// ---------- -// a : array_like -// Input array or object that can be converted to an array. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a logical AND reduction is performed. -// The default (``axis=None``) is to perform a logical AND over all -// the dimensions of the input array. `axis` may be negative, in -// which case it counts from the last to the first axis. -// -// .. versionadded:: 1.7.0 -// -// If this is a tuple of ints, a reduction is performed on multiple -// axes, instead of a single axis or all the axes as before. -// out : ndarray, optional -// Alternate output array in which to place the result. -// It must have the same shape as the expected output and its -// type is preserved (e.g., if ``dtype(out)`` is float, the result -// will consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` for more -// details. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `all` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// where : array_like of bool, optional -// Elements to include in checking for all `True` values. -// See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// all : ndarray, bool -// A new boolean or array is returned unless `out` is specified, -// in which case a reference to `out` is returned. -// -// See Also -// -------- -// ndarray.all : equivalent method -// -// any : Test whether any element along a given axis evaluates to True. -// -// Notes -// ----- -// Not a Number (NaN), positive infinity and negative infinity -// evaluate to `True` because these are not equal to zero. -// -// Examples -// -------- -// >>> np.all([[True,False],[True,True]]) -// False -// -// >>> np.all([[True,False],[True,True]], axis=0) -// array([ True, False]) -// -// >>> np.all([-1, 4, 5]) -// True -// -// >>> np.all([1.0, np.nan]) -// True -// -// >>> np.all([[True, True], [False, True]], where=[[True], [False]]) -// True -// -// >>> o=np.array(False) -// >>> z=np.all([-1, 4, 5], out=o) -// >>> id(z), id(o), z -// (28293632, 28293632, array(True)) # may vary -// -// -// -//go:linkname All py.all -func All(__llgo_va_list ...interface{}) *py.Object -// -// Return the number of elements along a given axis. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : int, optional -// Axis along which the elements are counted. By default, give -// the total number of elements. -// -// Returns -// ------- -// element_count : int -// Number of elements along the specified axis. -// -// See Also -// -------- -// shape : dimensions of array -// ndarray.shape : dimensions of array -// ndarray.size : number of elements in array -// -// Examples -// -------- -// >>> a = np.array([[1,2,3],[4,5,6]]) -// >>> np.size(a) -// 6 -// >>> np.size(a,1) -// 3 -// >>> np.size(a,0) -// 2 -// -// -// -//go:linkname Size py.size -func Size(a *py.Object, axis *py.Object) *py.Object -// -// busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None) -// -// Counts the number of valid days between `begindates` and -// `enddates`, not including the day of `enddates`. -// -// If ``enddates`` specifies a date value that is earlier than the -// corresponding ``begindates`` date value, the count will be negative. -// -// .. versionadded:: 1.7.0 -// -// Parameters -// ---------- -// begindates : array_like of datetime64[D] -// The array of the first dates for counting. -// enddates : array_like of datetime64[D] -// The array of the end dates for counting, which are excluded -// from the count themselves. -// weekmask : str or array_like of bool, optional -// A seven-element array indicating which of Monday through Sunday are -// valid days. May be specified as a length-seven list or array, like -// [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string -// like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for -// weekdays, optionally separated by white space. Valid abbreviations -// are: Mon Tue Wed Thu Fri Sat Sun -// holidays : array_like of datetime64[D], optional -// An array of dates to consider as invalid dates. They may be -// specified in any order, and NaT (not-a-time) dates are ignored. -// This list is saved in a normalized form that is suited for -// fast calculations of valid days. -// busdaycal : busdaycalendar, optional -// A `busdaycalendar` object which specifies the valid days. If this -// parameter is provided, neither weekmask nor holidays may be -// provided. -// out : array of int, optional -// If provided, this array is filled with the result. -// -// Returns -// ------- -// out : array of int -// An array with a shape from broadcasting ``begindates`` and ``enddates`` -// together, containing the number of valid days between -// the begin and end dates. -// -// See Also -// -------- -// busdaycalendar : An object that specifies a custom set of valid days. -// is_busday : Returns a boolean array indicating valid days. -// busday_offset : Applies an offset counted in valid days. -// -// Examples -// -------- -// >>> # Number of weekdays in January 2011 -// ... np.busday_count('2011-01', '2011-02') -// 21 -// >>> # Number of weekdays in 2011 -// >>> np.busday_count('2011', '2012') -// 260 -// >>> # Number of Saturdays in 2011 -// ... np.busday_count('2011', '2012', weekmask='Sat') -// 53 -// -// -//go:linkname BusdayCount py.busday_count -func BusdayCount(begindates *py.Object, enddates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object -// -// Compute the qth quantile of the data along the specified axis, -// while ignoring nan values. -// Returns the qth quantile(s) of the array elements. -// -// .. versionadded:: 1.15.0 -// -// Parameters -// ---------- -// a : array_like -// Input array or object that can be converted to an array, containing -// nan values to be ignored -// q : array_like of float -// Probability or sequence of probabilities for the quantiles to compute. -// Values must be between 0 and 1 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the quantiles are computed. The -// default is to compute the quantile(s) along a flattened -// version of the array. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by intermediate -// calculations, to save memory. In this case, the contents of the input -// `a` after this function completes is undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// quantile. There are many different methods, some unique to NumPy. -// See the notes for explanation. The options sorted by their R type -// as summarized in the H&F paper [1]_ are: -// -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' -// -// The first three methods are discontinuous. NumPy further defines the -// following discontinuous variations of the default 'linear' (7.) option: -// -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' -// -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. -// -// 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 array `a`. -// -// If this is anything but the default value it will be passed -// through (in the special case of an empty array) to the -// `mean` function of the underlying array. If the array is -// a sub-class and `mean` does not have the kwarg `keepdims` this -// will raise a RuntimeError. -// -// interpolation : str, optional -// Deprecated name for the method keyword argument. -// -// .. deprecated:: 1.22.0 -// -// Returns -// ------- -// quantile : scalar or ndarray -// If `q` is a single probability and `axis=None`, then the result -// is a scalar. If multiple probability levels are given, first axis of -// the result corresponds to the quantiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the -// same as that of the input. If `out` is specified, that array is -// returned instead. -// -// See Also -// -------- -// quantile -// nanmean, nanmedian -// nanmedian : equivalent to ``nanquantile(..., 0.5)`` -// nanpercentile : same as nanquantile, but with q in the range [0, 100]. -// -// Notes -// ----- -// For more information please see `numpy.quantile` -// -// Examples -// -------- -// >>> a = np.array([[10., 7., 4.], [3., 2., 1.]]) -// >>> a[0][1] = np.nan -// >>> a -// array([[10., nan, 4.], -// [ 3., 2., 1.]]) -// >>> np.quantile(a, 0.5) -// nan -// >>> np.nanquantile(a, 0.5) -// 3.0 -// >>> np.nanquantile(a, 0.5, axis=0) -// array([6.5, 2. , 2.5]) -// >>> np.nanquantile(a, 0.5, axis=1, keepdims=True) -// array([[7.], -// [2.]]) -// >>> m = np.nanquantile(a, 0.5, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.nanquantile(a, 0.5, axis=0, out=out) -// array([6.5, 2. , 2.5]) -// >>> m -// array([6.5, 2. , 2.5]) -// >>> b = a.copy() -// >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a==b) -// -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 -// -// -// -//go:linkname Nanquantile py.nanquantile -func Nanquantile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object -// empty(shape, dtype=float, order='C', *, like=None) -// -// Return a new array of given shape and type, without initializing entries. -// -// Parameters -// ---------- -// shape : int or tuple of int -// Shape of the empty array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// Desired output data-type for the array, e.g, `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: 'C' -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of uninitialized (arbitrary) data of the given shape, dtype, and -// order. Object arrays will be initialized to None. -// -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. -// -// -// Notes -// ----- -// `empty`, unlike `zeros`, does not set the array values to zero, -// and may therefore be marginally faster. On the other hand, it requires -// the user to manually set all the values in the array, and should be -// used with caution. -// -// Examples -// -------- -// >>> np.empty([2, 2]) -// array([[ -9.74499359e+001, 6.69583040e-309], -// [ 2.13182611e-314, 3.06959433e-309]]) #uninitialized -// -// >>> np.empty([2, 2], dtype=int) -// array([[-1073741821, -1067949133], -// [ 496041986, 19249760]]) #uninitialized -// -//go:linkname Empty py.empty -func Empty(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// Return a list of coordinate matrices from coordinate vectors. -// -// Make N-D coordinate arrays for vectorized evaluations of -// N-D scalar/vector fields over N-D grids, given -// one-dimensional coordinate arrays x1, x2,..., xn. -// -// .. versionchanged:: 1.9 -// 1-D and 0-D cases are allowed. -// -// Parameters -// ---------- -// x1, x2,..., xn : array_like -// 1-D arrays representing the coordinates of a grid. -// indexing : {'xy', 'ij'}, optional -// Cartesian ('xy', default) or matrix ('ij') indexing of output. -// See Notes for more details. -// -// .. versionadded:: 1.7.0 -// sparse : bool, optional -// If True the shape of the returned coordinate array for dimension *i* -// is reduced from ``(N1, ..., Ni, ... Nn)`` to -// ``(1, ..., 1, Ni, 1, ..., 1)``. These sparse coordinate grids are -// intended to be use with :ref:`basics.broadcasting`. When all -// coordinates are used in an expression, broadcasting still leads to a -// fully-dimensonal result array. -// -// Default is False. -// -// .. versionadded:: 1.7.0 -// copy : bool, optional -// If False, a view into the original arrays are returned in order to -// conserve memory. Default is True. Please note that -// ``sparse=False, copy=False`` will likely return non-contiguous -// arrays. Furthermore, more than one element of a broadcast array -// may refer to a single memory location. If you need to write to the -// arrays, make copies first. -// -// .. versionadded:: 1.7.0 -// -// Returns -// ------- -// X1, X2,..., XN : list of ndarrays -// 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. -// -// Notes -// ----- -// This function supports both indexing conventions through the indexing -// keyword argument. Giving the string 'ij' returns a meshgrid with -// matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing. -// In the 2-D case with inputs of length M and N, the outputs are of shape -// (N, M) for 'xy' indexing and (M, N) for 'ij' indexing. In the 3-D case -// with inputs of length M, N and P, outputs are of shape (N, M, P) for -// 'xy' indexing and (M, N, P) for 'ij' indexing. The difference is -// illustrated by the following code snippet:: -// -// xv, yv = np.meshgrid(x, y, indexing='ij') -// for i in range(nx): -// for j in range(ny): -// # treat xv[i,j], yv[i,j] -// -// xv, yv = np.meshgrid(x, y, indexing='xy') -// for i in range(nx): -// for j in range(ny): -// # treat xv[j,i], yv[j,i] -// -// In the 1-D and 0-D case, the indexing and sparse keywords have no effect. -// -// See Also -// -------- -// mgrid : Construct a multi-dimensional "meshgrid" using indexing notation. -// ogrid : Construct an open multi-dimensional "meshgrid" using indexing -// notation. -// how-to-index -// -// Examples -// -------- -// >>> nx, ny = (3, 2) -// >>> x = np.linspace(0, 1, nx) -// >>> y = np.linspace(0, 1, ny) -// >>> xv, yv = np.meshgrid(x, y) -// >>> xv -// array([[0. , 0.5, 1. ], -// [0. , 0.5, 1. ]]) -// >>> yv -// array([[0., 0., 0.], -// [1., 1., 1.]]) -// -// 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, both dense and sparse outputs can be -// used. -// -// >>> x = np.linspace(-5, 5, 101) -// >>> y = np.linspace(-5, 5, 101) -// >>> # full coordinate arrays -// >>> xx, yy = np.meshgrid(x, y) -// >>> zz = np.sqrt(xx**2 + yy**2) -// >>> xx.shape, yy.shape, zz.shape -// ((101, 101), (101, 101), (101, 101)) -// >>> # sparse coordinate arrays -// >>> xs, ys = np.meshgrid(x, y, sparse=True) -// >>> zs = np.sqrt(xs**2 + ys**2) -// >>> xs.shape, ys.shape, zs.shape -// ((1, 101), (101, 1), (101, 101)) -// >>> np.array_equal(zz, zs) -// True -// -// >>> h = plt.contourf(x, y, zs) -// >>> plt.axis('scaled') -// >>> plt.colorbar() -// >>> plt.show() -// -// -//go:linkname Meshgrid py.meshgrid -func Meshgrid(__llgo_va_list ...interface{}) *py.Object -// Broadcast an array to a new shape. -// -// Parameters -// ---------- -// array : array_like -// The array to broadcast. -// shape : tuple or int -// The shape of the desired array. A single integer ``i`` is interpreted -// as ``(i,)``. -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise -// the returned array will be forced to be a base-class array (default). -// -// Returns -// ------- -// broadcast : array -// A readonly view on the original array with the given shape. It is -// typically not contiguous. Furthermore, more than one element of a -// broadcasted array may refer to a single memory location. -// -// Raises -// ------ -// ValueError -// If the array is not compatible with the new shape according to NumPy's -// broadcasting rules. -// -// See Also -// -------- -// broadcast -// broadcast_arrays -// broadcast_shapes -// -// Notes -// ----- -// .. versionadded:: 1.10.0 -// -// Examples -// -------- -// >>> x = np.array([1, 2, 3]) -// >>> np.broadcast_to(x, (3, 3)) -// array([[1, 2, 3], -// [1, 2, 3], -// [1, 2, 3]]) -// -// -//go:linkname BroadcastTo py.broadcast_to -func BroadcastTo(array *py.Object, shape *py.Object, subok *py.Object) *py.Object -// -// Compute the bi-dimensional histogram of two data samples. -// -// Parameters -// ---------- -// x : array_like, shape (N,) -// An array containing the x coordinates of the points to be -// histogrammed. -// y : array_like, shape (N,) -// An array containing the y coordinates of the points to be -// histogrammed. -// bins : int or array_like or [int, int] or [array, array], optional -// The bin specification: -// -// * If int, the number of bins for the two dimensions (nx=ny=bins). -// * If array_like, the bin edges for the two dimensions -// (x_edges=y_edges=bins). -// * If [int, int], the number of bins in each dimension -// (nx, ny = bins). -// * If [array, array], the bin edges in each dimension -// (x_edges, y_edges = bins). -// * A combination [int, array] or [array, int], where int -// is the number of bins and array is the bin edges. -// -// range : array_like, shape(2,2), optional -// The leftmost and rightmost edges of the bins along each dimension -// (if not specified explicitly in the `bins` parameters): -// ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range -// will be considered outliers and not tallied in the histogram. -// density : bool, optional -// 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``. -// 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 `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, shape(nx, ny) -// The bi-dimensional histogram of samples `x` and `y`. Values in `x` -// are histogrammed along the first dimension and values in `y` are -// histogrammed along the second dimension. -// xedges : ndarray, shape(nx+1,) -// The bin edges along the first dimension. -// yedges : ndarray, shape(ny+1,) -// The bin edges along the second dimension. -// -// See Also -// -------- -// histogram : 1D histogram -// histogramdd : Multidimensional histogram -// -// Notes -// ----- -// 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. -// -// Please note that the histogram does not follow the Cartesian convention -// where `x` values are on the abscissa and `y` values on the ordinate -// axis. Rather, `x` is histogrammed along the first dimension of the -// array (vertical), and `y` along the second dimension of the array -// (horizontal). This ensures compatibility with `histogramdd`. -// -// Examples -// -------- -// >>> from matplotlib.image import NonUniformImage -// >>> import matplotlib.pyplot as plt -// -// Construct a 2-D histogram with variable bin width. First define the bin -// edges: -// -// >>> xedges = [0, 1, 3, 5] -// >>> yedges = [0, 2, 3, 4, 6] -// -// Next we create a histogram H with random bin content: -// -// >>> x = np.random.normal(2, 1, 100) -// >>> y = np.random.normal(1, 1, 100) -// >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) -// >>> # Histogram does not follow Cartesian convention (see Notes), -// >>> # therefore transpose H for visualization purposes. -// >>> H = H.T -// -// :func:`imshow ` can only display square bins: -// -// >>> fig = plt.figure(figsize=(7, 3)) -// >>> ax = fig.add_subplot(131, title='imshow: square bins') -// >>> plt.imshow(H, interpolation='nearest', origin='lower', -// ... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) -// -// -// :func:`pcolormesh ` can display actual edges: -// -// >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges', -// ... aspect='equal') -// >>> X, Y = np.meshgrid(xedges, yedges) -// >>> ax.pcolormesh(X, Y, H) -// -// -// :class:`NonUniformImage ` can be used to -// display actual bin edges with interpolation: -// -// >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated', -// ... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]]) -// >>> im = NonUniformImage(ax, interpolation='bilinear') -// >>> xcenters = (xedges[:-1] + xedges[1:]) / 2 -// >>> ycenters = (yedges[:-1] + yedges[1:]) / 2 -// >>> im.set_data(xcenters, ycenters, H) -// >>> ax.add_image(im) -// >>> plt.show() -// -// It is also possible to construct a 2-D histogram without specifying bin -// edges: -// -// >>> # Generate non-symmetric test data -// >>> n = 10000 -// >>> x = np.linspace(1, 100, n) -// >>> y = 2*np.log(x) + np.random.rand(n) - 0.5 -// >>> # Compute 2d histogram. Note the order of x/y and xedges/yedges -// >>> H, yedges, xedges = np.histogram2d(y, x, bins=20) -// -// Now we can plot the histogram using -// :func:`pcolormesh `, and a -// :func:`hexbin ` for comparison. -// -// >>> # Plot histogram using pcolormesh -// >>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True) -// >>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow') -// >>> ax1.plot(x, 2*np.log(x), 'k-') -// >>> ax1.set_xlim(x.min(), x.max()) -// >>> ax1.set_ylim(y.min(), y.max()) -// >>> ax1.set_xlabel('x') -// >>> ax1.set_ylabel('y') -// >>> ax1.set_title('histogram2d') -// >>> ax1.grid() -// -// >>> # Create hexbin plot for comparison -// >>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow') -// >>> ax2.plot(x, 2*np.log(x), 'k-') -// >>> ax2.set_title('hexbin') -// >>> ax2.set_xlim(x.min(), x.max()) -// >>> ax2.set_xlabel('x') -// >>> ax2.grid() -// -// >>> plt.show() -// -// -//go:linkname Histogram2d py.histogram2d -func Histogram2d(x *py.Object, y *py.Object, bins *py.Object, Range *py.Object, density *py.Object, weights *py.Object) *py.Object -// -// Return an antiderivative (indefinite integral) of a polynomial. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// The returned order `m` antiderivative `P` of polynomial `p` satisfies -// :math:`\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1` -// integration constants `k`. The constants determine the low-order -// polynomial part -// -// .. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1} -// -// of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`. -// -// Parameters -// ---------- -// p : array_like or poly1d -// Polynomial to integrate. -// A sequence is interpreted as polynomial coefficients, see `poly1d`. -// m : int, optional -// Order of the antiderivative. (Default: 1) -// k : list of `m` scalars or scalar, optional -// Integration constants. They are given in the order of integration: -// those corresponding to highest-order terms come first. -// -// If ``None`` (default), all constants are assumed to be zero. -// If `m = 1`, a single scalar can be given instead of a list. -// -// See Also -// -------- -// polyder : derivative of a polynomial -// poly1d.integ : equivalent method -// -// Examples -// -------- -// The defining property of the antiderivative: -// -// >>> p = np.poly1d([1,1,1]) -// >>> P = np.polyint(p) -// >>> P -// poly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary -// >>> np.polyder(P) == p -// True -// -// The integration constants default to zero, but can be specified: -// -// >>> P = np.polyint(p, 3) -// >>> P(0) -// 0.0 -// >>> np.polyder(P)(0) -// 0.0 -// >>> np.polyder(P, 2)(0) -// 0.0 -// >>> P = np.polyint(p, 3, k=[6,5,3]) -// >>> P -// poly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may vary -// -// Note that 3 = 6 / 2!, and that the constants are given in the order of -// integrations. Constant of the highest-order polynomial term comes first: -// -// >>> np.polyder(P, 2)(0) -// 6.0 -// >>> np.polyder(P, 1)(0) -// 5.0 -// >>> P(0) -// 3.0 -// -// -// -//go:linkname Polyint py.polyint -func Polyint(p *py.Object, m *py.Object, k *py.Object) *py.Object -// -// Deprecates a function and includes the deprecation in its docstring. -// -// This function is used as a decorator. It returns an object that can be -// used to issue a DeprecationWarning, by passing the to-be decorated -// function as argument, this adds warning to the to-be decorated function's -// docstring and returns the new function object. -// -// See Also -// -------- -// deprecate : Decorate a function such that it issues a `DeprecationWarning` -// -// Parameters -// ---------- -// msg : str -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// obj : object -// -// -// -//go:linkname DeprecateWithDoc py.deprecate_with_doc -func DeprecateWithDoc(msg *py.Object) *py.Object -// -// Return the sum of array elements over a given axis treating Not a -// Numbers (NaNs) as zero. -// -// In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or -// empty. In later versions zero is returned. -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose sum is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the sum is computed. The default is to compute the -// sum of the flattened array. -// dtype : data-type, optional -// The type of the returned array and of the accumulator in which the -// elements are summed. By default, the dtype of `a` is used. An -// exception is when `a` has an integer type with less precision than -// the platform (u)intp. In that case, the default will be either -// (u)int32 or (u)int64 depending on whether the platform is 32 or 64 -// bits. For inexact inputs, dtype must be inexact. -// -// .. versionadded:: 1.8.0 -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``. If provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. The casting of NaN to integer -// can yield unexpected results. -// -// .. versionadded:: 1.8.0 -// 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`. -// -// -// If the value is anything but the default, then -// `keepdims` will be passed through to the `mean` or `sum` methods -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// -// .. versionadded:: 1.8.0 -// initial : scalar, optional -// Starting value for the sum. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to include in the sum. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// nansum : ndarray. -// A new array holding the result is returned unless `out` is -// specified, in which it is returned. The result has the same -// size as `a`, and the same shape as `a` if `axis` is not None -// or `a` is a 1-d array. -// -// See Also -// -------- -// numpy.sum : Sum across array propagating NaNs. -// isnan : Show which elements are NaN. -// isfinite : Show which elements are not NaN or +/-inf. -// -// Notes -// ----- -// If both positive and negative infinity are present, the sum will be Not -// A Number (NaN). -// -// Examples -// -------- -// >>> np.nansum(1) -// 1 -// >>> np.nansum([1]) -// 1 -// >>> np.nansum([1, np.nan]) -// 1.0 -// >>> a = np.array([[1, 1], [1, np.nan]]) -// >>> np.nansum(a) -// 3.0 -// >>> np.nansum(a, axis=0) -// array([2., 1.]) -// >>> np.nansum([1, np.nan, np.inf]) -// inf -// >>> np.nansum([1, np.nan, np.NINF]) -// -inf -// >>> from numpy.testing import suppress_warnings -// >>> with suppress_warnings() as sup: -// ... sup.filter(RuntimeWarning) -// ... np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present -// nan -// -// -// -//go:linkname Nansum py.nansum -func Nansum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// zeros(shape, dtype=float, order='C', *, like=None) -// -// Return a new array of given shape and type, filled with zeros. -// -// Parameters -// ---------- -// shape : int or tuple of ints -// Shape of the new array, e.g., ``(2, 3)`` or ``2``. -// dtype : data-type, optional -// The desired data-type for the array, e.g., `numpy.int8`. Default is -// `numpy.float64`. -// order : {'C', 'F'}, optional, default: 'C' -// Whether to store multi-dimensional data in row-major -// (C-style) or column-major (Fortran-style) order in -// memory. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array of zeros with the given shape, dtype, and order. -// -// See Also -// -------- -// zeros_like : Return an array of zeros with shape and type of input. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// full : Return a new array of given shape filled with value. -// -// Examples -// -------- -// >>> np.zeros(5) -// array([ 0., 0., 0., 0., 0.]) -// -// >>> np.zeros((5,), dtype=int) -// array([0, 0, 0, 0, 0]) -// -// >>> np.zeros((2, 1)) -// array([[ 0.], -// [ 0.]]) -// -// >>> s = (2,2) -// >>> np.zeros(s) -// array([[ 0., 0.], -// [ 0., 0.]]) -// -// >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype -// array([(0, 0), (0, 0)], -// dtype=[('x', '>> a = np.arange(6).reshape((3, 2)) -// >>> a -// array([[0, 1], -// [2, 3], -// [4, 5]]) -// -// You can think of reshaping as first raveling the array (using the given -// index order), then inserting the elements from the raveled array into the -// new array using the same kind of index ordering as was used for the -// raveling. -// -// >>> np.reshape(a, (2, 3)) # C-like index ordering -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering -// array([[0, 4, 3], -// [2, 1, 5]]) -// >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F') -// array([[0, 4, 3], -// [2, 1, 5]]) -// -// Examples -// -------- -// >>> a = np.array([[1,2,3], [4,5,6]]) -// >>> np.reshape(a, 6) -// array([1, 2, 3, 4, 5, 6]) -// >>> np.reshape(a, 6, order='F') -// array([1, 4, 2, 5, 3, 6]) -// -// >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 -// array([[1, 2], -// [3, 4], -// [5, 6]]) -// -// -//go:linkname Reshape py.reshape -func Reshape(a *py.Object, newshape *py.Object, order *py.Object) *py.Object -// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs in base-2. -// -// Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine -// learning when the calculated probabilities of events may be so small as -// to exceed the range of normal floating point numbers. In such cases -// the base-2 logarithm of the calculated probability can be used instead. -// This function allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Base-2 logarithm of ``2**x1 + 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp: Logarithm of the sum of exponentiations of the inputs. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log2(1e-50) -// >>> prob2 = np.log2(2.5e-50) -// >>> prob12 = np.logaddexp2(prob1, prob2) -// >>> prob1, prob2, prob12 -// (-166.09640474436813, -164.77447664948076, -164.28904982231052) -// >>> 2**prob12 -// 3.4999999999999914e-50 -// -//go:linkname Logaddexp2 py.logaddexp2 -func Logaddexp2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return the gradient of an N-dimensional array. -// -// The gradient is computed using second order accurate central differences -// in the interior points and either first or second order accurate one-sides -// (forward or backwards) differences at the boundaries. -// The returned gradient hence has the same shape as the input array. -// -// Parameters -// ---------- -// f : array_like -// An N-dimensional array containing samples of a scalar function. -// varargs : list of scalar or array, optional -// Spacing between f values. Default unitary spacing for all dimensions. -// Spacing can be specified using: -// -// 1. single scalar to specify a sample distance for all dimensions. -// 2. N scalars to specify a constant sample distance for each dimension. -// i.e. `dx`, `dy`, `dz`, ... -// 3. N arrays to specify the coordinates of the values along each -// dimension of F. The length of the array must match the size of -// the corresponding dimension -// 4. Any combination of N scalars/arrays with the meaning of 2. and 3. -// -// If `axis` is given, the number of varargs must equal the number of axes. -// Default: 1. -// -// edge_order : {1, 2}, optional -// Gradient is calculated using N-th order accurate differences -// at the boundaries. Default: 1. -// -// .. versionadded:: 1.9.1 -// -// axis : None or int or tuple of ints, optional -// Gradient is calculated only along the given axis or axes -// The default (axis = None) is to calculate the gradient for all the axes -// of the input array. axis may be negative, in which case it counts from -// the last to the first axis. -// -// .. versionadded:: 1.11.0 -// -// Returns -// ------- -// gradient : ndarray or list of ndarray -// A list of ndarrays (or a single ndarray if there is only one dimension) -// corresponding to the derivatives of f with respect to each dimension. -// Each derivative has the same shape as f. -// -// Examples -// -------- -// >>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float) -// >>> np.gradient(f) -// array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) -// >>> np.gradient(f, 2) -// array([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ]) -// -// Spacing can be also specified with an array that represents the coordinates -// of the values F along the dimensions. -// For instance a uniform spacing: -// -// >>> x = np.arange(f.size) -// >>> np.gradient(f, x) -// array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) -// -// Or a non uniform one: -// -// >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float) -// >>> np.gradient(f, x) -// array([1. , 3. , 3.5, 6.7, 6.9, 2.5]) -// -// For two dimensional arrays, the return will be two arrays ordered by -// axis. In this example the first array stands for the gradient in -// rows and the second one in columns direction: -// -// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float)) -// [array([[ 2., 2., -1.], -// [ 2., 2., -1.]]), array([[1. , 2.5, 4. ], -// [1. , 1. , 1. ]])] -// -// In this example the spacing is also specified: -// uniform for axis=0 and non uniform for axis=1 -// -// >>> dx = 2. -// >>> y = [1., 1.5, 3.5] -// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y) -// [array([[ 1. , 1. , -0.5], -// [ 1. , 1. , -0.5]]), array([[2. , 2. , 2. ], -// [2. , 1.7, 0.5]])] -// -// It is possible to specify how boundaries are treated using `edge_order` -// -// >>> x = np.array([0, 1, 2, 3, 4]) -// >>> f = x**2 -// >>> np.gradient(f, edge_order=1) -// array([1., 2., 4., 6., 7.]) -// >>> np.gradient(f, edge_order=2) -// array([0., 2., 4., 6., 8.]) -// -// The `axis` keyword can be used to specify a subset of axes of which the -// gradient is calculated -// -// >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0) -// array([[ 2., 2., -1.], -// [ 2., 2., -1.]]) -// -// Notes -// ----- -// Assuming that :math:`f\in C^{3}` (i.e., :math:`f` has at least 3 continuous -// derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we -// minimize the "consistency error" :math:`\eta_{i}` between the true gradient -// and its estimate from a linear combination of the neighboring grid-points: -// -// .. math:: -// -// \eta_{i} = f_{i}^{\left(1\right)} - -// \left[ \alpha f\left(x_{i}\right) + -// \beta f\left(x_{i} + h_{d}\right) + -// \gamma f\left(x_{i}-h_{s}\right) -// \right] -// -// By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})` -// with their Taylor series expansion, this translates into solving -// the following the linear system: -// -// .. math:: -// -// \left\{ -// \begin{array}{r} -// \alpha+\beta+\gamma=0 \\ -// \beta h_{d}-\gamma h_{s}=1 \\ -// \beta h_{d}^{2}+\gamma h_{s}^{2}=0 -// \end{array} -// \right. -// -// The resulting approximation of :math:`f_{i}^{(1)}` is the following: -// -// .. math:: -// -// \hat f_{i}^{(1)} = -// \frac{ -// h_{s}^{2}f\left(x_{i} + h_{d}\right) -// + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right) -// - h_{d}^{2}f\left(x_{i}-h_{s}\right)} -// { h_{s}h_{d}\left(h_{d} + h_{s}\right)} -// + \mathcal{O}\left(\frac{h_{d}h_{s}^{2} -// + h_{s}h_{d}^{2}}{h_{d} -// + h_{s}}\right) -// -// It is worth noting that if :math:`h_{s}=h_{d}` -// (i.e., data are evenly spaced) -// we find the standard second order approximation: -// -// .. math:: -// -// \hat f_{i}^{(1)}= -// \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h} -// + \mathcal{O}\left(h^{2}\right) -// -// With a similar procedure the forward/backward approximations used for -// boundaries can be derived. -// -// References -// ---------- -// .. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics -// (Texts in Applied Mathematics). New York: Springer. -// .. [2] Durran D. R. (1999) Numerical Methods for Wave Equations -// in Geophysical Fluid Dynamics. New York: Springer. -// .. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on -// Arbitrarily Spaced Grids, -// Mathematics of Computation 51, no. 184 : 699-706. -// `PDF `_. -// -// -//go:linkname Gradient py.gradient -func Gradient(f *py.Object, __llgo_va_list ...interface{}) *py.Object -// -// Kronecker product of two arrays. -// -// Computes the Kronecker product, a composite array made of blocks of the -// second array scaled by the first. -// -// Parameters -// ---------- -// a, b : array_like -// -// Returns -// ------- -// out : ndarray -// -// See Also -// -------- -// outer : The outer product -// -// Notes -// ----- -// The function assumes that the number of dimensions of `a` and `b` -// are the same, if necessary prepending the smallest with ones. -// If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``, -// the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``. -// The elements are products of elements from `a` and `b`, organized -// explicitly by:: -// -// kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN] -// -// where:: -// -// kt = it * st + jt, t = 0,...,N -// -// In the common 2-D case (N=1), the block structure can be visualized:: -// -// [[ a[0,0]*b, a[0,1]*b, ... , a[0,-1]*b ], -// [ ... ... ], -// [ a[-1,0]*b, a[-1,1]*b, ... , a[-1,-1]*b ]] -// -// -// Examples -// -------- -// >>> np.kron([1,10,100], [5,6,7]) -// array([ 5, 6, 7, ..., 500, 600, 700]) -// >>> np.kron([5,6,7], [1,10,100]) -// array([ 5, 50, 500, ..., 7, 70, 700]) -// -// >>> np.kron(np.eye(2), np.ones((2,2))) -// array([[1., 1., 0., 0.], -// [1., 1., 0., 0.], -// [0., 0., 1., 1.], -// [0., 0., 1., 1.]]) -// -// >>> a = np.arange(100).reshape((2,5,2,5)) -// >>> b = np.arange(24).reshape((2,3,4)) -// >>> c = np.kron(a,b) -// >>> c.shape -// (2, 10, 6, 20) -// >>> I = (1,3,0,2) -// >>> J = (0,2,1) -// >>> J1 = (0,) + J # extend to ndim=4 -// >>> S1 = (1,) + b.shape -// >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1)) -// >>> c[K] == a[I]*b[J] -// True -// -// -// -//go:linkname Kron py.kron -func Kron(a *py.Object, b *py.Object) *py.Object -// -// inner(a, b, /) -// -// Inner product of two arrays. -// -// Ordinary inner product of vectors for 1-D arrays (without complex -// conjugation), in higher dimensions a sum product over the last axes. -// -// Parameters -// ---------- -// a, b : array_like -// If `a` and `b` are nonscalar, their last dimensions must match. -// -// Returns -// ------- -// out : ndarray -// If `a` and `b` are both -// scalars or both 1-D arrays then a scalar is returned; otherwise -// an array is returned. -// ``out.shape = (*a.shape[:-1], *b.shape[:-1])`` -// -// Raises -// ------ -// ValueError -// If both `a` and `b` are nonscalar and their last dimensions have -// different sizes. -// -// See Also -// -------- -// tensordot : Sum products over arbitrary axes. -// dot : Generalised matrix product, using second last dimension of `b`. -// einsum : Einstein summation convention. -// -// Notes -// ----- -// For vectors (1-D arrays) it computes the ordinary inner-product:: -// -// np.inner(a, b) = sum(a[:]*b[:]) -// -// More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``:: -// -// np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1)) -// -// or explicitly:: -// -// np.inner(a, b)[i0,...,ir-2,j0,...,js-2] -// = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:]) -// -// In addition `a` or `b` may be scalars, in which case:: -// -// np.inner(a,b) = a*b -// -// Examples -// -------- -// Ordinary inner product for vectors: -// -// >>> a = np.array([1,2,3]) -// >>> b = np.array([0,1,0]) -// >>> np.inner(a, b) -// 2 -// -// Some multidimensional examples: -// -// >>> a = np.arange(24).reshape((2,3,4)) -// >>> b = np.arange(4) -// >>> c = np.inner(a, b) -// >>> c.shape -// (2, 3) -// >>> c -// array([[ 14, 38, 62], -// [ 86, 110, 134]]) -// -// >>> a = np.arange(2).reshape((1,1,2)) -// >>> b = np.arange(6).reshape((3,2)) -// >>> c = np.inner(a, b) -// >>> c.shape -// (1, 1, 3) -// >>> c -// array([[[1, 3, 5]]]) -// -// An example where `b` is a scalar: -// -// >>> np.inner(np.eye(2), 7) -// array([[7., 0.], -// [0., 7.]]) -// -// -// -//go:linkname Inner py.inner -func Inner(a *py.Object, b *py.Object) *py.Object -//go:linkname Arccos py.arccos -func Arccos(__llgo_va_list ...interface{}) *py.Object -// float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// First array elements raised to powers from second array, element-wise. -// -// Raise each base in `x1` to the positionally-corresponding power in `x2`. -// `x1` and `x2` must be broadcastable to the same shape. This differs from -// the power function in that integers, float16, and float32 are promoted to -// floats with a minimum precision of float64 so that the result is always -// inexact. The intent is that the function will return a usable result for -// negative powers and seldom overflow for positive powers. -// -// Negative values raised to a non-integral value will return ``nan``. -// To get complex results, cast the input to complex, or specify the -// ``dtype`` to be ``complex`` (see the example below). -// -// .. versionadded:: 1.12.0 -// -// Parameters -// ---------- -// x1 : array_like -// The bases. -// x2 : array_like -// The exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The bases in `x1` raised to the exponents in `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// power : power function that preserves type -// -// Examples -// -------- -// Cube each element in a list. -// -// >>> x1 = range(6) -// >>> x1 -// [0, 1, 2, 3, 4, 5] -// >>> np.float_power(x1, 3) -// array([ 0., 1., 8., 27., 64., 125.]) -// -// Raise the bases to different exponents. -// -// >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] -// >>> np.float_power(x1, x2) -// array([ 0., 1., 8., 27., 16., 5.]) -// -// The effect of broadcasting. -// -// >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) -// >>> x2 -// array([[1, 2, 3, 3, 2, 1], -// [1, 2, 3, 3, 2, 1]]) -// >>> np.float_power(x1, x2) -// array([[ 0., 1., 8., 27., 16., 5.], -// [ 0., 1., 8., 27., 16., 5.]]) -// -// Negative values raised to a non-integral value will result in ``nan`` -// (and a warning will be generated). -// -// >>> x3 = np.array([-1, -4]) -// >>> with np.errstate(invalid='ignore'): -// ... p = np.float_power(x3, 1.5) -// ... -// >>> p -// array([nan, nan]) -// -// To get complex results, give the argument ``dtype=complex``. -// -// >>> np.float_power(x3, 1.5, dtype=complex) -// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j]) -// -//go:linkname FloatPower py.float_power -func FloatPower(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute hyperbolic tangent element-wise. -// -// Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// https://personal.math.ubc.ca/~cbm/aands/page_83.htm -// -// .. [2] Wikipedia, "Hyperbolic function", -// https://en.wikipedia.org/wiki/Hyperbolic_function -// -// Examples -// -------- -// >>> np.tanh((0, np.pi*1j, np.pi*1j/2)) -// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j]) -// -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.tanh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tanh py.tanh -func Tanh(x *py.Object, out *py.Object) *py.Object -// -// Return an array drawn from elements in choicelist, depending on conditions. -// -// Parameters -// ---------- -// condlist : list of bool ndarrays -// The list of conditions which determine from which array in `choicelist` -// the output elements are taken. When multiple conditions are satisfied, -// the first one encountered in `condlist` is used. -// choicelist : list of ndarrays -// The list of arrays from which the output elements are taken. It has -// to be of the same length as `condlist`. -// default : scalar, optional -// The element inserted in `output` when all conditions evaluate to False. -// -// Returns -// ------- -// output : ndarray -// The output at position m is the m-th element of the array in -// `choicelist` where the m-th element of the corresponding array in -// `condlist` is True. -// -// See Also -// -------- -// where : Return elements from one of two arrays depending on condition. -// take, choose, compress, diag, diagonal -// -// Examples -// -------- -// >>> x = np.arange(6) -// >>> condlist = [x<3, x>3] -// >>> choicelist = [x, x**2] -// >>> np.select(condlist, choicelist, 42) -// array([ 0, 1, 2, 42, 16, 25]) -// -// >>> condlist = [x<=4, x>3] -// >>> choicelist = [x, x**2] -// >>> np.select(condlist, choicelist, 55) -// array([ 0, 1, 2, 3, 4, 25]) -// -// -// -//go:linkname Select py.select -func Select(condlist *py.Object, choicelist *py.Object, Default *py.Object) *py.Object -// -// Least squares polynomial fit. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg` -// to points `(x, y)`. Returns a vector of coefficients `p` that minimises -// the squared error in the order `deg`, `deg-1`, ... `0`. -// -// The `Polynomial.fit ` class -// method is recommended for new code as it is more stable numerically. See -// the documentation of the method for more information. -// -// Parameters -// ---------- -// x : array_like, shape (M,) -// x-coordinates of the M sample points ``(x[i], y[i])``. -// y : array_like, shape (M,) or (M, K) -// y-coordinates of the sample points. Several data sets of sample -// points sharing the same x-coordinates can be fitted at once by -// passing in a 2D-array that contains one dataset per column. -// deg : int -// Degree of the fitting polynomial -// rcond : float, optional -// Relative condition number of the fit. Singular values smaller than -// this relative to the largest singular value will be ignored. The -// default value is len(x)*eps, where eps is the relative precision of -// the float type, about 2e-16 in most cases. -// full : bool, optional -// Switch determining nature of return value. When it is False (the -// default) just the coefficients are returned, when True diagnostic -// information from the singular value decomposition is also returned. -// w : array_like, shape (M,), optional -// Weights. If not None, the weight ``w[i]`` applies to the unsquared -// residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are -// chosen so that the errors of the products ``w[i]*y[i]`` all have the -// same variance. When using inverse-variance weighting, use -// ``w[i] = 1/sigma(y[i])``. The default value is None. -// cov : bool or str, optional -// If given and not `False`, return not just the estimate but also its -// covariance matrix. By default, the covariance are scaled by -// chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed -// to be unreliable except in a relative sense and everything is scaled -// such that the reduced chi2 is unity. This scaling is omitted if -// ``cov='unscaled'``, as is relevant for the case that the weights are -// w = 1/sigma, with sigma known to be a reliable estimate of the -// uncertainty. -// -// Returns -// ------- -// p : ndarray, shape (deg + 1,) or (deg + 1, K) -// Polynomial coefficients, highest power first. If `y` was 2-D, the -// coefficients for `k`-th data set are in ``p[:,k]``. -// -// residuals, rank, singular_values, rcond -// These values are only returned if ``full == True`` -// -// - residuals -- sum of squared residuals of the least squares fit -// - rank -- the effective rank of the scaled Vandermonde -// coefficient matrix -// - singular_values -- singular values of the scaled Vandermonde -// coefficient matrix -// - rcond -- value of `rcond`. -// -// For more details, see `numpy.linalg.lstsq`. -// -// V : ndarray, shape (M,M) or (M,M,K) -// Present only if ``full == False`` and ``cov == True``. The covariance -// matrix of the polynomial coefficient estimates. The diagonal of -// this matrix are the variance estimates for each coefficient. If y -// is a 2-D array, then the covariance matrix for the `k`-th data set -// are in ``V[:,:,k]`` -// -// -// Warns -// ----- -// RankWarning -// The rank of the coefficient matrix in the least-squares fit is -// deficient. The warning is only raised if ``full == False``. -// -// The warnings can be turned off by -// -// >>> import warnings -// >>> warnings.simplefilter('ignore', np.RankWarning) -// -// See Also -// -------- -// polyval : Compute polynomial values. -// linalg.lstsq : Computes a least-squares fit. -// scipy.interpolate.UnivariateSpline : Computes spline fits. -// -// Notes -// ----- -// The solution minimizes the squared error -// -// .. math:: -// E = \sum_{j=0}^k |p(x_j) - y_j|^2 -// -// in the equations:: -// -// x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0] -// x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1] -// ... -// x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k] -// -// The coefficient matrix of the coefficients `p` is a Vandermonde matrix. -// -// `polyfit` issues a `RankWarning` when the least-squares fit is badly -// conditioned. This implies that the best fit is not well-defined due -// to numerical error. The results may be improved by lowering the polynomial -// degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter -// can also be set to a value smaller than its default, but the resulting -// fit may be spurious: including contributions from the small singular -// values can add numerical noise to the result. -// -// Note that fitting polynomial coefficients is inherently badly conditioned -// when the degree of the polynomial is large or the interval of sample points -// is badly centered. The quality of the fit should always be checked in these -// cases. When polynomial fits are not satisfactory, splines may be a good -// alternative. -// -// References -// ---------- -// .. [1] Wikipedia, "Curve fitting", -// https://en.wikipedia.org/wiki/Curve_fitting -// .. [2] Wikipedia, "Polynomial interpolation", -// https://en.wikipedia.org/wiki/Polynomial_interpolation -// -// Examples -// -------- -// >>> import warnings -// >>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]) -// >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0]) -// >>> z = np.polyfit(x, y, 3) -// >>> z -// array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary -// -// It is convenient to use `poly1d` objects for dealing with polynomials: -// -// >>> p = np.poly1d(z) -// >>> p(0.5) -// 0.6143849206349179 # may vary -// >>> p(3.5) -// -0.34732142857143039 # may vary -// >>> p(10) -// 22.579365079365115 # may vary -// -// High-order polynomials may oscillate wildly: -// -// >>> with warnings.catch_warnings(): -// ... warnings.simplefilter('ignore', np.RankWarning) -// ... p30 = np.poly1d(np.polyfit(x, y, 30)) -// ... -// >>> p30(4) -// -0.80000000000000204 # may vary -// >>> p30(5) -// -0.99999999999999445 # may vary -// >>> p30(4.5) -// -0.10547061179440398 # may vary -// -// Illustration: -// -// >>> import matplotlib.pyplot as plt -// >>> xp = np.linspace(-2, 6, 100) -// >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--') -// >>> plt.ylim(-2,2) -// (-2, 2) -// >>> plt.show() -// -// -// -//go:linkname Polyfit py.polyfit -func Polyfit(x *py.Object, y *py.Object, deg *py.Object, rcond *py.Object, full *py.Object, w *py.Object, cov *py.Object) *py.Object -// -// Return minimum of an array or minimum along an axis, ignoring any NaNs. -// When all-NaN slices are encountered a ``RuntimeWarning`` is raised and -// Nan is returned for that slice. -// -// Parameters -// ---------- -// a : array_like -// Array containing numbers whose minimum is desired. If `a` is not an -// array, a conversion is attempted. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the minimum is computed. The default is to compute -// the minimum of the flattened array. -// out : ndarray, optional -// Alternate output array in which to place the result. The default -// is ``None``; if provided, it must have the same shape as the -// expected output, but the type will be cast if necessary. See -// :ref:`ufuncs-output-type` for more details. -// -// .. versionadded:: 1.8.0 -// 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`. -// -// If the value is anything but the default, then -// `keepdims` will be passed through to the `min` method -// of sub-classes of `ndarray`. If the sub-classes methods -// does not implement `keepdims` any exceptions will be raised. -// -// .. versionadded:: 1.8.0 -// initial : scalar, optional -// The maximum value of an output element. Must be present to allow -// computation on empty slice. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.22.0 -// where : array_like of bool, optional -// Elements to compare for the minimum. See `~numpy.ufunc.reduce` -// for details. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// nanmin : ndarray -// An array with the same shape as `a`, with the specified axis -// removed. If `a` is a 0-d array, or if axis is None, an ndarray -// scalar is returned. The same dtype as `a` is returned. -// -// See Also -// -------- -// nanmax : -// The maximum value of an array along a given axis, ignoring any NaNs. -// amin : -// The minimum value of an array along a given axis, propagating any NaNs. -// fmin : -// Element-wise minimum of two arrays, ignoring any NaNs. -// minimum : -// Element-wise minimum of two arrays, propagating any NaNs. -// isnan : -// Shows which elements are Not a Number (NaN). -// isfinite: -// Shows which elements are neither NaN nor infinity. -// -// amax, fmax, maximum -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// Positive infinity is treated as a very large number and negative -// infinity is treated as a very small (i.e. negative) number. -// -// If the input has a integer type the function is equivalent to np.min. -// -// Examples -// -------- -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nanmin(a) -// 1.0 -// >>> np.nanmin(a, axis=0) -// array([1., 2.]) -// >>> np.nanmin(a, axis=1) -// array([1., 3.]) -// -// When positive infinity and negative infinity are present: -// -// >>> np.nanmin([1, 2, np.nan, np.inf]) -// 1.0 -// >>> np.nanmin([1, 2, np.nan, np.NINF]) -// -inf -// -// -// -//go:linkname Nanmin py.nanmin -func Nanmin(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Cosine element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding cosine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> np.cos(np.array([0, np.pi/2, np.pi])) -// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) -// >>> -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Cos py.cos -func Cos(x *py.Object, out *py.Object) *py.Object -// gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the greatest common divisor of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The greatest common divisor of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// lcm : The lowest common multiple -// -// Examples -// -------- -// >>> np.gcd(12, 20) -// 4 -// >>> np.gcd.reduce([15, 25, 35]) -// 5 -// >>> np.gcd(np.arange(6), 20) -// array([20, 1, 2, 1, 4, 5]) -// -//go:linkname Gcd py.gcd -func Gcd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Set the floating-point error callback function or log object. -// -// There are two ways to capture floating-point error messages. The first -// is to set the error-handler to 'call', using `seterr`. Then, set -// the function to call using this function. -// -// The second is to set the error-handler to 'log', using `seterr`. -// Floating-point errors then trigger a call to the 'write' method of -// the provided object. -// -// Parameters -// ---------- -// func : callable f(err, flag) or object with write method -// Function to call upon floating-point errors ('call'-mode) or -// object whose 'write' method is used to log such message ('log'-mode). -// -// The call function takes two arguments. The first is a string describing -// the type of error (such as "divide by zero", "overflow", "underflow", -// or "invalid value"), and the second is the status flag. The flag is a -// byte, whose four least-significant bits indicate the type of error, one -// of "divide", "over", "under", "invalid":: -// -// [0 0 0 0 divide over under invalid] -// -// In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. -// -// If an object is provided, its write method should take one argument, -// a string. -// -// Returns -// ------- -// h : callable, log instance or None -// The old error handler. -// -// See Also -// -------- -// seterr, geterr, geterrcall -// -// Examples -// -------- -// Callback upon error: -// -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// ... -// -// >>> saved_handler = np.seterrcall(err_handler) -// >>> save_err = np.seterr(all='call') -// -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} -// -// Log error message: -// -// >>> class Log: -// ... def write(self, msg): -// ... print("LOG: %s" % msg) -// ... -// -// >>> log = Log() -// >>> saved_handler = np.seterrcall(log) -// >>> save_err = np.seterr(all='log') -// -// >>> np.array([1, 2, 3]) / 0.0 -// LOG: Warning: divide by zero encountered in divide -// array([inf, inf, inf]) -// -// >>> np.seterrcall(saved_handler) -// -// >>> np.seterr(**save_err) -// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} -// -// -// -//go:linkname Seterrcall py.seterrcall -func Seterrcall(Func *py.Object) *py.Object -// -// Check whether or not an object can be iterated over. -// -// Parameters -// ---------- -// y : object -// Input object. -// -// Returns -// ------- -// b : bool -// Return ``True`` if the object has an iterator method or is a -// sequence and ``False`` otherwise. -// -// -// Examples -// -------- -// >>> np.iterable([1, 2, 3]) -// True -// >>> np.iterable(2) -// False -// -// Notes -// ----- -// In most cases, the results of ``np.iterable(obj)`` are consistent with -// ``isinstance(obj, collections.abc.Iterable)``. One notable exception is -// the treatment of 0-dimensional arrays:: -// -// >>> from collections.abc import Iterable -// >>> a = np.array(1.0) # 0-dimensional numpy array -// >>> isinstance(a, Iterable) -// True -// >>> np.iterable(a) -// False -// -// -// -//go:linkname Iterable py.iterable -func Iterable(y *py.Object) *py.Object -// -// Reverse the order of elements along axis 0 (up/down). -// -// For a 2-D array, this flips the entries in each column in the up/down -// direction. Rows are preserved, but appear in a different order than before. -// -// Parameters -// ---------- -// m : array_like -// Input array. -// -// Returns -// ------- -// out : array_like -// A view of `m` with the rows reversed. Since a view is -// returned, this operation is :math:`\mathcal O(1)`. -// -// See Also -// -------- -// fliplr : Flip array in the left/right direction. -// flip : Flip array in one or more dimensions. -// rot90 : Rotate array counterclockwise. -// -// Notes -// ----- -// Equivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``. -// Requires the array to be at least 1-D. -// -// Examples -// -------- -// >>> A = np.diag([1.0, 2, 3]) -// >>> A -// array([[1., 0., 0.], -// [0., 2., 0.], -// [0., 0., 3.]]) -// >>> np.flipud(A) -// array([[0., 0., 3.], -// [0., 2., 0.], -// [1., 0., 0.]]) -// -// >>> A = np.random.randn(2,3,5) -// >>> np.all(np.flipud(A) == A[::-1,...]) -// True -// -// >>> np.flipud([1,2]) -// array([2, 1]) -// -// -// -//go:linkname Flipud py.flipud -func Flipud(m *py.Object) *py.Object -// -// Construct an array by executing a function over each coordinate. -// -// The resulting array therefore has a value ``fn(x, y, z)`` at -// coordinate ``(x, y, z)``. -// -// Parameters -// ---------- -// function : callable -// The function is called with N parameters, where N is the rank of -// `shape`. Each parameter represents the coordinates of the array -// varying along a specific axis. For example, if `shape` -// were ``(2, 2)``, then the parameters would be -// ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` -// shape : (N,) tuple of ints -// Shape of the output array, which also determines the shape of -// the coordinate arrays passed to `function`. -// dtype : data-type, optional -// Data-type of the coordinate arrays passed to `function`. -// By default, `dtype` is float. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// fromfunction : any -// The result of the call to `function` is passed back directly. -// Therefore the shape of `fromfunction` is completely determined by -// `function`. If `function` returns a scalar value, the shape of -// `fromfunction` would not match the `shape` parameter. -// -// See Also -// -------- -// indices, meshgrid -// -// Notes -// ----- -// 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], -// [False, False, True]]) -// -// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) -// array([[0, 1, 2], -// [1, 2, 3], -// [2, 3, 4]]) -// -// -// -//go:linkname Fromfunction py.fromfunction -func Fromfunction(function *py.Object, shape *py.Object) *py.Object -// -// Determine common type following standard coercion rules. -// -// .. deprecated:: NumPy 1.25 -// -// This function is deprecated, use `numpy.promote_types` or -// `numpy.result_type` instead. To achieve semantics for the -// `scalar_types` argument, use `numpy.result_type` and pass the Python -// values `0`, `0.0`, or `0j`. -// This will give the same results in almost all cases. -// More information and rare exception can be found in the -// `NumPy 1.25 release notes `_. -// -// Parameters -// ---------- -// array_types : sequence -// A list of dtypes or dtype convertible objects representing arrays. -// scalar_types : sequence -// A list of dtypes or dtype convertible objects representing scalars. -// -// Returns -// ------- -// datatype : dtype -// The common data type, which is the maximum of `array_types` ignoring -// `scalar_types`, unless the maximum of `scalar_types` is of a -// different kind (`dtype.kind`). If the kind is not understood, then -// None is returned. -// -// See Also -// -------- -// dtype, common_type, can_cast, mintypecode -// -// Examples -// -------- -// >>> np.find_common_type([], [np.int64, np.float32, complex]) -// dtype('complex128') -// >>> np.find_common_type([np.int64, np.float32], []) -// dtype('float64') -// -// The standard casting rules ensure that a scalar cannot up-cast an -// array unless the scalar is of a fundamentally different kind of data -// (i.e. under a different hierarchy in the data type hierarchy) then -// the array: -// -// >>> np.find_common_type([np.float32], [np.int64, np.float64]) -// dtype('float32') -// -// Complex is of a different type, so it up-casts the float in the -// `array_types` argument: -// -// >>> np.find_common_type([np.float32], [complex]) -// dtype('complex128') -// -// Type specifier strings are convertible to dtypes and can therefore -// be used instead of dtypes: -// -// >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) -// dtype('complex128') -// -// -// -//go:linkname FindCommonType py.find_common_type -func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object -// -// Set the size of the buffer used in ufuncs. -// -// Parameters -// ---------- -// size : int -// Size of buffer. -// -// -// -//go:linkname Setbufsize py.setbufsize -func Setbufsize(size *py.Object) *py.Object -// -// Estimate a covariance matrix, given data and weights. -// -// Covariance indicates the level to which two variables vary together. -// If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`, -// then 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`. -// -// See the notes for an outline of the algorithm. -// -// Parameters -// ---------- -// m : array_like -// A 1-D or 2-D array containing multiple variables and observations. -// Each row of `m` represents a variable, and each column a single -// observation of all those variables. Also see `rowvar` below. -// y : array_like, optional -// An additional set of variables and observations. `y` has the same form -// as that of `m`. -// rowvar : bool, optional -// If `rowvar` is True (default), then each row represents a -// variable, with observations in the columns. Otherwise, the relationship -// is transposed: each column represents a variable, while the rows -// contain observations. -// bias : bool, optional -// Default normalization (False) is by ``(N - 1)``, where ``N`` is the -// number of observations given (unbiased estimate). If `bias` is True, -// then normalization is by ``N``. These values can be overridden by using -// the keyword ``ddof`` in numpy versions >= 1.5. -// ddof : int, optional -// If not ``None`` the default value implied by `bias` is overridden. -// Note that ``ddof=1`` will return the unbiased estimate, even if both -// `fweights` and `aweights` are specified, and ``ddof=0`` will return -// the simple average. See the notes for the details. The default value -// is ``None``. -// -// .. versionadded:: 1.5 -// fweights : array_like, int, optional -// 1-D array of integer frequency weights; the number of times each -// observation vector should be repeated. -// -// .. versionadded:: 1.10 -// aweights : array_like, optional -// 1-D array of observation vector weights. These relative weights are -// typically large for observations considered "important" and smaller for -// observations considered less "important". If ``ddof=0`` the array of -// weights can be used to assign probabilities to observation vectors. -// -// .. versionadded:: 1.10 -// dtype : data-type, optional -// Data-type of the result. By default, the return data-type will have -// at least `numpy.float64` precision. -// -// .. versionadded:: 1.20 -// -// Returns -// ------- -// out : ndarray -// The covariance matrix of the variables. -// -// See Also -// -------- -// corrcoef : Normalized covariance matrix -// -// Notes -// ----- -// Assume that the observations are in the columns of the observation -// array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The -// steps to compute the weighted covariance are as follows:: -// -// >>> m = np.arange(10, dtype=np.float64) -// >>> f = np.arange(10) * 2 -// >>> a = np.arange(10) ** 2. -// >>> ddof = 1 -// >>> w = f * a -// >>> v1 = np.sum(w) -// >>> v2 = np.sum(w * a) -// >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1 -// >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2) -// -// Note that when ``a == 1``, the normalization factor -// ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)`` -// as it should. -// -// Examples -// -------- -// Consider two variables, :math:`x_0` and :math:`x_1`, which -// correlate perfectly, but in opposite directions: -// -// >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T -// >>> x -// array([[0, 1, 2], -// [2, 1, 0]]) -// -// Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance -// matrix shows this clearly: -// -// >>> np.cov(x) -// array([[ 1., -1.], -// [-1., 1.]]) -// -// Note that element :math:`C_{0,1}`, which shows the correlation between -// :math:`x_0` and :math:`x_1`, is negative. -// -// Further, note how `x` and `y` are combined: -// -// >>> x = [-2.1, -1, 4.3] -// >>> y = [3, 1.1, 0.12] -// >>> X = np.stack((x, y), axis=0) -// >>> np.cov(X) -// array([[11.71 , -4.286 ], # may vary -// [-4.286 , 2.144133]]) -// >>> np.cov(x, y) -// array([[11.71 , -4.286 ], # may vary -// [-4.286 , 2.144133]]) -// >>> np.cov(x) -// array(11.71) -// -// -// -//go:linkname Cov py.cov -func Cov(m *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object, fweights *py.Object, aweights *py.Object) *py.Object -// -// Find the sum of two polynomials. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// Returns the polynomial resulting from the sum of two input polynomials. -// Each input must be either a poly1d object or a 1D sequence of polynomial -// coefficients, from highest to lowest degree. -// -// Parameters -// ---------- -// a1, a2 : array_like or poly1d object -// Input polynomials. -// -// Returns -// ------- -// out : ndarray or poly1d object -// The sum of the inputs. If either input is a poly1d object, then the -// output is also a poly1d object. Otherwise, it is a 1D array of -// polynomial coefficients from highest to lowest degree. -// -// See Also -// -------- -// poly1d : A one-dimensional polynomial class. -// poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval -// -// Examples -// -------- -// >>> np.polyadd([1, 2], [9, 5, 4]) -// array([9, 6, 6]) -// -// Using poly1d objects: -// -// >>> p1 = np.poly1d([1, 2]) -// >>> p2 = np.poly1d([9, 5, 4]) -// >>> print(p1) -// 1 x + 2 -// >>> print(p2) -// 2 -// 9 x + 5 x + 4 -// >>> print(np.polyadd(p1, p2)) -// 2 -// 9 x + 6 x + 6 -// -// -// -//go:linkname Polyadd py.polyadd -func Polyadd(a1 *py.Object, a2 *py.Object) *py.Object -// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// fmin, amin, nanmin -// -// Notes -// ----- -// The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when -// neither x1 nor x2 are nans, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.maximum([2, 3, 4], [1, 5, 2]) -// array([2, 5, 4]) -// -// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.maximum(np.Inf, 1) -// inf -// -//go:linkname Maximum py.maximum -func Maximum(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return the indices to access the main diagonal of an array. -// -// This returns a tuple of indices that can be used to access the main -// diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape -// (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for -// ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]`` -// for ``i = [0..n-1]``. -// -// Parameters -// ---------- -// n : int -// The size, along each dimension, of the arrays for which the returned -// indices can be used. -// -// ndim : int, optional -// The number of dimensions. -// -// See Also -// -------- -// diag_indices_from -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Create a set of indices to access the diagonal of a (4, 4) array: -// -// >>> di = np.diag_indices(4) -// >>> di -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// >>> a[di] = 100 -// >>> a -// array([[100, 1, 2, 3], -// [ 4, 100, 6, 7], -// [ 8, 9, 100, 11], -// [ 12, 13, 14, 100]]) -// -// Now, we create indices to manipulate a 3-D array: -// -// >>> d3 = np.diag_indices(2, 3) -// >>> d3 -// (array([0, 1]), array([0, 1]), array([0, 1])) -// -// And use it to set the diagonal of an array of zeros to 1: -// -// >>> a = np.zeros((2, 2, 2), dtype=int) -// >>> a[d3] = 1 -// >>> a -// array([[[1, 0], -// [0, 0]], -// [[0, 0], -// [0, 1]]]) -// -// -// -//go:linkname DiagIndices py.diag_indices -func DiagIndices(n *py.Object, ndim *py.Object) *py.Object -// -// Print or write to a file the source code for a NumPy object. -// -// The source code is only returned for objects written in Python. Many -// functions and classes are defined in C and will therefore not return -// useful information. -// -// Parameters -// ---------- -// object : numpy object -// Input object. This can be any object (function, class, module, -// ...). -// output : file object, optional -// If `output` not supplied then source code is printed to screen -// (sys.stdout). File object must be created with either write 'w' or -// append 'a' modes. -// -// See Also -// -------- -// lookfor, info -// -// Examples -// -------- -// >>> np.source(np.interp) #doctest: +SKIP -// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py -// def interp(x, xp, fp, left=None, right=None): -// """.... (full docstring printed)""" -// if isinstance(x, (float, int, number)): -// return compiled_interp([x], xp, fp, left, right).item() -// else: -// return compiled_interp(x, xp, fp, left, right) -// -// The source code is only returned for objects written in Python. -// -// >>> np.source(np.array) #doctest: +SKIP -// Not available for this object. -// -// -// -//go:linkname Source py.source -func Source(object *py.Object, output *py.Object) *py.Object -// arange([start,] stop[, step,], dtype=None, *, like=None) -// -// Return evenly spaced values within a given interval. -// -// ``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 Warning sections below for more information. -// -// Parameters -// ---------- -// start : integer or real, optional -// Start of interval. The interval includes this value. The default -// start value is 0. -// stop : integer or real -// End of interval. The interval does not include this value, except -// in some cases where `step` is not an integer and floating point -// round-off affects the length of `out`. -// step : integer or real, optional -// Spacing between values. For any output `out`, this is the distance -// 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, optional -// The type of the output array. If `dtype` is not given, infer the data -// type from the other input arguments. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// arange : ndarray -// Array of evenly spaced values. -// -// For floating point arguments, the length of the result is -// ``ceil((stop - start)/step)``. Because of floating point overflow, -// this rule may result in the last element of `out` being greater -// than `stop`. -// -// Warnings -// -------- -// The length of the output might not be numerically stable. -// -// Another stability issue is due to the internal implementation of -// `numpy.arange`. -// The actual step value used to populate the array is -// ``dtype(start + step) - dtype(start)`` and not `step`. Precision loss -// can occur here, due to casting or due to using floating points when -// `start` is much larger than `step`. This can lead to unexpected -// behaviour. For example:: -// -// >>> np.arange(0, 5, 0.5, dtype=int) -// array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) -// >>> np.arange(-3, 3, 0.5, dtype=int) -// array([-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]) -// -// 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 -// -------- -// >>> np.arange(3) -// array([0, 1, 2]) -// >>> np.arange(3.0) -// array([ 0., 1., 2.]) -// >>> np.arange(3,7) -// array([3, 4, 5, 6]) -// >>> np.arange(3,7,2) -// array([3, 5]) -// -//go:linkname Arange py.arange -func Arange(start *py.Object, stop *py.Object, step *py.Object, dtype *py.Object) *py.Object -// -// Return a string representation of a number in the given base system. -// -// Parameters -// ---------- -// number : int -// The value to convert. Positive and negative values are handled. -// base : int, optional -// Convert `number` to the `base` number system. The valid range is 2-36, -// the default value is 2. -// padding : int, optional -// Number of zeros padded on the left. Default is 0 (no padding). -// -// Returns -// ------- -// out : str -// String representation of `number` in `base` system. -// -// See Also -// -------- -// binary_repr : Faster version of `base_repr` for base 2. -// -// Examples -// -------- -// >>> np.base_repr(5) -// '101' -// >>> np.base_repr(6, 5) -// '11' -// >>> np.base_repr(7, base=5, padding=3) -// '00012' -// -// >>> np.base_repr(10, base=16) -// 'A' -// >>> np.base_repr(32, base=16) -// '20' -// -// -// -//go:linkname BaseRepr py.base_repr -func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object -// -// Return a full array with the same shape and type as a given array. -// -// Parameters -// ---------- -// a : array_like -// The shape and data-type of `a` define these same attributes of -// the returned array. -// fill_value : array_like -// Fill value. -// dtype : data-type, optional -// Overrides the data type of the result. -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, -// 'C' otherwise. 'K' means match the layout of `a` as closely -// as possible. -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `a`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// out : ndarray -// Array of `fill_value` with the same shape and type as `a`. -// -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// ones_like : Return an array of ones with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full : Return a new array of given shape filled with value. -// -// Examples -// -------- -// >>> x = np.arange(6, dtype=int) -// >>> np.full_like(x, 1) -// array([1, 1, 1, 1, 1, 1]) -// >>> np.full_like(x, 0.1) -// array([0, 0, 0, 0, 0, 0]) -// >>> np.full_like(x, 0.1, dtype=np.double) -// array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) -// >>> np.full_like(x, np.nan, dtype=np.double) -// array([nan, nan, nan, nan, nan, nan]) -// -// >>> y = np.arange(6, dtype=np.double) -// >>> 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]]]) -// -// -//go:linkname FullLike py.full_like -func FullLike(a *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object -// -// Return the maximum of an array or maximum along an axis. -// -// `amax` is an alias of `~numpy.max`. -// -// See Also -// -------- -// max : alias of this function -// ndarray.max : equivalent method -// -// -//go:linkname Amax py.amax -func Amax(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric inverse tangent, element-wise. -// -// The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``. -// -// Parameters -// ---------- -// x : array_like -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Out has the same shape as `x`. Its real part is in -// ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``). -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`) -// and the positive `x`-axis. -// angle : Argument of complex values. -// -// Notes -// ----- -// `arctan` is a multi-valued function: for each `x` there are infinitely -// many numbers `z` such that tan(`z`) = `x`. The convention is to return -// the angle `z` whose real part lies in [-pi/2, pi/2]. -// -// For real-valued input data types, `arctan` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arctan` is a complex analytic function that -// has [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous -// from the left on the former and from the right on the latter. -// -// The inverse tangent is also known as `atan` or tan^{-1}. -// -// References -// ---------- -// Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, -// 10th printing, New York: Dover, 1964, pp. 79. -// https://personal.math.ubc.ca/~cbm/aands/page_79.htm -// -// Examples -// -------- -// We expect the arctan of 0 to be 0, and of 1 to be pi/4: -// -// >>> np.arctan([0, 1]) -// array([ 0. , 0.78539816]) -// -// >>> np.pi/4 -// 0.78539816339744828 -// -// Plot arctan: -// -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-10, 10) -// >>> plt.plot(x, np.arctan(x)) -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Arctan py.arctan -func Arctan(x *py.Object, out *py.Object) *py.Object -// -// busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None) -// -// First adjusts the date to fall on a valid day according to -// the ``roll`` rule, then applies offsets to the given dates -// counted in valid days. -// -// .. versionadded:: 1.7.0 -// -// Parameters -// ---------- -// dates : array_like of datetime64[D] -// The array of dates to process. -// offsets : array_like of int -// The array of offsets, which is broadcast with ``dates``. -// roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional -// How to treat dates that do not fall on a valid day. The default -// is 'raise'. -// -// * 'raise' means to raise an exception for an invalid day. -// * 'nat' means to return a NaT (not-a-time) for an invalid day. -// * 'forward' and 'following' mean to take the first valid day -// later in time. -// * 'backward' and 'preceding' mean to take the first valid day -// earlier in time. -// * 'modifiedfollowing' means to take the first valid day -// later in time unless it is across a Month boundary, in which -// case to take the first valid day earlier in time. -// * 'modifiedpreceding' means to take the first valid day -// earlier in time unless it is across a Month boundary, in which -// case to take the first valid day later in time. -// weekmask : str or array_like of bool, optional -// A seven-element array indicating which of Monday through Sunday are -// valid days. May be specified as a length-seven list or array, like -// [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string -// like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for -// weekdays, optionally separated by white space. Valid abbreviations -// are: Mon Tue Wed Thu Fri Sat Sun -// holidays : array_like of datetime64[D], optional -// An array of dates to consider as invalid dates. They may be -// specified in any order, and NaT (not-a-time) dates are ignored. -// This list is saved in a normalized form that is suited for -// fast calculations of valid days. -// busdaycal : busdaycalendar, optional -// A `busdaycalendar` object which specifies the valid days. If this -// parameter is provided, neither weekmask nor holidays may be -// provided. -// out : array of datetime64[D], optional -// If provided, this array is filled with the result. -// -// Returns -// ------- -// out : array of datetime64[D] -// An array with a shape from broadcasting ``dates`` and ``offsets`` -// together, containing the dates with offsets applied. -// -// See Also -// -------- -// busdaycalendar : An object that specifies a custom set of valid days. -// is_busday : Returns a boolean array indicating valid days. -// busday_count : Counts how many valid days are in a half-open date range. -// -// Examples -// -------- -// >>> # First business day in October 2011 (not accounting for holidays) -// ... np.busday_offset('2011-10', 0, roll='forward') -// numpy.datetime64('2011-10-03') -// >>> # Last business day in February 2012 (not accounting for holidays) -// ... np.busday_offset('2012-03', -1, roll='forward') -// numpy.datetime64('2012-02-29') -// >>> # Third Wednesday in January 2011 -// ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed') -// numpy.datetime64('2011-01-19') -// >>> # 2012 Mother's Day in Canada and the U.S. -// ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun') -// numpy.datetime64('2012-05-13') -// -// >>> # First business day on or after a date -// ... np.busday_offset('2011-03-20', 0, roll='forward') -// numpy.datetime64('2011-03-21') -// >>> np.busday_offset('2011-03-22', 0, roll='forward') -// numpy.datetime64('2011-03-22') -// >>> # First business day after a date -// ... np.busday_offset('2011-03-20', 1, roll='backward') -// numpy.datetime64('2011-03-21') -// >>> np.busday_offset('2011-03-22', 1, roll='backward') -// numpy.datetime64('2011-03-23') -// -// -//go:linkname BusdayOffset py.busday_offset -func BusdayOffset(dates *py.Object, offsets *py.Object, roll *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object -// -// Return the indices for the upper-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The size of the arrays for which the returned indices will -// be valid. -// k : int, optional -// Diagonal offset (see `triu` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple, shape(2) of ndarrays, shape(`n`) -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. Can be used -// to slice a ndarray of shape(`n`, `n`). -// -// See also -// -------- -// tril_indices : similar function, for lower-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// triu, tril -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// upper triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> iu1 = np.triu_indices(4) -// >>> iu2 = np.triu_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[iu1] -// array([ 0, 1, 2, ..., 10, 11, 15]) -// -// And for assigning values: -// -// >>> a[iu1] = -1 -// >>> a -// array([[-1, -1, -1, -1], -// [ 4, -1, -1, -1], -// [ 8, 9, -1, -1], -// [12, 13, 14, -1]]) -// -// These cover only a small part of the whole array (two diagonals right -// of the main one): -// -// >>> a[iu2] = -10 -// >>> a -// array([[ -1, -1, -10, -10], -// [ 4, -1, -1, -10], -// [ 8, 9, -1, -1], -// [ 12, 13, 14, -1]]) -// -// -// -//go:linkname TriuIndices py.triu_indices -func TriuIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -//go:linkname GreaterEqual py.greater_equal -func GreaterEqual(__llgo_va_list ...interface{}) *py.Object -// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Round elements of the array to the nearest integer. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array is same shape and type as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// fix, ceil, floor, trunc -// -// Notes -// ----- -// 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. -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.rint(a) -// array([-2., -2., -0., 0., 2., 2., 2.]) -// -//go:linkname Rint py.rint -func Rint(x *py.Object, out *py.Object) *py.Object -// -// datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind') -// -// Convert an array of datetimes into an array of strings. -// -// Parameters -// ---------- -// arr : array_like of datetime64 -// The array of UTC timestamps to format. -// unit : str -// One of None, 'auto', or a :ref:`datetime unit `. -// timezone : {'naive', 'UTC', 'local'} or tzinfo -// Timezone information to use when displaying the datetime. If 'UTC', end -// with a Z to indicate UTC time. If 'local', convert to the local timezone -// first, and suffix with a +-#### timezone offset. If a tzinfo object, -// then do as with 'local', but use the specified timezone. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'} -// Casting to allow when changing between datetime units. -// -// Returns -// ------- -// str_arr : ndarray -// An array of strings the same shape as `arr`. -// -// Examples -// -------- -// >>> import pytz -// >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]') -// >>> d -// array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30', -// '2002-10-27T07:30'], dtype='datetime64[m]') -// -// Setting the timezone to UTC shows the same information, but with a Z suffix -// -// >>> np.datetime_as_string(d, timezone='UTC') -// array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z', -// '2002-10-27T07:30Z'], dtype='>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern')) -// array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400', -// '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='>> np.datetime_as_string(d, unit='h') -// array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'], -// dtype='>> np.datetime_as_string(d, unit='s') -// array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00', -// '2002-10-27T07:30:00'], dtype='>> np.datetime_as_string(d, unit='h', casting='safe') -// Traceback (most recent call last): -// ... -// TypeError: Cannot create a datetime string as units 'h' from a NumPy -// datetime with units 'm' according to the rule 'safe' -// -// -//go:linkname DatetimeAsString py.datetime_as_string -func DatetimeAsString(arr *py.Object, unit *py.Object, timezone *py.Object, casting *py.Object) *py.Object -// -// Split an array into multiple sub-arrays vertically (row-wise). -// -// Please refer to the ``split`` documentation. ``vsplit`` is equivalent -// to ``split`` with `axis=0` (default), the array is always split along the -// first axis regardless of the array dimension. -// -// See Also -// -------- -// split : Split an array into multiple sub-arrays of equal size. -// -// Examples -// -------- -// >>> x = np.arange(16.0).reshape(4, 4) -// >>> x -// array([[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.], -// [ 8., 9., 10., 11.], -// [12., 13., 14., 15.]]) -// >>> np.vsplit(x, 2) -// [array([[0., 1., 2., 3.], -// [4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.], -// [12., 13., 14., 15.]])] -// >>> np.vsplit(x, np.array([3, 6])) -// [array([[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.], -// [ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)] -// -// With a higher dimensional array the split is still along the first axis. -// -// >>> x = np.arange(8.0).reshape(2, 2, 2) -// >>> x -// array([[[0., 1.], -// [2., 3.]], -// [[4., 5.], -// [6., 7.]]]) -// >>> np.vsplit(x, 2) -// [array([[[0., 1.], -// [2., 3.]]]), array([[[4., 5.], -// [6., 7.]]])] -// -// -// -//go:linkname Vsplit py.vsplit -func Vsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object -// -// Return the indices for the lower-triangle of an (n, m) array. -// -// Parameters -// ---------- -// n : int -// The row dimension of the arrays for which the returned -// indices will be valid. -// k : int, optional -// Diagonal offset (see `tril` for details). -// m : int, optional -// .. versionadded:: 1.9.0 -// -// The column dimension of the arrays for which the returned -// arrays will be valid. -// By default `m` is taken equal to `n`. -// -// -// Returns -// ------- -// inds : tuple of arrays -// The indices for the triangle. The returned tuple contains two arrays, -// each with the indices along one dimension of the array. -// -// See also -// -------- -// triu_indices : similar function, for upper-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// tril, triu -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// Compute two different sets of indices to access 4x4 arrays, one for the -// lower triangular part starting at the main diagonal, and one starting two -// diagonals further right: -// -// >>> il1 = np.tril_indices(4) -// >>> il2 = np.tril_indices(4, 2) -// -// Here is how they can be used with a sample array: -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Both for indexing: -// -// >>> a[il1] -// array([ 0, 4, 5, ..., 13, 14, 15]) -// -// And for assigning values: -// -// >>> a[il1] = -1 -// >>> a -// array([[-1, 1, 2, 3], -// [-1, -1, 6, 7], -// [-1, -1, -1, 11], -// [-1, -1, -1, -1]]) -// -// These cover almost the whole array (two diagonals right of the main one): -// -// >>> a[il2] = -10 -// >>> a -// array([[-10, -10, -10, 3], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10], -// [-10, -10, -10, -10]]) -// -// -// -//go:linkname TrilIndices py.tril_indices -func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object -// -// Save several arrays into a single file in compressed ``.npz`` format. -// -// Provide arrays as keyword arguments to store them under the -// corresponding name in the output file: ``savez(fn, x=x, y=y)``. -// -// If arrays are specified as positional arguments, i.e., ``savez(fn, -// x, y)``, their names will be `arr_0`, `arr_1`, etc. -// -// Parameters -// ---------- -// file : str or file -// Either the filename (string) or an open file (file-like object) -// where the data will be saved. If file is a string or a Path, the -// ``.npz`` extension will be appended to the filename if it is not -// already there. -// args : Arguments, optional -// Arrays to save to the file. Please use keyword arguments (see -// `kwds` below) to assign names to arrays. Arrays specified as -// args will be named "arr_0", "arr_1", and so on. -// kwds : Keyword arguments, optional -// Arrays to save to the file. Each array will be saved to the -// output file with its corresponding keyword name. -// -// Returns -// ------- -// None -// -// See Also -// -------- -// numpy.save : Save a single array to a binary file in NumPy format. -// numpy.savetxt : Save an array to a file as plain text. -// numpy.savez : Save several arrays into an uncompressed ``.npz`` file format -// numpy.load : Load the files created by savez_compressed. -// -// Notes -// ----- -// The ``.npz`` file format is a zipped archive of files named after the -// variables they contain. The archive is compressed with -// ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable -// in ``.npy`` format. For a description of the ``.npy`` format, see -// :py:mod:`numpy.lib.format`. -// -// -// When opening the saved ``.npz`` file with `load` a `NpzFile` object is -// returned. This is a dictionary-like object which can be queried for -// its list of arrays (with the ``.files`` attribute), and for the arrays -// themselves. -// -// Examples -// -------- -// >>> test_array = np.random.rand(3, 2) -// >>> test_vector = np.random.rand(4) -// >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector) -// >>> loaded = np.load('/tmp/123.npz') -// >>> print(np.array_equal(test_array, loaded['a'])) -// True -// >>> print(np.array_equal(test_vector, loaded['b'])) -// True -// -// -// -//go:linkname SavezCompressed py.savez_compressed -func SavezCompressed(file *py.Object, __llgo_va_list ...interface{}) *py.Object -// -// where(condition, [x, y], /) -// -// Return elements chosen from `x` or `y` depending on `condition`. -// -// .. note:: -// When only `condition` is provided, this function is a shorthand for -// ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be -// preferred, as it behaves correctly for subclasses. The rest of this -// documentation covers only the case where all three arguments are -// provided. -// -// Parameters -// ---------- -// condition : array_like, bool -// Where True, yield `x`, otherwise yield `y`. -// x, y : array_like -// Values from which to choose. `x`, `y` and `condition` need to be -// broadcastable to some shape. -// -// Returns -// ------- -// out : ndarray -// An array with elements from `x` where `condition` is True, and elements -// from `y` elsewhere. -// -// See Also -// -------- -// choose -// nonzero : The function that is called when x and y are omitted -// -// Notes -// ----- -// If all the arrays are 1-D, `where` is equivalent to:: -// -// [xv if c else yv -// for c, xv, yv in zip(condition, x, y)] -// -// Examples -// -------- -// >>> a = np.arange(10) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.where(a < 5, a, 10*a) -// array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90]) -// -// This can be used on multidimensional arrays too: -// -// >>> np.where([[True, False], [True, True]], -// ... [[1, 2], [3, 4]], -// ... [[9, 8], [7, 6]]) -// array([[1, 8], -// [3, 4]]) -// -// The shapes of x, y, and the condition are broadcast together: -// -// >>> x, y = np.ogrid[:3, :4] -// >>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast -// array([[10, 0, 0, 0], -// [10, 11, 1, 1], -// [10, 11, 12, 2]]) -// -// >>> a = np.array([[0, 1, 2], -// ... [0, 2, 4], -// ... [0, 3, 6]]) -// >>> np.where(a < 4, a, -1) # -1 is broadcast -// array([[ 0, 1, 2], -// [ 0, 2, -1], -// [ 0, 3, -1]]) -// -// -//go:linkname Where py.where -func Where(condition *py.Object, x *py.Object, y *py.Object) *py.Object -// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// This is the NumPy implementation of the C library function fmod, the -// remainder has the same sign as the dividend `x1`. It is equivalent to -// the Matlab(TM) ``rem`` function and should not be confused with the -// Python modulus operator ``x1 % x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend. -// x2 : array_like -// Divisor. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The remainder of the division of `x1` by `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Equivalent to the Python ``%`` operator. -// divide -// -// Notes -// ----- -// The result of the modulo operation for negative dividend and divisors -// is bound by conventions. For `fmod`, the sign of result is the sign of -// the dividend, while for `remainder` the sign of the result is the sign -// of the divisor. The `fmod` function is equivalent to the Matlab(TM) -// ``rem`` function. -// -// Examples -// -------- -// >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) -// array([-1, 0, -1, 1, 0, 1]) -// >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) -// array([1, 0, 1, 1, 0, 1]) -// -// >>> np.fmod([5, 3], [2, 2.]) -// array([ 1., 1.]) -// >>> a = np.arange(-3, 3).reshape(3, 2) -// >>> a -// array([[-3, -2], -// [-1, 0], -// [ 1, 2]]) -// >>> np.fmod(a, [2,2]) -// array([[-1, 0], -// [-1, 0], -// [ 1, 0]]) -// -//go:linkname Fmod py.fmod -func Fmod(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for finiteness (not infinity and not Not a Number). -// -// The result is returned as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray, bool -// True where ``x`` is not positive infinity, negative infinity, -// or NaN; false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isnan -// -// Notes -// ----- -// Not a Number, positive infinity and negative infinity are considered -// to be non-finite. -// -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// Also that positive infinity is not equivalent to negative infinity. But -// infinity is equivalent to positive infinity. Errors result if the -// second argument is also supplied when `x` is a scalar input, or if -// first and second arguments have different shapes. -// -// Examples -// -------- -// >>> np.isfinite(1) -// True -// >>> np.isfinite(0) -// True -// >>> np.isfinite(np.nan) -// False -// >>> np.isfinite(np.inf) -// False -// >>> np.isfinite(np.NINF) -// False -// >>> np.isfinite([np.log(-1.),1.,np.log(0)]) -// array([False, True, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isfinite(x, y) -// array([0, 1, 0]) -// >>> y -// array([0, 1, 0]) -// -//go:linkname Isfinite py.isfinite -func Isfinite(x *py.Object, out *py.Object) *py.Object -// minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then that -// element is returned. If both elements are NaNs then the first is -// returned. The latter distinction is important for complex NaNs, which -// are defined as at least one of the real or imaginary parts being a NaN. -// The net effect is that NaNs are propagated. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// fmax, amax, nanmax -// -// Notes -// ----- -// The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when -// neither x1 nor x2 are NaNs, but it is faster and does proper -// broadcasting. -// -// Examples -// -------- -// >>> np.minimum([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([nan, nan, nan]) -// >>> np.minimum(-np.Inf, 1) -// -inf -// -//go:linkname Minimum py.minimum -func Minimum(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// ravel_multi_index(multi_index, dims, mode='raise', order='C') -// -// Converts a tuple of index arrays into an array of flat -// indices, applying boundary modes to the multi-index. -// -// Parameters -// ---------- -// multi_index : tuple of array_like -// A tuple of integer arrays, one array for each dimension. -// dims : tuple of ints -// The shape of array into which the indices from ``multi_index`` apply. -// mode : {'raise', 'wrap', 'clip'}, optional -// Specifies how out-of-bounds indices are handled. Can specify -// either one mode or a tuple of modes, one mode per index. -// -// * 'raise' -- raise an error (default) -// * 'wrap' -- wrap around -// * 'clip' -- clip to the range -// -// In 'clip' mode, a negative index which would normally -// wrap will clip to 0 instead. -// order : {'C', 'F'}, optional -// Determines whether the multi-index should be viewed as -// indexing in row-major (C-style) or column-major -// (Fortran-style) order. -// -// Returns -// ------- -// raveled_indices : ndarray -// An array of indices into the flattened version of an array -// of dimensions ``dims``. -// -// See Also -// -------- -// unravel_index -// -// Notes -// ----- -// .. versionadded:: 1.6.0 -// -// Examples -// -------- -// >>> arr = np.array([[3,6,6],[4,5,1]]) -// >>> np.ravel_multi_index(arr, (7,6)) -// array([22, 41, 37]) -// >>> np.ravel_multi_index(arr, (7,6), order='F') -// array([31, 41, 13]) -// >>> np.ravel_multi_index(arr, (4,6), mode='clip') -// array([22, 23, 19]) -// >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap')) -// array([12, 13, 13]) -// -// >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9)) -// 1621 -// -// -//go:linkname RavelMultiIndex py.ravel_multi_index -func RavelMultiIndex(multiIndex *py.Object, dims *py.Object, mode *py.Object, order *py.Object) *py.Object -// -// Compute the weighted average along the specified axis. -// -// Parameters -// ---------- -// a : array_like -// Array containing data to be averaged. If `a` is not an array, a -// conversion is attempted. -// axis : None or int or tuple of ints, optional -// Axis or axes along which to average `a`. The default, -// axis=None, will average over all of the elements of the input array. -// If axis is negative it counts from the last to the first axis. -// -// .. versionadded:: 1.7.0 -// -// If axis is a tuple of ints, averaging is performed on all of the axes -// specified in the tuple instead of a single axis or all the axes as -// before. -// weights : array_like, optional -// An array of weights associated with the values in `a`. Each value in -// `a` contributes to the average according to its associated weight. -// The weights array can either be 1-D (in which case its length must be -// the size of `a` along the given axis) or of the same shape as `a`. -// If `weights=None`, then all data in `a` are assumed to have a -// weight equal to one. The 1-D calculation is:: -// -// avg = sum(a * weights) / sum(weights) -// -// The only constraint on `weights` is that `sum(weights)` must not be 0. -// returned : bool, optional -// Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`) -// 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 -// ------- -// retval, [sum_of_weights] : array_type or double -// Return the average along the specified axis. When `returned` is `True`, -// return a tuple with the average as the first element and the sum -// of the weights as the second element. `sum_of_weights` is of the -// same type as `retval`. The result dtype follows a genereal pattern. -// If `weights` is None, the result dtype will be that of `a` , or ``float64`` -// if `a` is integral. Otherwise, if `weights` is not None and `a` is non- -// integral, the result type will be the type of lowest precision capable of -// representing values of both `a` and `weights`. If `a` happens to be -// integral, the previous rules still applies but the result dtype will -// at least be ``float64``. -// -// Raises -// ------ -// ZeroDivisionError -// When all weights along axis are zero. See `numpy.ma.average` for a -// version robust to this type of error. -// TypeError -// When the length of 1D `weights` is not the same as the shape of `a` -// along axis. -// -// See Also -// -------- -// mean -// -// ma.average : average for masked arrays -- useful if your data contains -// "missing" values -// numpy.result_type : Returns the type that results from applying the -// numpy type promotion rules to the arguments. -// -// Examples -// -------- -// >>> data = np.arange(1, 5) -// >>> data -// array([1, 2, 3, 4]) -// >>> np.average(data) -// 2.5 -// >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1)) -// 4.0 -// -// >>> data = np.arange(6).reshape((3, 2)) -// >>> data -// array([[0, 1], -// [2, 3], -// [4, 5]]) -// >>> np.average(data, axis=1, weights=[1./4, 3./4]) -// array([0.75, 2.75, 4.75]) -// >>> np.average(data, weights=[1./4, 3./4]) -// Traceback (most recent call last): -// ... -// TypeError: Axis must be specified when shapes of a and weights differ. -// -// >>> a = np.ones(5, dtype=np.float128) -// >>> w = np.ones(5, dtype=np.complex64) -// >>> 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]]) -// -// -//go:linkname Average py.average -func Average(a *py.Object, axis *py.Object, weights *py.Object, returned *py.Object) *py.Object -// array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, -// like=None) -// -// Create an array. -// -// Parameters -// ---------- -// object : array_like -// An array, any object exposing the array interface, an object whose -// ``__array__`` method returns an array, or any (nested) sequence. -// If object is a scalar, a 0-dimensional array containing object is -// returned. -// dtype : data-type, optional -// The desired data-type for the array. If not given, NumPy will try to use -// a default ``dtype`` that can represent the values (by applying promotion -// rules when necessary.) -// copy : bool, optional -// If true (default), then the object is copied. Otherwise, a copy will -// only be made if ``__array__`` returns a copy, if obj is a nested -// sequence, or if a copy is needed to satisfy any of the other -// requirements (``dtype``, ``order``, etc.). -// order : {'K', 'A', 'C', 'F'}, optional -// Specify the memory layout of the array. If object is not an array, the -// newly created array will be in C order (row major) unless 'F' is -// specified, in which case it will be in Fortran order (column major). -// If object is an array the following holds. -// -// ===== ========= =================================================== -// order no copy copy=True -// ===== ========= =================================================== -// 'K' unchanged F & C order preserved, otherwise most similar order -// 'A' unchanged F order if input is F and not C, otherwise C order -// 'C' C order C order -// 'F' F order F order -// ===== ========= =================================================== -// -// When ``copy=False`` and a copy is made for other reasons, the result is -// the same as if ``copy=True``, with some exceptions for 'A', see the -// Notes section. The default order is 'K'. -// subok : bool, optional -// If True, then sub-classes will be passed-through, otherwise -// 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 prepended to the shape as -// needed to meet this requirement. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// An array object satisfying the specified requirements. -// -// See Also -// -------- -// empty_like : Return an empty array with shape and type of input. -// ones_like : Return an array of ones with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// ones : Return a new array setting values to one. -// zeros : Return a new array setting values to zero. -// full : Return a new array of given shape filled with value. -// -// -// Notes -// ----- -// When order is 'A' and ``object`` is an array in neither 'C' nor 'F' order, -// and a copy is forced by a change in dtype, then the order of the result is -// not necessarily 'C' as expected. This is likely a bug. -// -// Examples -// -------- -// >>> np.array([1, 2, 3]) -// array([1, 2, 3]) -// -// Upcasting: -// -// >>> np.array([1, 2, 3.0]) -// array([ 1., 2., 3.]) -// -// More than one dimension: -// -// >>> np.array([[1, 2], [3, 4]]) -// array([[1, 2], -// [3, 4]]) -// -// Minimum dimensions 2: -// -// >>> np.array([1, 2, 3], ndmin=2) -// array([[1, 2, 3]]) -// -// Type provided: -// -// >>> np.array([1, 2, 3], dtype=complex) -// array([ 1.+0.j, 2.+0.j, 3.+0.j]) -// -// Data-type consisting of more than one element: -// -// >>> x = np.array([(1,2),(3,4)],dtype=[('a','>> x['a'] -// array([1, 3]) -// -// Creating an array from sub-classes: -// -// >>> np.array(np.mat('1 2; 3 4')) -// array([[1, 2], -// [3, 4]]) -// -// >>> np.array(np.mat('1 2; 3 4'), subok=True) -// matrix([[1, 2], -// [3, 4]]) -// -//go:linkname Array py.array -func Array(object *py.Object, dtype *py.Object) *py.Object -// fromstring(string, dtype=float, count=-1, *, sep, like=None) -// -// A new 1-D array initialized from text data in a string. -// -// Parameters -// ---------- -// string : str -// A string containing the data. -// dtype : data-type, optional -// The data type of the array; default: float. For binary input data, -// the data must be in exactly this format. Most builtin numeric types are -// supported and extension types may be supported. -// -// .. versionadded:: 1.18.0 -// Complex dtypes. -// -// count : int, optional -// Read this number of `dtype` elements from the data. If this is -// negative (the default), the count will be determined from the -// length of the data. -// sep : str, optional -// The string separating numbers in the data; extra whitespace between -// elements is also ignored. -// -// .. deprecated:: 1.14 -// Passing ``sep=''``, the default, is deprecated since it will -// trigger the deprecated binary mode of this function. This mode -// interprets `string` as binary bytes, rather than ASCII text with -// 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 utf-8, which will not produce sane results. -// -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// arr : ndarray -// The constructed array. -// -// Raises -// ------ -// ValueError -// If the string is not the correct size to satisfy the requested -// `dtype` and `count`. -// -// See Also -// -------- -// frombuffer, fromfile, fromiter -// -// Examples -// -------- -// >>> np.fromstring('1 2', dtype=int, sep=' ') -// array([1, 2]) -// >>> np.fromstring('1, 2', dtype=int, sep=',') -// array([1, 2]) -// -//go:linkname Fromstring py.fromstring -func Fromstring(string *py.Object, dtype *py.Object, count *py.Object) *py.Object -// -// Repeat each element of an array after themselves -// -// Parameters -// ---------- -// a : array_like -// Input array. -// repeats : int or array of ints -// The number of repetitions for each element. `repeats` is broadcasted -// to fit the shape of the given axis. -// axis : int, optional -// The axis along which to repeat values. By default, use the -// flattened input array, and return a flat output array. -// -// Returns -// ------- -// repeated_array : ndarray -// Output array which has the same shape as `a`, except along -// the given axis. -// -// See Also -// -------- -// tile : Tile an array. -// unique : Find the unique elements of an array. -// -// Examples -// -------- -// >>> np.repeat(3, 4) -// array([3, 3, 3, 3]) -// >>> x = np.array([[1,2],[3,4]]) -// >>> np.repeat(x, 2) -// array([1, 1, 2, 2, 3, 3, 4, 4]) -// >>> np.repeat(x, 3, axis=1) -// array([[1, 1, 1, 2, 2, 2], -// [3, 3, 3, 4, 4, 4]]) -// >>> np.repeat(x, [1, 2], axis=0) -// array([[1, 2], -// [3, 4], -// [3, 4]]) -// -// -// -//go:linkname Repeat py.repeat -func Repeat(a *py.Object, repeats *py.Object, axis *py.Object) *py.Object -// -// Return the sum along diagonals of the array. -// -// If `a` is 2-D, the sum along its diagonal with the given offset -// is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i. -// -// If `a` has more than two dimensions, then the axes specified by axis1 and -// axis2 are used to determine the 2-D sub-arrays whose traces are returned. -// The shape of the resulting array is the same as that of `a` with `axis1` -// and `axis2` removed. -// -// Parameters -// ---------- -// a : array_like -// Input array, from which the diagonals are taken. -// offset : int, optional -// Offset of the diagonal from the main diagonal. Can be both positive -// and negative. Defaults to 0. -// axis1, axis2 : int, optional -// Axes to be used as the first and second axis of the 2-D sub-arrays -// from which the diagonals should be taken. Defaults are the first two -// axes of `a`. -// dtype : dtype, optional -// Determines the data-type of the returned array and of the accumulator -// where the elements are summed. If dtype has the value None and `a` is -// of integer type of precision less than the default integer -// precision, then the default integer precision is used. Otherwise, -// the precision is the same as that of `a`. -// out : ndarray, optional -// Array into which the output is placed. Its type is preserved and -// it must be of the right shape to hold the output. -// -// Returns -// ------- -// sum_along_diagonals : ndarray -// If `a` is 2-D, the sum along the diagonal is returned. If `a` has -// larger dimensions, then an array of sums along diagonals is returned. -// -// See Also -// -------- -// diag, diagonal, diagflat -// -// Examples -// -------- -// >>> np.trace(np.eye(3)) -// 3.0 -// >>> a = np.arange(8).reshape((2,2,2)) -// >>> np.trace(a) -// array([6, 8]) -// -// >>> a = np.arange(24).reshape((2,2,2,3)) -// >>> np.trace(a).shape -// (2, 3) -// -// -// -//go:linkname Trace py.trace -func Trace(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Object, dtype *py.Object, out *py.Object) *py.Object -// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the base 10 logarithm of the input array, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The logarithm to the base 10 of `x`, element-wise. NaNs are -// returned where x is negative. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.log10 -// -// Notes -// ----- -// 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]`. -// -// For real-valued input data types, `log10` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log10` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. -// `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", -// 10th printing, 1964, pp. 67. -// https://personal.math.ubc.ca/~cbm/aands/page_67.htm -// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm -// -// Examples -// -------- -// >>> np.log10([1e-15, -3.]) -// array([-15., nan]) -// -//go:linkname Log10 py.log10 -func Log10(x *py.Object, out *py.Object) *py.Object -// -// Modified Bessel function of the first kind, order 0. -// -// Usually denoted :math:`I_0`. -// -// Parameters -// ---------- -// x : array_like of float -// Argument of the Bessel function. -// -// Returns -// ------- -// out : ndarray, shape = x.shape, dtype = float -// The modified Bessel function evaluated at each of the elements of `x`. -// -// See Also -// -------- -// scipy.special.i0, scipy.special.iv, scipy.special.ive -// -// Notes -// ----- -// The scipy implementation is recommended over this function: it is a -// proper ufunc written in C, and more than an order of magnitude faster. -// -// We use the algorithm published by Clenshaw [1]_ and referenced by -// Abramowitz and Stegun [2]_, for which the function domain is -// partitioned into the two intervals [0,8] and (8,inf), and Chebyshev -// polynomial expansions are employed in each interval. Relative error on -// the domain [0,30] using IEEE arithmetic is documented [3]_ as having a -// peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000). -// -// References -// ---------- -// .. [1] C. W. Clenshaw, "Chebyshev series for mathematical functions", in -// *National Physical Laboratory Mathematical Tables*, vol. 5, London: -// Her Majesty's Stationery Office, 1962. -// .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical -// Functions*, 10th printing, New York: Dover, 1964, pp. 379. -// https://personal.math.ubc.ca/~cbm/aands/page_379.htm -// .. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero -// -// Examples -// -------- -// >>> np.i0(0.) -// array(1.0) -// >>> np.i0([0, 1, 2, 3]) -// array([1. , 1.26606588, 2.2795853 , 4.88079259]) -// -// -// -//go:linkname I0 py.i0 -func I0(x *py.Object) *py.Object -// -// Round to nearest integer towards zero. -// -// Round an array of floats element-wise to nearest integer towards zero. -// The rounded values are returned as floats. -// -// Parameters -// ---------- -// x : array_like -// An array of floats to be rounded -// out : ndarray, optional -// A location into which the result is stored. If provided, it must have -// a shape that the input broadcasts to. If not provided or None, a -// freshly-allocated array is returned. -// -// Returns -// ------- -// out : ndarray of floats -// A float array with the same dimensions as the input. -// If second argument is not supplied then a float array is returned -// with the rounded values. -// -// If a second argument is supplied the result is stored there. -// The return value `out` is then a reference to that array. -// -// See Also -// -------- -// rint, trunc, floor, ceil -// around : Round to given number of decimals -// -// Examples -// -------- -// >>> np.fix(3.14) -// 3.0 -// >>> np.fix(3) -// 3.0 -// >>> np.fix([2.1, 2.9, -2.1, -2.9]) -// array([ 2., 2., -2., -2.]) -// -// -// -//go:linkname Fix py.fix -func Fix(x *py.Object, out *py.Object) *py.Object -// -// Find the coefficients of a polynomial with the given sequence of roots. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// Returns the coefficients of the polynomial whose leading coefficient -// is one for the given sequence of zeros (multiple roots must be included -// in the sequence as many times as their multiplicity; see Examples). -// A square matrix (or array, which will be treated as a matrix) can also -// be given, in which case the coefficients of the characteristic polynomial -// of the matrix are returned. -// -// Parameters -// ---------- -// seq_of_zeros : array_like, shape (N,) or (N, N) -// A sequence of polynomial roots, or a square array or matrix object. -// -// Returns -// ------- -// c : ndarray -// 1D array of polynomial coefficients from highest to lowest degree: -// -// ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]`` -// where c[0] always equals 1. -// -// Raises -// ------ -// ValueError -// If input is the wrong shape (the input must be a 1-D or square -// 2-D array). -// -// See Also -// -------- -// polyval : Compute polynomial values. -// roots : Return the roots of a polynomial. -// polyfit : Least squares polynomial fit. -// poly1d : A one-dimensional polynomial class. -// -// Notes -// ----- -// Specifying the roots of a polynomial still leaves one degree of -// freedom, typically represented by an undetermined leading -// coefficient. [1]_ In the case of this function, that coefficient - -// the first one in the returned array - is always taken as one. (If -// for some reason you have one other point, the only automatic way -// presently to leverage that information is to use ``polyfit``.) -// -// The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n` -// matrix **A** is given by -// -// :math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`, -// -// where **I** is the `n`-by-`n` identity matrix. [2]_ -// -// References -// ---------- -// .. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trigonometry, -// Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996. -// -// .. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition," -// Academic Press, pg. 182, 1980. -// -// Examples -// -------- -// Given a sequence of a polynomial's zeros: -// -// >>> np.poly((0, 0, 0)) # Multiple root example -// array([1., 0., 0., 0.]) -// -// The line above represents z**3 + 0*z**2 + 0*z + 0. -// -// >>> np.poly((-1./2, 0, 1./2)) -// array([ 1. , 0. , -0.25, 0. ]) -// -// The line above represents z**3 - z/4 -// -// >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0])) -// array([ 1. , -0.77086955, 0.08618131, 0. ]) # random -// -// Given a square array object: -// -// >>> P = np.array([[0, 1./3], [-1./2, 0]]) -// >>> np.poly(P) -// array([1. , 0. , 0.16666667]) -// -// Note how in all cases the leading coefficient is always 1. -// -// -// -//go:linkname Poly py.poly -func Poly(seqOfZeros *py.Object) *py.Object -// -// Return indices that are non-zero in the flattened version of a. -// -// This is equivalent to ``np.nonzero(np.ravel(a))[0]``. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// -// Returns -// ------- -// res : ndarray -// Output array, containing the indices of the elements of ``a.ravel()`` -// that are non-zero. -// -// See Also -// -------- -// nonzero : Return the indices of the non-zero elements of the input array. -// ravel : Return a 1-D array containing the elements of the input array. -// -// Examples -// -------- -// >>> x = np.arange(-2, 3) -// >>> x -// array([-2, -1, 0, 1, 2]) -// >>> np.flatnonzero(x) -// array([0, 1, 3, 4]) -// -// Use the indices of the non-zero elements as an index array to extract -// these elements: -// -// >>> x.ravel()[np.flatnonzero(x)] -// array([-2, -1, 1, 2]) -// -// -// -//go:linkname Flatnonzero py.flatnonzero -func Flatnonzero(a *py.Object) *py.Object -// -// Return the product of array elements over a given axis. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// axis : None or int or tuple of ints, optional -// Axis or axes along which a product is performed. The default, -// axis=None, will calculate the product of all the elements in the -// input array. If axis is negative it counts from the last to the -// first axis. -// -// .. versionadded:: 1.7.0 -// -// If axis is a tuple of ints, a product is performed on all of the -// axes specified in the tuple instead of a single axis or all the -// axes as before. -// dtype : dtype, optional -// The type of the returned array, as well as of the accumulator in -// which the elements are multiplied. The dtype of `a` is used by -// default unless `a` has an integer dtype of less precision than the -// default platform integer. In that case, if `a` is signed then the -// platform integer is used while if `a` is unsigned then an unsigned -// integer of the same precision as the platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output, but the type of the output -// values will be cast if necessary. -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `prod` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// initial : scalar, optional -// The starting value for this product. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.15.0 -// -// where : array_like of bool, optional -// Elements to include in the product. See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// product_along_axis : ndarray, see `dtype` parameter above. -// An array shaped as `a` but with the specified axis removed. -// Returns a reference to `out` if specified. -// -// See Also -// -------- -// ndarray.prod : equivalent method -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. That means that, on a 32-bit platform: -// -// >>> x = np.array([536870910, 536870910, 536870910, 536870910]) -// >>> np.prod(x) -// 16 # may vary -// -// The product of an empty array is the neutral element 1: -// -// >>> np.prod([]) -// 1.0 -// -// Examples -// -------- -// By default, calculate the product of all elements: -// -// >>> np.prod([1.,2.]) -// 2.0 -// -// Even when the input array is two-dimensional: -// -// >>> 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(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]) -// 3.0 -// -// If the type of `x` is unsigned, then the output type is -// the unsigned platform integer: -// -// >>> x = np.array([1, 2, 3], dtype=np.uint8) -// >>> np.prod(x).dtype == np.uint -// True -// -// If `x` is of a signed integer type, then the output type -// is the default platform integer: -// -// >>> x = np.array([1, 2, 3], dtype=np.int8) -// >>> np.prod(x).dtype == int -// True -// -// You can also start the product with a value other than one: -// -// >>> np.prod([1, 2], initial=5) -// 10 -// -// -//go:linkname Prod py.prod -func Prod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *py.Object, initial *py.Object, where *py.Object) *py.Object -// -// Check whether some values are true. -// -// Refer to `any` for full documentation. -// -// .. deprecated:: 1.25.0 -// ``sometrue`` is deprecated as of NumPy 1.25.0, and will be -// removed in NumPy 2.0. Please use `any` instead. -// -// See Also -// -------- -// any : equivalent function; see for details. -// -// -//go:linkname Sometrue py.sometrue -func Sometrue(__llgo_va_list ...interface{}) *py.Object -// -// Return the Bartlett window. -// -// The Bartlett window is very similar to a triangular window, except -// that the end points are at zero. It is often used in signal -// processing for tapering a signal, without generating too much -// ripple in the frequency domain. -// -// Parameters -// ---------- -// M : int -// Number of points in the output window. If zero or less, an -// empty array is returned. -// -// Returns -// ------- -// out : array -// The triangular window, with the maximum value normalized to one -// (the value one appears only if the number of samples is odd), with -// the first and last samples equal to zero. -// -// See Also -// -------- -// blackman, hamming, hanning, kaiser -// -// Notes -// ----- -// The Bartlett window is defined as -// -// .. math:: w(n) = \frac{2}{M-1} \left( -// \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 window is the product of two sinc functions. Note the excellent -// discussion in Kanasewich [2]_. -// -// References -// ---------- -// .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", -// Biometrika 37, 1-16, 1950. -// .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", -// The University of Alberta Press, 1975, pp. 109-110. -// .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal -// Processing", Prentice-Hall, 1999, pp. 468-471. -// .. [4] Wikipedia, "Window function", -// https://en.wikipedia.org/wiki/Window_function -// .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling, -// "Numerical Recipes", Cambridge University Press, 1986, page 429. -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> np.bartlett(12) -// array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary -// 0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636, -// 0.18181818, 0. ]) -// -// Plot the window and its frequency response (requires SciPy and matplotlib): -// -// >>> from numpy.fft import fft, fftshift -// >>> window = np.bartlett(51) -// >>> plt.plot(window) -// [] -// >>> plt.title("Bartlett window") -// Text(0.5, 1.0, 'Bartlett window') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("Sample") -// Text(0.5, 0, 'Sample') -// >>> plt.show() -// -// >>> plt.figure() -//
-// >>> A = fft(window, 2048) / 25.5 -// >>> mag = np.abs(fftshift(A)) -// >>> freq = np.linspace(-0.5, 0.5, len(A)) -// >>> with np.errstate(divide='ignore', invalid='ignore'): -// ... response = 20 * np.log10(mag) -// ... -// >>> response = np.clip(response, -100, 100) -// >>> plt.plot(freq, response) -// [] -// >>> plt.title("Frequency response of Bartlett window") -// Text(0.5, 1.0, 'Frequency response of Bartlett window') -// >>> plt.ylabel("Magnitude [dB]") -// Text(0, 0.5, 'Magnitude [dB]') -// >>> plt.xlabel("Normalized frequency [cycles per sample]") -// Text(0.5, 0, 'Normalized frequency [cycles per sample]') -// >>> _ = plt.axis('tight') -// >>> plt.show() -// -// -// -//go:linkname Bartlett py.bartlett -func Bartlett(M *py.Object) *py.Object -// -// Add documentation to an existing object, typically one defined in C -// -// The purpose is to allow easier editing of the docstrings without requiring -// a re-compile. This exists primarily for internal use within numpy itself. -// -// Parameters -// ---------- -// place : str -// The absolute name of the module to import from -// obj : str -// The name of the object to add documentation to, typically a class or -// function name -// doc : {str, Tuple[str, str], List[Tuple[str, str]]} -// If a string, the documentation to apply to `obj` -// -// If a tuple, then the first element is interpreted as an attribute of -// `obj` and the second as the docstring to apply - ``(method, docstring)`` -// -// If a list, then each element of the list should be a tuple of length -// two - ``[(method1, docstring1), (method2, docstring2), ...]`` -// warn_on_python : bool -// If True, the default, emit `UserWarning` if this is used to attach -// documentation to a pure-python object. -// -// Notes -// ----- -// This routine never raises an error if the docstring can't be written, but -// will raise an error if the object being documented does not exist. -// -// This routine cannot modify read-only docstrings, as appear -// in new-style classes or built-in functions. Because this -// routine never raises an error the caller must check manually -// that the docstrings were changed. -// -// Since this function grabs the ``char *`` from a c-level str object and puts -// it into the ``tp_doc`` slot of the type of `obj`, it violates a number of -// C-API best-practices, by: -// -// - modifying a `PyTypeObject` after calling `PyType_Ready` -// - calling `Py_INCREF` on the str and losing the reference, so the str -// will never be released -// -// If possible it should be avoided. -// -// -//go:linkname AddNewdoc py.add_newdoc -func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object -// -// Show libraries and system information on which NumPy was built -// and is being used -// -// Parameters -// ---------- -// mode : {`'stdout'`, `'dicts'`}, optional. -// Indicates how to display the config information. -// `'stdout'` prints to console, `'dicts'` returns a dictionary -// of the configuration. -// -// Returns -// ------- -// out : {`dict`, `None`} -// If mode is `'dicts'`, a dict is returned, else None -// -// See Also -// -------- -// get_include : Returns the directory containing NumPy C -// header files. -// -// Notes -// ----- -// 1. The `'stdout'` mode will give more readable -// output if ``pyyaml`` is installed -// -// -// -//go:linkname ShowConfig py.show_config -func ShowConfig(mode *py.Object) *py.Object -// -// result_type(*arrays_and_dtypes) -// -// Returns the type that results from applying the NumPy -// type promotion rules to the arguments. -// -// Type promotion in NumPy works similarly to the rules in languages -// like C++, with some slight differences. When both scalars and -// arrays are used, the array's type takes precedence and the actual value -// of the scalar is taken into account. -// -// For example, calculating 3*a, where a is an array of 32-bit floats, -// intuitively should result in a 32-bit float output. If the 3 is a -// 32-bit integer, the NumPy rules indicate it can't convert losslessly -// into a 32-bit float, so a 64-bit float should be the result type. -// By examining the value of the constant, '3', we see that it fits in -// an 8-bit integer, which can be cast losslessly into the 32-bit float. -// -// Parameters -// ---------- -// arrays_and_dtypes : list of arrays and dtypes -// The operands of some operation whose result type is needed. -// -// Returns -// ------- -// out : dtype -// The result type. -// -// See also -// -------- -// dtype, promote_types, min_scalar_type, can_cast -// -// Notes -// ----- -// .. versionadded:: 1.6.0 -// -// The specific algorithm used is as follows. -// -// Categories are determined by first checking which of boolean, -// integer (int/uint), or floating point (float/complex) the maximum -// kind of all the arrays and the scalars are. -// -// If there are only scalars or the maximum category of the scalars -// is higher than the maximum category of the arrays, -// the data types are combined with :func:`promote_types` -// to produce the return value. -// -// Otherwise, `min_scalar_type` is called on each scalar, and -// the resulting data types are all combined with :func:`promote_types` -// to produce the return value. -// -// The set of int values is not a subset of the uint values for types -// with the same number of bits, something not reflected in -// :func:`min_scalar_type`, but handled as a special case in `result_type`. -// -// Examples -// -------- -// >>> np.result_type(3, np.arange(7, dtype='i1')) -// dtype('int8') -// -// >>> np.result_type('i4', 'c8') -// dtype('complex128') -// -// >>> np.result_type(3.0, -2) -// dtype('float64') -// -// -// -//go:linkname ResultType py.result_type -func ResultType(__llgo_va_list ...interface{}) *py.Object -// less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 <= x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// greater, less, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less_equal([4, 2, 1], [2, 2, 2]) -// array([False, True, True]) -// -// The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on -// ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a <= b -// array([False, True, True]) -// -//go:linkname LessEqual py.less_equal -func LessEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> 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. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname TrueDivide py.true_divide -func TrueDivide(__llgo_va_list ...interface{}) *py.Object -// -// einsum(subscripts, *operands, out=None, dtype=None, order='K', -// casting='safe', optimize=False) -// -// Evaluates the Einstein summation convention on the operands. -// -// Using the Einstein summation convention, many common multi-dimensional, -// linear algebraic array operations can be represented in a simple fashion. -// In *implicit* mode `einsum` computes these values. -// -// In *explicit* mode, `einsum` provides further flexibility to compute -// other array operations that might not be considered classical Einstein -// summation operations, by disabling, or forcing summation over specified -// subscript labels. -// -// See the notes and examples for clarification. -// -// Parameters -// ---------- -// subscripts : str -// Specifies the subscripts for summation as comma separated list of -// subscript labels. An implicit (classical Einstein summation) -// calculation is performed unless the explicit indicator '->' is -// included as well as subscript labels of the precise output form. -// operands : list of array_like -// These are the arrays for the operation. -// out : ndarray, optional -// If provided, the calculation is done into this array. -// dtype : {data-type, None}, optional -// If provided, forces the calculation to use the data type specified. -// Note that you may have to also give a more liberal `casting` -// parameter to allow the conversions. Default is None. -// order : {'C', 'F', 'A', 'K'}, optional -// Controls the memory layout of the output. 'C' means it should -// be C contiguous. 'F' means it should be Fortran contiguous, -// 'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise. -// 'K' means it should be as close to the layout as the inputs as -// is possible, including arbitrarily permuted axes. -// Default is 'K'. -// casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional -// Controls what kind of data casting may occur. Setting this to -// 'unsafe' is not recommended, as it can adversely affect accumulations. -// -// * 'no' means the data types should not be cast at all. -// * 'equiv' means only byte-order changes are allowed. -// * 'safe' means only casts which can preserve values are allowed. -// * 'same_kind' means only safe casts or casts within a kind, -// like float64 to float32, are allowed. -// * 'unsafe' means any data conversions may be done. -// -// Default is 'safe'. -// optimize : {False, True, 'greedy', 'optimal'}, optional -// Controls if intermediate optimization should occur. No optimization -// will occur if False and True will default to the 'greedy' algorithm. -// Also accepts an explicit contraction list from the ``np.einsum_path`` -// function. See ``np.einsum_path`` for more details. Defaults to False. -// -// Returns -// ------- -// output : ndarray -// The calculation based on the Einstein summation convention. -// -// See Also -// -------- -// einsum_path, dot, inner, outer, tensordot, linalg.multi_dot -// einops : -// similar verbose interface is provided by -// `einops `_ package to cover -// additional operations: transpose, reshape/flatten, repeat/tile, -// squeeze/unsqueeze and reductions. -// opt_einsum : -// `opt_einsum `_ -// optimizes contraction order for einsum-like expressions -// in backend-agnostic manner. -// -// Notes -// ----- -// .. versionadded:: 1.6.0 -// -// The Einstein summation convention can be used to compute -// many multi-dimensional, linear algebraic array operations. `einsum` -// provides a succinct way of representing these. -// -// A non-exhaustive list of these operations, -// which can be computed by `einsum`, is shown below along with examples: -// -// * Trace of an array, :py:func:`numpy.trace`. -// * Return a diagonal, :py:func:`numpy.diag`. -// * Array axis summations, :py:func:`numpy.sum`. -// * Transpositions and permutations, :py:func:`numpy.transpose`. -// * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`. -// * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`. -// * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`. -// * Tensor contractions, :py:func:`numpy.tensordot`. -// * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`. -// -// The subscripts string is a comma-separated list of subscript labels, -// where each label refers to a dimension of the corresponding operand. -// Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)`` -// is equivalent to :py:func:`np.inner(a,b) `. If a label -// appears only once, it is not summed, so ``np.einsum('i', a)`` produces a -// view of ``a`` with no changes. A further example ``np.einsum('ij,jk', a, b)`` -// describes traditional matrix multiplication and is equivalent to -// :py:func:`np.matmul(a,b) `. Repeated subscript labels in one -// operand take the diagonal. For example, ``np.einsum('ii', a)`` is equivalent -// to :py:func:`np.trace(a) `. -// -// In *implicit mode*, the chosen subscripts are important -// since the axes of the output are reordered alphabetically. This -// means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while -// ``np.einsum('ji', a)`` takes its transpose. Additionally, -// ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while, -// ``np.einsum('ij,jh', a, b)`` returns the transpose of the -// multiplication since subscript 'h' precedes subscript 'i'. -// -// In *explicit mode* the output can be directly controlled by -// specifying output subscript labels. This requires the -// identifier '->' as well as the list of output subscript labels. -// This feature increases the flexibility of the function since -// summing can be disabled or forced when required. The call -// ``np.einsum('i->', a)`` is like :py:func:`np.sum(a, axis=-1) `, -// and ``np.einsum('ii->i', a)`` is like :py:func:`np.diag(a) `. -// The difference is that `einsum` does not allow broadcasting by default. -// Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the -// order of the output subscript labels and therefore returns matrix -// multiplication, unlike the example above in implicit mode. -// -// To enable and control broadcasting, use an ellipsis. Default -// NumPy-style broadcasting is done by adding an ellipsis -// to the left of each term, like ``np.einsum('...ii->...i', a)``. -// To take the trace along the first and last axes, -// you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix -// product with the left-most indices instead of rightmost, one can do -// ``np.einsum('ij...,jk...->ik...', a, b)``. -// -// When there is only one operand, no axes are summed, and no output -// parameter is provided, a view into the operand is returned instead -// of a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)`` -// produces a view (changed in version 1.10.0). -// -// `einsum` also provides an alternative way to provide the subscripts -// and operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. -// If the output shape is not provided in this format `einsum` will be -// calculated in implicit mode, otherwise it will be performed explicitly. -// The examples below have corresponding `einsum` calls with the two -// parameter methods. -// -// .. versionadded:: 1.10.0 -// -// Views returned from einsum are now writeable whenever the input array -// is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now -// have the same effect as :py:func:`np.swapaxes(a, 0, 2) ` -// and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal -// of a 2D array. -// -// .. versionadded:: 1.12.0 -// -// Added the ``optimize`` argument which will optimize the contraction order -// of an einsum expression. For a contraction with three or more operands this -// can greatly increase the computational efficiency at the cost of a larger -// memory footprint during computation. -// -// Typically a 'greedy' algorithm is applied which empirical tests have shown -// returns the optimal path in the majority of cases. In some cases 'optimal' -// will return the superlative path through a more expensive, exhaustive search. -// For iterative calculations it may be advisable to calculate the optimal path -// once and reuse that path by supplying it as an argument. An example is given -// below. -// -// See :py:func:`numpy.einsum_path` for more details. -// -// Examples -// -------- -// >>> a = np.arange(25).reshape(5,5) -// >>> b = np.arange(5) -// >>> c = np.arange(6).reshape(2,3) -// -// Trace of a matrix: -// -// >>> np.einsum('ii', a) -// 60 -// >>> np.einsum(a, [0,0]) -// 60 -// >>> np.trace(a) -// 60 -// -// Extract the diagonal (requires explicit form): -// -// >>> np.einsum('ii->i', a) -// array([ 0, 6, 12, 18, 24]) -// >>> np.einsum(a, [0,0], [0]) -// array([ 0, 6, 12, 18, 24]) -// >>> np.diag(a) -// array([ 0, 6, 12, 18, 24]) -// -// Sum over an axis (requires explicit form): -// -// >>> np.einsum('ij->i', a) -// array([ 10, 35, 60, 85, 110]) -// >>> np.einsum(a, [0,1], [0]) -// array([ 10, 35, 60, 85, 110]) -// >>> np.sum(a, axis=1) -// array([ 10, 35, 60, 85, 110]) -// -// For higher dimensional arrays summing a single axis can be done with ellipsis: -// -// >>> np.einsum('...j->...', a) -// array([ 10, 35, 60, 85, 110]) -// >>> np.einsum(a, [Ellipsis,1], [Ellipsis]) -// array([ 10, 35, 60, 85, 110]) -// -// Compute a matrix transpose, or reorder any number of axes: -// -// >>> np.einsum('ji', c) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// >>> np.einsum('ij->ji', c) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// >>> np.einsum(c, [1,0]) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// >>> np.transpose(c) -// array([[0, 3], -// [1, 4], -// [2, 5]]) -// -// Vector inner products: -// -// >>> np.einsum('i,i', b, b) -// 30 -// >>> np.einsum(b, [0], b, [0]) -// 30 -// >>> np.inner(b,b) -// 30 -// -// Matrix vector multiplication: -// -// >>> np.einsum('ij,j', a, b) -// array([ 30, 80, 130, 180, 230]) -// >>> np.einsum(a, [0,1], b, [1]) -// array([ 30, 80, 130, 180, 230]) -// >>> np.dot(a, b) -// array([ 30, 80, 130, 180, 230]) -// >>> np.einsum('...j,j', a, b) -// array([ 30, 80, 130, 180, 230]) -// -// Broadcasting and scalar multiplication: -// -// >>> np.einsum('..., ...', 3, c) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// >>> np.einsum(',ij', 3, c) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// >>> np.einsum(3, [Ellipsis], c, [Ellipsis]) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// >>> np.multiply(3, c) -// array([[ 0, 3, 6], -// [ 9, 12, 15]]) -// -// Vector outer product: -// -// >>> np.einsum('i,j', np.arange(2)+1, b) -// array([[0, 1, 2, 3, 4], -// [0, 2, 4, 6, 8]]) -// >>> np.einsum(np.arange(2)+1, [0], b, [1]) -// array([[0, 1, 2, 3, 4], -// [0, 2, 4, 6, 8]]) -// >>> np.outer(np.arange(2)+1, b) -// array([[0, 1, 2, 3, 4], -// [0, 2, 4, 6, 8]]) -// -// Tensor contraction: -// -// >>> a = np.arange(60.).reshape(3,4,5) -// >>> b = np.arange(24.).reshape(4,3,2) -// >>> np.einsum('ijk,jil->kl', a, b) -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) -// >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) -// >>> np.tensordot(a,b, axes=([1,0],[0,1])) -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) -// -// Writeable returned arrays (since version 1.10.0): -// -// >>> a = np.zeros((3, 3)) -// >>> np.einsum('ii->i', a)[:] = 1 -// >>> a -// array([[1., 0., 0.], -// [0., 1., 0.], -// [0., 0., 1.]]) -// -// Example of ellipsis use: -// -// >>> a = np.arange(6).reshape((3,2)) -// >>> b = np.arange(12).reshape((4,3)) -// >>> np.einsum('ki,jk->ij', a, b) -// array([[10, 28, 46, 64], -// [13, 40, 67, 94]]) -// >>> np.einsum('ki,...k->i...', a, b) -// array([[10, 28, 46, 64], -// [13, 40, 67, 94]]) -// >>> np.einsum('k...,jk', a, b) -// array([[10, 28, 46, 64], -// [13, 40, 67, 94]]) -// -// Chained array operations. For more complicated contractions, speed ups -// might be achieved by repeatedly computing a 'greedy' path or pre-computing the -// 'optimal' path and repeatedly applying it, using an -// `einsum_path` insertion (since version 1.12.0). Performance improvements can be -// particularly significant with larger arrays: -// -// >>> a = np.ones(64).reshape(2,4,8) -// -// Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.) -// -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a) -// -// Sub-optimal `einsum` (due to repeated path calculation time): ~330ms -// -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal') -// -// Greedy `einsum` (faster optimal path approximation): ~160ms -// -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy') -// -// Optimal `einsum` (best usage pattern in some use cases): ~110ms -// -// >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0] -// >>> for iteration in range(500): -// ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path) -// -// -// -//go:linkname Einsum py.einsum -func Einsum(__llgo_va_list ...interface{}) *py.Object -// -// Stack 1-D arrays as columns into a 2-D array. -// -// Take a sequence of 1-D arrays and stack them as columns -// to make a single 2-D array. 2-D arrays are stacked as-is, -// just like with `hstack`. 1-D arrays are turned into 2-D columns -// first. -// -// Parameters -// ---------- -// tup : sequence of 1-D or 2-D arrays. -// Arrays to stack. All of them must have the same first dimension. -// -// Returns -// ------- -// stacked : 2-D array -// The array formed by stacking the given arrays. -// -// See Also -// -------- -// stack, hstack, vstack, concatenate -// -// Examples -// -------- -// >>> a = np.array((1,2,3)) -// >>> b = np.array((2,3,4)) -// >>> np.column_stack((a,b)) -// array([[1, 2], -// [2, 3], -// [3, 4]]) -// -// -// -//go:linkname ColumnStack py.column_stack -func ColumnStack(tup *py.Object) *py.Object -// -// Load data from a text file, with missing values handled as specified. -// -// Each line past the first `skip_header` lines is split at the `delimiter` -// character, and characters following the `comments` character are discarded. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : dtype, optional -// Data type of the resulting array. -// If None, the dtypes will be determined by the contents of each -// column, individually. -// comments : str, optional -// The character used to indicate the start of a comment. -// All the characters occurring on a line after a comment are discarded. -// delimiter : str, int, or sequence, optional -// The string used to separate values. By default, any consecutive -// whitespaces act as delimiter. An integer or sequence of integers -// can also be provided as width(s) of each field. -// skiprows : int, optional -// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. -// skip_header : int, optional -// The number of lines to skip at the beginning of the file. -// skip_footer : int, optional -// The number of lines to skip at the end of the file. -// converters : variable, optional -// The set of functions that convert the data of a column to a value. -// The converters can also be used to provide a default value -// for missing data: ``converters = {3: lambda s: float(s or 0)}``. -// missing : variable, optional -// `missing` was removed in numpy 1.10. Please use `missing_values` -// instead. -// missing_values : variable, optional -// The set of strings corresponding to missing data. -// filling_values : variable, optional -// The set of values to be used as default when the data are missing. -// usecols : sequence, optional -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. -// names : {None, True, str, sequence}, optional -// If `names` is True, the field names are read from the first line after -// the first `skip_header` lines. This line can optionally be preceded -// by a comment delimiter. If `names` is a sequence or a single-string of -// comma-separated names, the names will be used to define the field names -// in a structured dtype. If `names` is None, the names of the dtype -// fields will be used, if any. -// excludelist : sequence, optional -// A list of names to exclude. This list is appended to the default list -// ['return','file','print']. Excluded names are appended with an -// underscore: for example, `file` would become `file_`. -// deletechars : str, optional -// A string combining invalid characters that must be deleted from the -// names. -// defaultfmt : str, optional -// A format used to define default field names, such as "f%i" or "f_%02i". -// autostrip : bool, optional -// Whether to automatically strip white spaces from the variables. -// replace_space : char, optional -// Character(s) used in replacement of white spaces in the variable -// names. By default, use a '_'. -// case_sensitive : {True, False, 'upper', 'lower'}, optional -// If True, field names are case sensitive. -// If False or 'upper', field names are converted to upper case. -// If 'lower', field names are converted to lower case. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = genfromtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// usemask : bool, optional -// If True, return a masked array. -// If False, return a regular array. -// loose : bool, optional -// If True, do not raise errors for invalid values. -// invalid_raise : bool, optional -// If True, an exception is raised if an inconsistency is detected in the -// number of columns. -// If False, a warning is emitted and the offending lines are skipped. -// max_rows : int, optional -// The maximum number of rows to read. Must not be used with skip_footer -// at the same time. If given, the value must be at least 1. Default is -// to read the entire file. -// -// .. versionadded:: 1.10.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply when `fname` is -// a file object. The special value 'bytes' enables backward compatibility -// workarounds that ensure that you receive byte arrays when possible -// and passes latin1 encoded strings to converters. Override this value to -// receive unicode arrays and pass strings as input to converters. If set -// 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 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. If `usemask` is True, this is a -// masked array. -// -// See Also -// -------- -// numpy.loadtxt : equivalent function when no data is missing. -// -// Notes -// ----- -// * When spaces are used as delimiters, or when no delimiter has been given -// as input, there should not be any missing data between two fields. -// * When the variables are named (either by a flexible dtype or with `names`), -// there must not be any header in the file (else a ValueError -// exception is raised). -// * Individual values are not stripped of spaces by default. -// When using a custom converter, make sure the function does remove spaces. -// -// References -// ---------- -// .. [1] NumPy User Guide, section `I/O with NumPy -// `_. -// -// Examples -// -------- -// >>> from io import StringIO -// >>> import numpy as np -// -// Comma delimited file with mixed dtype -// -// >>> s = StringIO(u"1,1.3,abcde") -// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), -// ... ('mystring','S5')], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only -// >>> data = np.genfromtxt(s, dtype=None, -// ... names = ['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> _ = s.seek(0) -// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", -// ... names=['myint','myfloat','mystring'], delimiter=",") -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('myint', '>> s = StringIO(u"11.3abcde") -// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], -// ... delimiter=[1,3,5]) -// >>> data -// array((1, 1.3, b'abcde'), -// dtype=[('intvar', '>> f = StringIO(''' -// ... text,# of chars -// ... hello world,11 -// ... numpy,5''') -// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') -// array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')], -// dtype=[('f0', 'S12'), ('f1', 'S12')]) -// -// -// -//go:linkname Genfromtxt py.genfromtxt -func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object -// -// Take elements from an array along an axis. -// -// When axis is not None, this function does the same thing as "fancy" -// indexing (indexing arrays using arrays); however, it can be easier to use -// if you need elements along a given axis. A call such as -// ``np.take(arr, indices, axis=3)`` is equivalent to -// ``arr[:,:,:,indices,...]``. -// -// Explained without fancy indexing, this is equivalent to the following use -// of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of -// indices:: -// -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// Nj = indices.shape -// for ii in ndindex(Ni): -// for jj in ndindex(Nj): -// for kk in ndindex(Nk): -// out[ii + jj + kk] = a[ii + (indices[jj],) + kk] -// -// Parameters -// ---------- -// a : array_like (Ni..., M, Nk...) -// The source array. -// indices : array_like (Nj...) -// The indices of the values to extract. -// -// .. versionadded:: 1.8.0 -// -// Also allow scalars for indices. -// axis : int, optional -// The axis over which to select values. By default, the flattened -// input array is used. -// out : ndarray, optional (Ni..., Nj..., Nk...) -// If provided, the result will be placed in this array. It should -// be of the appropriate shape and dtype. Note that `out` is always -// buffered if `mode='raise'`; use other modes for better performance. -// mode : {'raise', 'wrap', 'clip'}, optional -// Specifies how out-of-bounds indices will behave. -// -// * 'raise' -- raise an error (default) -// * 'wrap' -- wrap around -// * 'clip' -- clip to the range -// -// 'clip' mode means that all indices that are too large are replaced -// by the index that addresses the last element along that axis. Note -// that this disables indexing with negative numbers. -// -// Returns -// ------- -// out : ndarray (Ni..., Nj..., Nk...) -// The returned array has the same type as `a`. -// -// See Also -// -------- -// compress : Take elements using a boolean mask -// ndarray.take : equivalent method -// take_along_axis : Take elements by matching the array and the index arrays -// -// Notes -// ----- -// -// By eliminating the inner loop in the description above, and using `s_` to -// build simple slice objects, `take` can be expressed in terms of applying -// fancy indexing to each 1-d slice:: -// -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// for ii in ndindex(Ni): -// for kk in ndindex(Nj): -// out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices] -// -// For this reason, it is equivalent to (but faster than) the following use -// of `apply_along_axis`:: -// -// out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a) -// -// Examples -// -------- -// >>> a = [4, 3, 5, 7, 6, 8] -// >>> indices = [0, 1, 4] -// >>> np.take(a, indices) -// array([4, 3, 6]) -// -// In this example if `a` is an ndarray, "fancy" indexing can be used. -// -// >>> a = np.array(a) -// >>> a[indices] -// array([4, 3, 6]) -// -// If `indices` is not one dimensional, the output also has these dimensions. -// -// >>> np.take(a, [[0, 1], [2, 3]]) -// array([[4, 3], -// [5, 7]]) -// -// -//go:linkname Take py.take -func Take(a *py.Object, indices *py.Object, axis *py.Object, out *py.Object, mode *py.Object) *py.Object -// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Base-2 logarithm of `x`. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Base-2 logarithm of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// log, log10, log1p, emath.log2 -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// 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]`. -// -// For real-valued input data types, `log2` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `log2` is a complex analytical function that -// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2` -// 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]) -// >>> np.log2(x) -// array([-Inf, 0., 1., 4.]) -// -// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j]) -// >>> np.log2(xi) -// array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j]) -// -//go:linkname Log2 py.log2 -func Log2(x *py.Object, out *py.Object) *py.Object -// rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Angle in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding angle in degrees. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : Convert angles from degrees to radians. -// unwrap : Remove large jumps in angle by wrapping. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// rad2deg(x) is ``180 * x / pi``. -// -// Examples -// -------- -// >>> np.rad2deg(np.pi/2) -// 90.0 -// -//go:linkname Rad2deg py.rad2deg -func Rad2deg(x *py.Object, out *py.Object) *py.Object -// -// Display a message on a device. -// -// Parameters -// ---------- -// mesg : str -// Message to display. -// device : object -// Device to write message. If None, defaults to ``sys.stdout`` which is -// very similar to ``print``. `device` needs to have ``write()`` and -// ``flush()`` methods. -// linefeed : bool, optional -// Option whether to print a line feed or not. Defaults to True. -// -// Raises -// ------ -// AttributeError -// If `device` does not have a ``write()`` or ``flush()`` method. -// -// Examples -// -------- -// Besides ``sys.stdout``, a file-like object can also be used as it has -// both required methods: -// -// >>> from io import StringIO -// >>> buf = StringIO() -// >>> np.disp(u'"Display" in a file', device=buf) -// >>> buf.getvalue() -// '"Display" in a file\n' -// -// -// -//go:linkname Disp py.disp -func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object -// -// Load ASCII data stored in a comma-separated file. -// -// The returned array is a record array (if ``usemask=False``, see -// `recarray`) or a masked record array (if ``usemask=True``, -// see `ma.mrecords.MaskedRecords`). -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function to load ASCII data. -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromcsv py.recfromcsv -func Recfromcsv(fname *py.Object) *py.Object -// -// Return the cumulative sum of array elements over a given axis treating Not a -// Numbers (NaNs) as zero. The cumulative sum does not change when NaNs are -// encountered and leading NaNs are replaced by zeros. -// -// Zeros are returned for slices that are all-NaN or empty. -// -// .. versionadded:: 1.12.0 -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative sum is computed. The default -// (None) is to compute the cumsum over the flattened array. -// dtype : dtype, optional -// Type of the returned array and of the accumulator in which the -// elements are summed. If `dtype` is not specified, it defaults -// to the dtype of `a`, unless `a` has an integer dtype with a -// precision less than that of the default platform integer. In -// that case, the default platform integer is used. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type will be cast if necessary. See :ref:`ufuncs-output-type` for -// more details. -// -// Returns -// ------- -// nancumsum : ndarray. -// A new array holding the result is returned unless `out` is -// specified, in which it is returned. The result has the same -// size as `a`, and the same shape as `a` if `axis` is not None -// or `a` is a 1-d array. -// -// See Also -// -------- -// numpy.cumsum : Cumulative sum across array propagating NaNs. -// isnan : Show which elements are NaN. -// -// Examples -// -------- -// >>> np.nancumsum(1) -// array([1]) -// >>> np.nancumsum([1]) -// array([1]) -// >>> np.nancumsum([1, np.nan]) -// array([1., 1.]) -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nancumsum(a) -// array([1., 3., 6., 6.]) -// >>> np.nancumsum(a, axis=0) -// array([[1., 2.], -// [4., 2.]]) -// >>> np.nancumsum(a, axis=1) -// array([[1., 3.], -// [3., 3.]]) -// -// -// -//go:linkname Nancumsum py.nancumsum -func Nancumsum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object -// Return a contiguous flattened array. -// -// A 1-D array, containing the elements of the input, is returned. A copy is -// made only if needed. -// -// As of NumPy 1.10, the returned array will have the same type as the input -// array. (for example, a masked array will be returned for a masked array -// input) -// -// Parameters -// ---------- -// a : array_like -// Input array. The elements in `a` are read in the order specified by -// `order`, and packed as a 1-D array. -// order : {'C','F', 'A', 'K'}, optional -// -// The elements of `a` are read using this index order. 'C' means -// to index the elements in row-major, C-style order, -// with the last axis index changing fastest, back to the first -// axis index changing slowest. 'F' means to index the elements -// in column-major, Fortran-style order, with the -// first index changing fastest, and the last index changing -// slowest. Note that the 'C' and 'F' options take no account of -// the memory layout of the underlying array, and only refer to -// the order of axis indexing. 'A' means to read the elements in -// Fortran-like index order if `a` is Fortran *contiguous* in -// memory, C-like order 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. -// -// Returns -// ------- -// y : array_like -// y is a contiguous 1-D array of the same subtype as `a`, -// with shape ``(a.size,)``. -// Note that matrices are special cased for backward compatibility, -// if `a` is a matrix, then y is a 1-D ndarray. -// -// See Also -// -------- -// ndarray.flat : 1-D iterator over an array. -// ndarray.flatten : 1-D array copy of the elements of an array -// in row-major order. -// ndarray.reshape : Change the shape of an array without changing its data. -// -// Notes -// ----- -// In row-major, C-style order, in two dimensions, the row index -// varies the slowest, and the column index the quickest. This can -// be generalized to multiple dimensions, where row-major order -// implies that the index along the first axis varies slowest, and -// the index along the last quickest. The opposite holds for -// column-major, Fortran-style index ordering. -// -// When a view is desired in as many cases as possible, ``arr.reshape(-1)`` -// may be preferable. However, ``ravel`` supports ``K`` in the optional -// ``order`` argument while ``reshape`` does not. -// -// Examples -// -------- -// It is equivalent to ``reshape(-1, order=order)``. -// -// >>> x = np.array([[1, 2, 3], [4, 5, 6]]) -// >>> np.ravel(x) -// array([1, 2, 3, 4, 5, 6]) -// -// >>> x.reshape(-1) -// array([1, 2, 3, 4, 5, 6]) -// -// >>> np.ravel(x, order='F') -// array([1, 4, 2, 5, 3, 6]) -// -// When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering: -// -// >>> np.ravel(x.T) -// array([1, 4, 2, 5, 3, 6]) -// >>> np.ravel(x.T, order='A') -// array([1, 2, 3, 4, 5, 6]) -// -// When ``order`` is 'K', it will preserve orderings that are neither 'C' -// nor 'F', but won't reverse axes: -// -// >>> a = np.arange(3)[::-1]; a -// array([2, 1, 0]) -// >>> a.ravel(order='C') -// array([2, 1, 0]) -// >>> a.ravel(order='K') -// array([2, 1, 0]) -// -// >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a -// array([[[ 0, 2, 4], -// [ 1, 3, 5]], -// [[ 6, 8, 10], -// [ 7, 9, 11]]]) -// >>> a.ravel(order='C') -// array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11]) -// >>> a.ravel(order='K') -// array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) -// -// -// -//go:linkname Ravel py.ravel -func Ravel(a *py.Object, order *py.Object) *py.Object -// equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 == x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// not_equal, greater_equal, less_equal, greater, less -// -// Examples -// -------- -// >>> np.equal([0, 1, 3], np.arange(3)) -// array([ True, True, False]) -// -// What is compared are values, not types. So an int (1) and an array of -// length one can evaluate as True: -// -// >>> np.equal(1, np.ones(1)) -// array([ True]) -// -// The ``==`` operator can be used as a shorthand for ``np.equal`` on -// ndarrays. -// -// >>> a = np.array([2, 4, 6]) -// >>> b = np.array([2, 4, 2]) -// >>> a == b -// array([ True, True, False]) -// -//go:linkname Equal py.equal -func Equal(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 XOR x2, element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical XOR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// Boolean result of the logical XOR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_or, logical_not, bitwise_xor -// -// Examples -// -------- -// >>> np.logical_xor(True, False) -// True -// >>> np.logical_xor([True, True, False, False], [True, False, True, False]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_xor(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// Simple example showing support of broadcasting -// -// >>> np.logical_xor(0, np.eye(2)) -// array([[ True, False], -// [False, True]]) -// -//go:linkname LogicalXor py.logical_xor -func LogicalXor(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Remainder py.remainder -func Remainder(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Format a floating-point scalar as a decimal string in positional notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed, or if `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// fractional : boolean, optional -// If `True`, the cutoffs of `precision` and `min_digits` refer to the -// total number of digits after the decimal point, including leading -// zeros. -// If `False`, `precision` and `min_digits` refer to the total number of -// significant digits, before or after the decimal point, ignoring leading -// zeros. -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// pad_right : non-negative integer, optional -// Pad the right side of the string with whitespace until at least that -// many characters are to the right of the decimal point. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. Only has an effect if `unique=True` -// in which case additional digits past those necessary to uniquely -// identify the value may be printed, rounding the last additional digit. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_scientific -// -// Examples -// -------- -// >>> np.format_float_positional(np.float32(np.pi)) -// '3.1415927' -// >>> np.format_float_positional(np.float16(np.pi)) -// '3.14' -// >>> np.format_float_positional(np.float16(0.3)) -// '0.3' -// >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) -// '0.3000488281' -// -// -//go:linkname FormatFloatPositional py.format_float_positional -func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object -// -// Return the character for the minimum-size type to which given types can -// be safely cast. -// -// The returned type character must represent the smallest size dtype such -// that an array of the returned type can handle the data from an array of -// all types in `typechars` (or if `typechars` is an array, then its -// dtype.char). -// -// Parameters -// ---------- -// typechars : list of str or array_like -// If a list of strings, each string should represent a dtype. -// If array_like, the character representation of the array dtype is used. -// typeset : str or list of str, optional -// The set of characters that the returned character is chosen from. -// The default set is 'GDFgdf'. -// default : str, optional -// The default character, this is returned if none of the characters in -// `typechars` matches a character in `typeset`. -// -// Returns -// ------- -// typechar : str -// The character representing the minimum-size type that was found. -// -// See Also -// -------- -// dtype, sctype2char, maximum_sctype -// -// Examples -// -------- -// >>> np.mintypecode(['d', 'f', 'S']) -// 'd' -// >>> x = np.array([1.1, 2-3.j]) -// >>> np.mintypecode(x) -// 'D' -// -// >>> np.mintypecode('abceh', default='G') -// 'G' -// -// -// -//go:linkname Mintypecode py.mintypecode -func Mintypecode(typechars *py.Object, typeset *py.Object, Default *py.Object) *py.Object -// -// Test whether each element of a 1-D array is also present in a second array. -// -// Returns a boolean array the same length as `ar1` that is True -// where an element of `ar1` is in `ar2` and False otherwise. -// -// We recommend using :func:`isin` instead of `in1d` for new code. -// -// Parameters -// ---------- -// ar1 : (M,) array_like -// Input array. -// ar2 : array_like -// The values against which to test each value of `ar1`. -// assume_unique : bool, optional -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. Default is False. -// invert : bool, optional -// If True, the values in the returned array are inverted (that is, -// 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 -// -// Returns -// ------- -// in1d : (M,) ndarray, bool -// The values `ar1[in1d]` are in `ar2`. -// -// See Also -// -------- -// isin : Version of this function that preserves the -// shape of ar1. -// numpy.lib.arraysetops : Module with a number of other functions for -// performing set operations on arrays. -// -// Notes -// ----- -// `in1d` can be considered as an element-wise function version of the -// python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly -// equivalent to ``np.array([item in b for item in a])``. -// However, this idea fails if `ar2` is a set, or similar (non-sequence) -// container: As ``ar2`` is converted to an array, in those cases -// ``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 -// -------- -// >>> test = np.array([0, 1, 2, 5, 0]) -// >>> states = [0, 2] -// >>> mask = np.in1d(test, states) -// >>> mask -// array([ True, False, True, False, True]) -// >>> test[mask] -// array([0, 2, 0]) -// >>> mask = np.in1d(test, states, invert=True) -// >>> mask -// array([False, True, False, True, False]) -// >>> test[mask] -// array([1, 5]) -// -// -//go:linkname In1d py.in1d -func In1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object -// -// packbits(a, /, axis=None, bitorder='big') -// -// Packs the elements of a binary-valued array into bits in a uint8 array. -// -// The result is padded to full bytes by inserting zero bits at the end. -// -// Parameters -// ---------- -// a : array_like -// An array of integers or booleans whose elements should be packed to -// bits. -// axis : int, optional -// The dimension over which bit-packing is done. -// ``None`` implies packing the flattened array. -// bitorder : {'big', 'little'}, optional -// The order of the input bits. 'big' will mimic bin(val), -// ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will -// reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``. -// Defaults to 'big'. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// packed : ndarray -// Array of type uint8 whose elements represent bits corresponding to the -// logical (0 or nonzero) value of the input elements. The shape of -// `packed` has the same number of dimensions as the input (unless `axis` -// is None, in which case the output is 1-D). -// -// See Also -// -------- -// unpackbits: Unpacks elements of a uint8 array into a binary-valued output -// array. -// -// Examples -// -------- -// >>> a = np.array([[[1,0,1], -// ... [0,1,0]], -// ... [[1,1,0], -// ... [0,0,1]]]) -// >>> b = np.packbits(a, axis=-1) -// >>> b -// array([[[160], -// [ 64]], -// [[192], -// [ 32]]], dtype=uint8) -// -// Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, -// and 32 = 0010 0000. -// -// -// -//go:linkname Packbits py.packbits -func Packbits(a *py.Object, axis *py.Object, bitorder *py.Object) *py.Object -// asarray(a, dtype=None, order=None, *, like=None) -// -// Convert the input to an array. -// -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes lists, lists of tuples, tuples, tuples of tuples, tuples -// of lists and ndarrays. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'K'. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array interpretation of `a`. No copy is performed if the input -// is already an ndarray with matching dtype and order. If `a` is a -// subclass of ndarray, a base class ndarray is returned. -// -// See Also -// -------- -// asanyarray : Similar function which passes through subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfarray : Convert input to a floating point ndarray. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// asarray_chkfinite : Similar function which checks input for NaNs and Infs. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. -// -// Examples -// -------- -// Convert a list into an array: -// -// >>> a = [1, 2] -// >>> np.asarray(a) -// array([1, 2]) -// -// Existing arrays are not copied: -// -// >>> a = np.array([1, 2]) -// >>> np.asarray(a) is a -// True -// -// If `dtype` is set, array is copied only if dtype does not match: -// -// >>> a = np.array([1, 2], dtype=np.float32) -// >>> np.asarray(a, dtype=np.float32) is a -// True -// >>> np.asarray(a, dtype=np.float64) is a -// False -// -// Contrary to `asanyarray`, ndarray subclasses are not passed through: -// -// >>> issubclass(np.recarray, np.ndarray) -// True -// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray) -// >>> np.asarray(a) is a -// False -// >>> np.asanyarray(a) is a -// True -// -//go:linkname Asarray py.asarray -func Asarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname BitwiseNot py.bitwise_not -func BitwiseNot(__llgo_va_list ...interface{}) *py.Object -// fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise maximum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// maxima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The maximum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmin : -// Element-wise minimum of two arrays, ignores NaNs. -// maximum : -// Element-wise maximum of two arrays, propagates NaNs. -// amax : -// The maximum value of an array along a given axis, propagates NaNs. -// nanmax : -// The maximum value of an array along a given axis, ignores NaNs. -// -// minimum, amin, nanmin -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmax([2, 3, 4], [1, 5, 2]) -// array([ 2., 5., 4.]) -// -// >>> np.fmax(np.eye(2), [0.5, 2]) -// array([[ 1. , 2. ], -// [ 0.5, 2. ]]) -// -// >>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmax py.fmax -func Fmax(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return the real part of the complex argument. -// -// Parameters -// ---------- -// val : array_like -// Input array. -// -// Returns -// ------- -// out : ndarray or scalar -// The real component of the complex argument. If `val` is real, the type -// of `val` is used for the output. If `val` has complex elements, the -// returned type is float. -// -// See Also -// -------- -// real_if_close, imag, angle -// -// Examples -// -------- -// >>> a = np.array([1+2j, 3+4j, 5+6j]) -// >>> a.real -// array([1., 3., 5.]) -// >>> a.real = 9 -// >>> a -// array([9.+2.j, 9.+4.j, 9.+6.j]) -// >>> a.real = np.array([9, 8, 7]) -// >>> a -// array([9.+2.j, 8.+4.j, 7.+6.j]) -// >>> np.real(1 + 1j) -// 1.0 -// -// -// -//go:linkname Real py.real -func Real(val *py.Object) *py.Object -// -// Apply a function repeatedly over multiple axes. -// -// `func` is called as `res = func(a, axis)`, where `axis` is the first -// element of `axes`. The result `res` of the function call must have -// either the same dimensions as `a` or one less dimension. If `res` -// has one less dimension than `a`, a dimension is inserted before -// `axis`. The call to `func` is then repeated for each axis in `axes`, -// with `res` as the first argument. -// -// Parameters -// ---------- -// func : function -// This function must take two arguments, `func(a, axis)`. -// a : array_like -// Input array. -// axes : array_like -// Axes over which `func` is applied; the elements must be integers. -// -// Returns -// ------- -// apply_over_axis : ndarray -// The output array. The number of dimensions is the same as `a`, -// but the shape can be different. This depends on whether `func` -// changes the shape of its output with respect to its input. -// -// See Also -// -------- -// apply_along_axis : -// Apply a function to 1-D slices of an array along the given axis. -// -// Notes -// ----- -// This function is equivalent to tuple axis arguments to reorderable ufuncs -// with keepdims=True. Tuple axis arguments to ufuncs have been available since -// version 1.7.0. -// -// Examples -// -------- -// >>> 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]]]) -// -// Sum over axes 0 and 2. The result has same number of dimensions -// as the original array: -// -// >>> np.apply_over_axes(np.sum, a, [0,2]) -// array([[[ 60], -// [ 92], -// [124]]]) -// -// Tuple axis arguments to ufuncs are equivalent: -// -// >>> np.sum(a, axis=(0,2), keepdims=True) -// array([[[ 60], -// [ 92], -// [124]]]) -// -// -// -//go:linkname ApplyOverAxes py.apply_over_axes -func ApplyOverAxes(Func *py.Object, a *py.Object, axes *py.Object) *py.Object -// -// Check if the array is Fortran contiguous but *not* C contiguous. -// -// This function is obsolete and, because of changes due to relaxed stride -// checking, its return value for the same array may differ for versions -// of NumPy >= 1.10.0 and previous versions. If you only want to check if an -// array is Fortran contiguous use ``a.flags.f_contiguous`` instead. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// -// Returns -// ------- -// isfortran : bool -// Returns True if the array is Fortran contiguous but *not* C contiguous. -// -// -// Examples -// -------- -// -// np.array allows to specify whether the array is written in C-contiguous -// order (last index varies the fastest), or FORTRAN-contiguous order in -// memory (first index varies the fastest). -// -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// -// >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') -// >>> b -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(b) -// True -// -// -// The transpose of a C-ordered array is a FORTRAN-ordered array. -// -// >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') -// >>> a -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> np.isfortran(a) -// False -// >>> b = a.T -// >>> b -// array([[1, 4], -// [2, 5], -// [3, 6]]) -// >>> np.isfortran(b) -// True -// -// C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. -// -// >>> np.isfortran(np.array([1, 2], order='F')) -// False -// -// -// -//go:linkname Isfortran py.isfortran -func Isfortran(a *py.Object) *py.Object -// -// Compute the outer product of two vectors. -// -// Given two vectors `a` and `b` of length ``M`` and ``N``, repsectively, -// the outer product [1]_ is:: -// -// [[a_0*b_0 a_0*b_1 ... a_0*b_{N-1} ] -// [a_1*b_0 . -// [ ... . -// [a_{M-1}*b_0 a_{M-1}*b_{N-1} ]] -// -// Parameters -// ---------- -// a : (M,) array_like -// First input vector. Input is flattened if -// not already 1-dimensional. -// b : (N,) array_like -// Second input vector. Input is flattened if -// not already 1-dimensional. -// out : (M, N) ndarray, optional -// A location where the result is stored -// -// .. versionadded:: 1.9.0 -// -// Returns -// ------- -// out : (M, N) ndarray -// ``out[i, j] = a[i] * b[j]`` -// -// See also -// -------- -// inner -// einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent. -// ufunc.outer : A generalization to dimensions other than 1D and other -// operations. ``np.multiply.outer(a.ravel(), b.ravel())`` -// is the equivalent. -// tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))`` -// is the equivalent. -// -// References -// ---------- -// .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd -// ed., Baltimore, MD, Johns Hopkins University Press, 1996, -// pg. 8. -// -// Examples -// -------- -// Make a (*very* coarse) grid for computing a Mandelbrot set: -// -// >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)) -// >>> rl -// array([[-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.], -// [-2., -1., 0., 1., 2.]]) -// >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,))) -// >>> im -// array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j], -// [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j], -// [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], -// [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j], -// [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]]) -// >>> grid = rl + im -// >>> grid -// array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j], -// [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j], -// [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j], -// [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], -// [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) -// -// An example using a "vector" of letters: -// -// >>> x = np.array(['a', 'b', 'c'], dtype=object) -// >>> np.outer(x, [1, 2, 3]) -// array([['a', 'aa', 'aaa'], -// ['b', 'bb', 'bbb'], -// ['c', 'cc', 'ccc']], dtype=object) -// -// -// -//go:linkname Outer py.outer -func Outer(__llgo_va_list ...interface{}) *py.Object -// ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the ceiling of the input, element-wise. -// -// The ceil of the scalar `x` is the smallest integer `i`, such that -// ``i >= x``. It is often denoted as :math:`\lceil x \rceil`. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The ceiling of each element in `x`, with `float` dtype. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// floor, trunc, rint, fix -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.ceil(a) -// array([-1., -1., -0., 1., 2., 2., 2.]) -// -//go:linkname Ceil py.ceil -func Ceil(x *py.Object, out *py.Object) *py.Object -// -// Return the angle of the complex argument. -// -// Parameters -// ---------- -// z : array_like -// A complex number or sequence of complex numbers. -// deg : bool, optional -// Return angle in degrees if True, radians if False (default). -// -// Returns -// ------- -// angle : ndarray or scalar -// The counterclockwise angle from the positive real axis on the complex -// plane in the range ``(-pi, pi]``, with dtype as numpy.float64. -// -// .. versionchanged:: 1.16.0 -// This function works on subclasses of ndarray like `ma.array`. -// -// See Also -// -------- -// arctan2 -// absolute -// -// Notes -// ----- -// Although the angle of the complex number 0 is undefined, ``numpy.angle(0)`` -// returns the value 0. -// -// Examples -// -------- -// >>> np.angle([1.0, 1.0j, 1+1j]) # in radians -// array([ 0. , 1.57079633, 0.78539816]) # may vary -// >>> np.angle(1+1j, deg=True) # in degrees -// 45.0 -// -// -// -//go:linkname Angle py.angle -func Angle(z *py.Object, deg *py.Object) *py.Object -// -// Load ASCII data from a file and return it in a record array. -// -// If ``usemask=False`` a standard `recarray` is returned, -// if ``usemask=True`` a MaskedRecords array is returned. -// -// Parameters -// ---------- -// fname, kwargs : For a description of input parameters, see `genfromtxt`. -// -// See Also -// -------- -// numpy.genfromtxt : generic function -// -// Notes -// ----- -// By default, `dtype` is None, which means that the data-type of the output -// array will be determined from the data. -// -// -// -//go:linkname Recfromtxt py.recfromtxt -func Recfromtxt(fname *py.Object) *py.Object -// -// Return a new array with the specified shape. -// -// If the new array is larger than the original array, then the new -// array is filled with repeated copies of `a`. Note that this behavior -// is different from a.resize(new_shape) which fills with zeros instead -// of repeated copies of `a`. -// -// Parameters -// ---------- -// a : array_like -// Array to be resized. -// -// new_shape : int or tuple of int -// Shape of resized array. -// -// Returns -// ------- -// reshaped_array : ndarray -// The new array is formed from the data in the old array, repeated -// if necessary to fill out the required number of elements. The -// data are repeated iterating over the array in C-order. -// -// See Also -// -------- -// numpy.reshape : Reshape an array without changing the total size. -// numpy.pad : Enlarge and pad an array. -// numpy.repeat : Repeat elements of an array. -// ndarray.resize : resize an array in-place. -// -// Notes -// ----- -// When the total size of the array does not change `~numpy.reshape` should -// be used. In most other cases either indexing (to reduce the size) -// or padding (to increase the size) may be a more appropriate solution. -// -// Warning: This functionality does **not** consider axes separately, -// i.e. it does not apply interpolation/extrapolation. -// It fills the return array with the required number of elements, iterating -// over `a` in C-order, disregarding axes (and cycling back from the start if -// the new shape is larger). This functionality is therefore not suitable to -// resize images, or data where each axis represents a separate and distinct -// entity. -// -// Examples -// -------- -// >>> a=np.array([[0,1],[2,3]]) -// >>> np.resize(a,(2,3)) -// array([[0, 1, 2], -// [3, 0, 1]]) -// >>> np.resize(a,(1,4)) -// array([[0, 1, 2, 3]]) -// >>> np.resize(a,(2,4)) -// array([[0, 1, 2, 3], -// [0, 1, 2, 3]]) -// -// -// -//go:linkname Resize py.resize -func Resize(a *py.Object, newShape *py.Object) *py.Object -// isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaT (not a time) and return result as a boolean array. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like -// Input array with datetime or timedelta data type. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaT, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isnan, isinf, isneginf, isposinf, isfinite -// -// Examples -// -------- -// >>> np.isnat(np.datetime64("NaT")) -// True -// >>> np.isnat(np.datetime64("2016-01-01")) -// False -// >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) -// array([ True, False]) -// -//go:linkname Isnat py.isnat -func Isnat(x *py.Object, out *py.Object) *py.Object -// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of x1 OR x2 element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Logical OR is applied to the elements of `x1` and `x2`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// Boolean result of the logical OR operation applied to the elements -// of `x1` and `x2`; the shape is determined by broadcasting. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and, logical_not, logical_xor -// bitwise_or -// -// Examples -// -------- -// >>> np.logical_or(True, False) -// True -// >>> np.logical_or([True, False], [False, False]) -// array([ True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_or(x < 1, x > 3) -// array([ True, False, False, False, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.logical_or`` on -// boolean ndarrays. -// -// >>> a = np.array([True, False]) -// >>> b = np.array([False, False]) -// >>> a | b -// array([ True, False]) -// -//go:linkname LogicalOr py.logical_or -func LogicalOr(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Trigonometric sine, element-wise. -// -// Parameters -// ---------- -// x : array_like -// Angle, in radians (:math:`2 \pi` rad equals 360 degrees). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : array_like -// The sine of each element of x. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// arcsin, sinh, cos -// -// Notes -// ----- -// The sine is one of the fundamental functions of trigonometry (the -// mathematical study of triangles). Consider a circle of radius 1 -// centered on the origin. A ray comes in from the :math:`+x` axis, makes -// an angle at the origin (measured counter-clockwise from that axis), and -// departs from the origin. The :math:`y` coordinate of the outgoing -// ray's intersection with the unit circle is the sine of that angle. It -// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The -// function has zeroes where the angle is a multiple of :math:`\pi`. -// Sines of angles between :math:`\pi` and :math:`2\pi` are negative. -// The numerous properties of the sine and related functions are included -// in any standard trigonometry text. -// -// Examples -// -------- -// Print sine of one angle: -// -// >>> np.sin(np.pi/2.) -// 1.0 -// -// Print sines of an array of angles given in degrees: -// -// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) -// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) -// -// Plot the sine function: -// -// >>> import matplotlib.pylab as plt -// >>> x = np.linspace(-np.pi, np.pi, 201) -// >>> plt.plot(x, np.sin(x)) -// >>> plt.xlabel('Angle [rad]') -// >>> plt.ylabel('sin(x)') -// >>> plt.axis('tight') -// >>> plt.show() -// -//go:linkname Sin py.sin -func Sin(x *py.Object, out *py.Object) *py.Object -// -// Return the indices of the bins to which each value in input array belongs. -// -// ========= ============= ============================ -// `right` order of bins returned index `i` satisfies -// ========= ============= ============================ -// ``False`` increasing ``bins[i-1] <= x < bins[i]`` -// ``True`` increasing ``bins[i-1] < x <= bins[i]`` -// ``False`` decreasing ``bins[i-1] > x >= bins[i]`` -// ``True`` decreasing ``bins[i-1] >= x > bins[i]`` -// ========= ============= ============================ -// -// If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is -// returned as appropriate. -// -// Parameters -// ---------- -// x : array_like -// Input array to be binned. Prior to NumPy 1.10.0, this array had to -// be 1-dimensional, but can now have any shape. -// bins : array_like -// Array of bins. It has to be 1-dimensional and monotonic. -// right : bool, optional -// Indicating whether the intervals include the right or the left bin -// edge. Default behavior is (right==False) indicating that the interval -// does not include the right edge. The left bin end is open in this -// case, i.e., bins[i-1] <= x < bins[i] is the default behavior for -// monotonically increasing bins. -// -// Returns -// ------- -// indices : ndarray of ints -// Output array of indices, of same shape as `x`. -// -// Raises -// ------ -// ValueError -// If `bins` is not monotonic. -// TypeError -// If the type of the input is complex. -// -// See Also -// -------- -// bincount, histogram, unique, searchsorted -// -// Notes -// ----- -// If values in `x` are such that they fall outside the bin range, -// attempting to index `bins` with the indices that `digitize` returns -// will result in an IndexError. -// -// .. versionadded:: 1.10.0 -// -// `np.digitize` is implemented in terms of `np.searchsorted`. This means -// that a binary search is used to bin the values, which scales much better -// for larger number of bins than the previous linear search. It also removes -// the requirement for the input array to be 1-dimensional. -// -// For monotonically _increasing_ `bins`, the following are equivalent:: -// -// np.digitize(x, bins, right=True) -// np.searchsorted(bins, x, side='left') -// -// Note that as the order of the arguments are reversed, the side must be too. -// The `searchsorted` call is marginally faster, as it does not do any -// monotonicity checks. Perhaps more importantly, it supports all dtypes. -// -// Examples -// -------- -// >>> x = np.array([0.2, 6.4, 3.0, 1.6]) -// >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0]) -// >>> inds = np.digitize(x, bins) -// >>> inds -// array([1, 4, 3, 2]) -// >>> for n in range(x.size): -// ... print(bins[inds[n]-1], "<=", x[n], "<", bins[inds[n]]) -// ... -// 0.0 <= 0.2 < 1.0 -// 4.0 <= 6.4 < 10.0 -// 2.5 <= 3.0 < 4.0 -// 1.0 <= 1.6 < 2.5 -// -// >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.]) -// >>> bins = np.array([0, 5, 10, 15, 20]) -// >>> np.digitize(x,bins,right=True) -// array([1, 2, 3, 4, 4]) -// >>> np.digitize(x,bins,right=False) -// array([1, 3, 3, 4, 5]) -// -// -//go:linkname Digitize py.digitize -func Digitize(x *py.Object, bins *py.Object, right *py.Object) *py.Object -// -// Construct an array by repeating A the number of times given by reps. -// -// If `reps` has length ``d``, the result will have dimension of -// ``max(d, A.ndim)``. -// -// If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new -// axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, -// or shape (1, 1, 3) for 3-D replication. If this is not the desired -// behavior, promote `A` to d-dimensions manually before calling this -// function. -// -// If ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it. -// Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as -// (1, 1, 2, 2). -// -// Note : Although tile may be used for broadcasting, it is strongly -// recommended to use numpy's broadcasting operations and functions. -// -// Parameters -// ---------- -// A : array_like -// The input array. -// reps : array_like -// The number of repetitions of `A` along each axis. -// -// Returns -// ------- -// c : ndarray -// The tiled output array. -// -// See Also -// -------- -// repeat : Repeat elements of an array. -// broadcast_to : Broadcast an array to a new shape -// -// Examples -// -------- -// >>> a = np.array([0, 1, 2]) -// >>> np.tile(a, 2) -// array([0, 1, 2, 0, 1, 2]) -// >>> np.tile(a, (2, 2)) -// array([[0, 1, 2, 0, 1, 2], -// [0, 1, 2, 0, 1, 2]]) -// >>> np.tile(a, (2, 1, 2)) -// array([[[0, 1, 2, 0, 1, 2]], -// [[0, 1, 2, 0, 1, 2]]]) -// -// >>> b = np.array([[1, 2], [3, 4]]) -// >>> np.tile(b, 2) -// array([[1, 2, 1, 2], -// [3, 4, 3, 4]]) -// >>> np.tile(b, (2, 1)) -// array([[1, 2], -// [3, 4], -// [1, 2], -// [3, 4]]) -// -// >>> c = np.array([1,2,3,4]) -// >>> np.tile(c,(4,1)) -// array([[1, 2, 3, 4], -// [1, 2, 3, 4], -// [1, 2, 3, 4], -// [1, 2, 3, 4]]) -// -// -//go:linkname Tile py.tile -func Tile(A *py.Object, reps *py.Object) *py.Object -// -// Returns pointers to the end-points of an array. -// -// Parameters -// ---------- -// a : ndarray -// Input array. It must conform to the Python-side of the array -// interface. -// -// Returns -// ------- -// (low, high) : tuple of 2 integers -// The first integer is the first byte of the array, the second -// integer is just past the last byte of the array. If `a` is not -// contiguous it will not use every byte between the (`low`, `high`) -// values. -// -// Examples -// -------- -// >>> I = np.eye(2, dtype='f'); I.dtype -// dtype('float32') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// >>> I = np.eye(2); I.dtype -// dtype('float64') -// >>> low, high = np.byte_bounds(I) -// >>> high - low == I.size*I.itemsize -// True -// -// -// -//go:linkname ByteBounds py.byte_bounds -func ByteBounds(a *py.Object) *py.Object -// -// 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 -// 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 -// -// Parameters -// ---------- -// a : array_like -// Array to be sorted. -// kth : int or sequence of ints -// Element index to partition by. The k-th value of the element -// will be in its final sorted position and all smaller elements -// will be moved before it and all equal or greater 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 elements -// indexed by k-th of them into their sorted position at once. -// -// .. deprecated:: 1.22.0 -// Passing booleans as index is deprecated. -// axis : int or None, optional -// Axis along which to sort. If None, the array is flattened before -// sorting. The default is -1, which sorts along the last axis. -// kind : {'introselect'}, optional -// Selection algorithm. Default is 'introselect'. -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument -// specifies which fields to compare first, second, etc. A single -// field can be specified as a string. Not all fields need be -// specified, but unspecified fields will still be used, in the -// order in which they come up in the dtype, to break ties. -// -// Returns -// ------- -// partitioned_array : ndarray -// Array of the same type and shape as `a`. -// -// See Also -// -------- -// ndarray.partition : Method to sort an array in-place. -// argpartition : Indirect partition. -// sort : Full sorting -// -// Notes -// ----- -// The various selection algorithms are characterized by their average -// speed, worst case performance, work space size, and whether they are -// stable. A stable sort keeps items with the same key in the same -// relative order. The available algorithms have the following -// properties: -// -// ================= ======= ============= ============ ======= -// kind speed worst case work space stable -// ================= ======= ============= ============ ======= -// 'introselect' 1 O(n) 0 no -// ================= ======= ============= ============ ======= -// -// All the partition algorithms make temporary copies of the data when -// partitioning along any but the last axis. Consequently, -// partitioning along the last axis is faster and uses less space than -// partitioning along any other axis. -// -// The sort order for complex numbers is lexicographic. If both the -// real and imaginary parts are non-nan then the order is determined by -// the real parts except when they are equal, in which case the order -// is determined by the imaginary parts. -// -// Examples -// -------- -// >>> 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]) -// -// ``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] -// -// -//go:linkname Partition py.partition -func Partition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the complex conjugate, element-wise. -// -// The complex conjugate of a complex number is obtained by changing the -// sign of its imaginary part. -// -// Parameters -// ---------- -// x : array_like -// Input value. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The complex conjugate of `x`, with same dtype as `y`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// `conj` is an alias for `conjugate`: -// -// >>> np.conj is np.conjugate -// True -// -// Examples -// -------- -// >>> np.conjugate(1+2j) -// (1-2j) -// -// >>> x = np.eye(2) + 1j * np.eye(2) -// >>> np.conjugate(x) -// array([[ 1.-1.j, 0.-0.j], -// [ 0.-0.j, 1.-1.j]]) -// -//go:linkname Conj py.conj -func Conj(__llgo_va_list ...interface{}) *py.Object -// exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the exponential of all elements in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise exponential of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// expm1 : Calculate ``exp(x) - 1`` for all elements in the array. -// exp2 : Calculate ``2**x`` for all elements in the array. -// -// Notes -// ----- -// The irrational number ``e`` is also known as Euler's number. It is -// approximately 2.718281, and is the base of the natural logarithm, -// ``ln`` (this means that, if :math:`x = \ln y = \log_e y`, -// then :math:`e^x = y`. For real input, ``exp(x)`` is always positive. -// -// For complex arguments, ``x = a + ib``, we can write -// :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already -// known (it is the real argument, described above). The second term, -// :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with -// magnitude 1 and a periodic phase. -// -// References -// ---------- -// .. [1] Wikipedia, "Exponential function", -// https://en.wikipedia.org/wiki/Exponential_function -// .. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions -// with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69, -// https://personal.math.ubc.ca/~cbm/aands/page_69.htm -// -// Examples -// -------- -// Plot the magnitude and phase of ``exp(x)`` in the complex plane: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(-2*np.pi, 2*np.pi, 100) -// >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane -// >>> out = np.exp(xx) -// -// >>> plt.subplot(121) -// >>> plt.imshow(np.abs(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') -// >>> plt.title('Magnitude of exp(x)') -// -// >>> plt.subplot(122) -// >>> plt.imshow(np.angle(out), -// ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') -// >>> plt.title('Phase (angle) of exp(x)') -// >>> plt.show() -// -//go:linkname Exp py.exp -func Exp(x *py.Object, out *py.Object) *py.Object -// frompyfunc(func, /, nin, nout, *[, identity]) -// -// Takes an arbitrary Python function and returns a NumPy ufunc. -// -// Can be used, for example, to add broadcasting to a built-in Python -// function (see Examples section). -// -// Parameters -// ---------- -// func : Python function object -// An arbitrary Python function. -// nin : int -// The number of input arguments. -// nout : int -// The number of objects returned by `func`. -// identity : object, optional -// The value to use for the `~numpy.ufunc.identity` attribute of the resulting -// object. If specified, this is equivalent to setting the underlying -// C ``identity`` field to ``PyUFunc_IdentityValue``. -// If omitted, the identity is set to ``PyUFunc_None``. Note that this is -// _not_ equivalent to setting the identity to ``None``, which implies the -// operation is reorderable. -// -// Returns -// ------- -// out : ufunc -// Returns a NumPy universal function (``ufunc``) object. -// -// See Also -// -------- -// vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy. -// -// Notes -// ----- -// The returned ufunc always returns PyObject arrays. -// -// Examples -// -------- -// Use frompyfunc to add broadcasting to the Python function ``oct``: -// -// >>> oct_array = np.frompyfunc(oct, 1, 1) -// >>> oct_array(np.array((10, 30, 100))) -// array(['0o12', '0o36', '0o144'], dtype=object) -// >>> np.array((oct(10), oct(30), oct(100))) # for comparison -// array(['0o12', '0o36', '0o144'], dtype='`. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// greater, less_equal, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.less([1, 2], [2, 2]) -// array([ True, False]) -// -// The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays. -// -// >>> a = np.array([1, 2]) -// >>> b = np.array([2, 2]) -// >>> a < b -// array([ True, False]) -// -//go:linkname Less py.less -func Less(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute tangent element-wise. -// -// Equivalent to ``np.sin(x)/np.cos(x)`` element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding tangent values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972. -// -// Examples -// -------- -// >>> from math import pi -// >>> np.tan(np.array([-pi,pi/2,pi])) -// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16]) -// >>> -// >>> # Example of providing the optional output parameter illustrating -// >>> # that what is returned is a reference to said parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.cos([0.1], out1) -// >>> out2 is out1 -// True -// >>> -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Tan py.tan -func Tan(x *py.Object, out *py.Object) *py.Object -// -// Evaluate a piecewise-defined function. -// -// Given a set of conditions and corresponding functions, evaluate each -// function on the input data wherever its condition is true. -// -// Parameters -// ---------- -// x : ndarray or scalar -// The input domain. -// condlist : list of bool arrays or bool scalars -// Each boolean array corresponds to a function in `funclist`. Wherever -// `condlist[i]` is True, `funclist[i](x)` is used as the output value. -// -// Each boolean array in `condlist` selects a piece of `x`, -// and should therefore be of the same shape as `x`. -// -// The length of `condlist` must correspond to that of `funclist`. -// If one extra function is given, i.e. if -// ``len(funclist) == len(condlist) + 1``, then that extra function -// is the default value, used wherever all conditions are false. -// funclist : list of callables, f(x,*args,**kw), or scalars -// Each function is evaluated over `x` wherever its corresponding -// condition is True. It should take a 1d array as input and give an 1d -// array or a scalar value as output. If, instead of a callable, -// a scalar is provided then a constant function (``lambda x: scalar``) is -// assumed. -// args : tuple, optional -// Any further arguments given to `piecewise` are passed to the functions -// upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then -// each function is called as ``f(x, 1, 'a')``. -// kw : dict, optional -// Keyword arguments used in calling `piecewise` are passed to the -// functions upon execution, i.e., if called -// ``piecewise(..., ..., alpha=1)``, then each function is called as -// ``f(x, alpha=1)``. -// -// Returns -// ------- -// out : ndarray -// The output is the same shape and type as x and is found by -// calling the functions in `funclist` on the appropriate portions of `x`, -// as defined by the boolean arrays in `condlist`. Portions not covered -// by any condition have a default value of 0. -// -// -// See Also -// -------- -// choose, select, where -// -// Notes -// ----- -// This is similar to choose or select, except that functions are -// evaluated on elements of `x` that satisfy the corresponding condition from -// `condlist`. -// -// The result is:: -// -// |-- -// |funclist[0](x[condlist[0]]) -// out = |funclist[1](x[condlist[1]]) -// |... -// |funclist[n2](x[condlist[n2]]) -// |-- -// -// Examples -// -------- -// Define the sigma function, which is -1 for ``x < 0`` and +1 for ``x >= 0``. -// -// >>> x = np.linspace(-2.5, 2.5, 6) -// >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1]) -// array([-1., -1., -1., 1., 1., 1.]) -// -// Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for -// ``x >= 0``. -// -// >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x]) -// array([2.5, 1.5, 0.5, 0.5, 1.5, 2.5]) -// -// Apply the same function to a scalar value. -// -// >>> y = -2 -// >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x]) -// array(2) -// -// -// -//go:linkname Piecewise py.piecewise -func Piecewise(x *py.Object, condlist *py.Object, funclist *py.Object, __llgo_va_list ...interface{}) *py.Object -// fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None) -// -// Construct an array from data in a text or binary file. -// -// A highly efficient way of reading binary data with a known data-type, -// as well as parsing simply formatted text files. Data written using the -// `tofile` method can be read using this function. -// -// Parameters -// ---------- -// file : file or str or Path -// Open file object or filename. -// -// .. versionchanged:: 1.17.0 -// `pathlib.Path` objects are now accepted. -// -// dtype : data-type -// Data type of the returned array. -// For binary files, it is used to determine the size and byte-order -// of the items in the file. -// Most builtin numeric types are supported and extension types may be supported. -// -// .. versionadded:: 1.18.0 -// Complex dtypes. -// -// count : int -// Number of items to read. ``-1`` means all items (i.e., the complete -// file). -// sep : str -// Separator between items if file is a text file. -// Empty ("") separator means the file should be treated as binary. -// Spaces (" ") in the separator match zero or more whitespace characters. -// A separator consisting only of spaces must match at least one -// whitespace. -// offset : int -// The offset (in bytes) from the file's current position. Defaults to 0. -// Only permitted for binary files. -// -// .. versionadded:: 1.17.0 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// See also -// -------- -// load, save -// ndarray.tofile -// loadtxt : More flexible way of loading data from a text file. -// -// Notes -// ----- -// Do not rely on the combination of `tofile` and `fromfile` for -// data storage, as the binary files generated are not platform -// independent. In particular, no byte-order or data-type information is -// saved. Data can be stored in the platform independent ``.npy`` format -// using `save` and `load` instead. -// -// Examples -// -------- -// Construct an ndarray: -// -// >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]), -// ... ('temp', float)]) -// >>> x = np.zeros((1,), dtype=dt) -// >>> x['time']['min'] = 10; x['temp'] = 98.25 -// >>> x -// array([((10, 0), 98.25)], -// dtype=[('time', [('min', '>> import tempfile -// >>> fname = tempfile.mkstemp()[1] -// >>> x.tofile(fname) -// -// Read the raw data from disk: -// -// >>> np.fromfile(fname, dtype=dt) -// array([((10, 0), 98.25)], -// dtype=[('time', [('min', '>> np.save(fname, x) -// >>> np.load(fname + '.npy') -// array([((10, 0), 98.25)], -// dtype=[('time', [('min', '>> a = np.arange(60.).reshape(3,4,5) -// >>> b = np.arange(24.).reshape(4,3,2) -// >>> c = np.tensordot(a,b, axes=([1,0],[0,1])) -// >>> c.shape -// (5, 2) -// >>> c -// array([[4400., 4730.], -// [4532., 4874.], -// [4664., 5018.], -// [4796., 5162.], -// [4928., 5306.]]) -// >>> # A slower but equivalent way of computing the same... -// >>> d = np.zeros((5,2)) -// >>> for i in range(5): -// ... for j in range(2): -// ... for k in range(3): -// ... for n in range(4): -// ... d[i,j] += a[k,n,i] * b[n,k,j] -// >>> c == d -// array([[ True, True], -// [ True, True], -// [ True, True], -// [ True, True], -// [ True, True]]) -// -// An extended example taking advantage of the overloading of + and \*: -// -// >>> a = np.array(range(1, 9)) -// >>> a.shape = (2, 2, 2) -// >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object) -// >>> A.shape = (2, 2) -// >>> a; A -// array([[[1, 2], -// [3, 4]], -// [[5, 6], -// [7, 8]]]) -// array([['a', 'b'], -// ['c', 'd']], dtype=object) -// -// >>> np.tensordot(a, A) # third argument default is 2 for double-contraction -// array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object) -// -// >>> np.tensordot(a, A, 1) -// array([[['acc', 'bdd'], -// ['aaacccc', 'bbbdddd']], -// [['aaaaacccccc', 'bbbbbdddddd'], -// ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object) -// -// >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.) -// array([[[[['a', 'b'], -// ['c', 'd']], -// ... -// -// >>> np.tensordot(a, A, (0, 1)) -// array([[['abbbbb', 'cddddd'], -// ['aabbbbbb', 'ccdddddd']], -// [['aaabbbbbbb', 'cccddddddd'], -// ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object) -// -// >>> np.tensordot(a, A, (2, 1)) -// array([[['abb', 'cdd'], -// ['aaabbbb', 'cccdddd']], -// [['aaaaabbbbbb', 'cccccdddddd'], -// ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object) -// -// >>> np.tensordot(a, A, ((0, 1), (0, 1))) -// array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object) -// -// >>> np.tensordot(a, A, ((2, 1), (1, 0))) -// array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object) -// -// -// -//go:linkname Tensordot py.tensordot -func Tensordot(a *py.Object, b *py.Object, axes *py.Object) *py.Object -// -// Perform an indirect partition along the given axis using the -// algorithm specified by the `kind` keyword. It returns an array of -// indices of the same shape as `a` that index data along the given -// axis in partitioned order. -// -// .. versionadded:: 1.8.0 -// -// Parameters -// ---------- -// a : array_like -// Array to sort. -// 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 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. -// -// .. deprecated:: 1.22.0 -// Passing booleans as index is deprecated. -// axis : int or None, optional -// Axis along which to sort. The default is -1 (the last axis). If -// None, the flattened array is used. -// kind : {'introselect'}, optional -// Selection algorithm. Default is 'introselect' -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument -// specifies which fields to compare first, second, etc. A single -// field can be specified as a string, and not all fields need be -// specified, but unspecified fields will still be used, in the -// order in which they come up in the dtype, to break ties. -// -// Returns -// ------- -// 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=axis)`` -// always yields the partitioned `a`, irrespective of dimensionality. -// -// See Also -// -------- -// partition : Describes partition algorithms used. -// ndarray.partition : Inplace partition. -// argsort : Full indirect sort. -// take_along_axis : Apply ``index_array`` from argpartition -// to an array as if by calling partition. -// -// Notes -// ----- -// See `partition` for notes on the different selection algorithms. -// -// Examples -// -------- -// One dimensional array: -// -// >>> x = np.array([3, 4, 2, 1]) -// >>> x[np.argpartition(x, 3)] -// array([2, 1, 3, 4]) -// >>> x[np.argpartition(x, (1, 3))] -// array([1, 2, 3, 4]) -// -// >>> x = [3, 4, 2, 1] -// >>> np.array(x)[np.argpartition(x, 3)] -// array([2, 1, 3, 4]) -// -// Multi-dimensional array: -// -// >>> x = np.array([[3, 4, 2], [1, 3, 1]]) -// >>> index_array = np.argpartition(x, kth=1, axis=-1) -// >>> np.take_along_axis(x, index_array, axis=-1) # same as np.partition(x, kth=1) -// array([[2, 3, 4], -// [1, 1, 3]]) -// -// -// -//go:linkname Argpartition py.argpartition -func Argpartition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object -// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the largest integer smaller or equal to the division of the inputs. -// It is equivalent to the Python ``//`` operator and pairs with the -// Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)`` -// up to roundoff. -// -// Parameters -// ---------- -// x1 : array_like -// Numerator. -// x2 : array_like -// Denominator. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// y = floor(`x1`/`x2`) -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// remainder : Remainder complementary to floor_divide. -// divmod : Simultaneous floor division and remainder. -// divide : Standard division. -// floor : Round a number to the nearest integer toward minus infinity. -// ceil : Round a number to the nearest integer toward infinity. -// -// Examples -// -------- -// >>> np.floor_divide(7,3) -// 2 -// >>> np.floor_divide([1., 2., 3., 4.], 2.5) -// array([ 0., 0., 1., 1.]) -// -// The ``//`` operator can be used as a shorthand for ``np.floor_divide`` -// on ndarrays. -// -// >>> x1 = np.array([1., 2., 3., 4.]) -// >>> x1 // 2.5 -// array([0., 0., 1., 1.]) -// -//go:linkname FloorDivide py.floor_divide -func FloorDivide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for NaN and return result as a boolean array. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or bool -// True where ``x`` is NaN, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isinf, isneginf, isposinf, isfinite, isnat -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). This means that Not a Number is not equivalent to infinity. -// -// Examples -// -------- -// >>> np.isnan(np.nan) -// True -// >>> np.isnan(np.inf) -// False -// >>> np.isnan([np.log(-1.),1.,np.log(0)]) -// array([ True, False, False]) -// -//go:linkname Isnan py.isnan -func Isnan(x *py.Object, out *py.Object) *py.Object -// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Logarithm of the sum of exponentiations of the inputs. -// -// Calculates ``log(exp(x1) + exp(x2))``. This function is useful in -// statistics where the calculated probabilities of events may be so small -// as to exceed the range of normal floating point numbers. In such cases -// the logarithm of the calculated probability is stored. This function -// allows adding probabilities stored in such a fashion. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray -// Logarithm of ``exp(x1) + exp(x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2. -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> prob1 = np.log(1e-50) -// >>> prob2 = np.log(2.5e-50) -// >>> prob12 = np.logaddexp(prob1, prob2) -// >>> prob12 -// -113.87649168120691 -// >>> np.exp(prob12) -// 3.5000000000000057e-50 -// -//go:linkname Logaddexp py.logaddexp -func Logaddexp(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// add_docstring(obj, docstring) -// -// Add a docstring to a built-in obj if possible. -// If the obj already has a docstring raise a RuntimeError -// If this routine does not know how to add a docstring to the object -// raise a TypeError -// -//go:linkname AddDocstring py.add_docstring -func AddDocstring(obj *py.Object, docstring *py.Object) *py.Object -// -// Stack arrays in sequence vertically (row wise). -// -// This is equivalent to concatenation along the first axis after 1-D arrays -// of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by -// `vsplit`. -// -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// 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 -// The array formed by stacking the given arrays, will be at least 2-D. -// -// See Also -// -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// hstack : Stack arrays in sequence horizontally (column wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// vsplit : Split an array into multiple sub-arrays vertically (row-wise). -// -// Examples -// -------- -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.vstack((a,b)) -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// >>> a = np.array([[1], [2], [3]]) -// >>> b = np.array([[4], [5], [6]]) -// >>> np.vstack((a,b)) -// array([[1], -// [2], -// [3], -// [4], -// [5], -// [6]]) -// -// -// -//go:linkname RowStack py.row_stack -func RowStack(tup *py.Object) *py.Object -// from_dlpack(x, /) -// -// Create a NumPy array from an object implementing the ``__dlpack__`` -// protocol. Generally, the returned NumPy array is a read-only view -// of the input object. See [1]_ and [2]_ for more details. -// -// 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 -// -------- -// >>> import torch -// >>> x = torch.arange(10) -// >>> # create a view of the torch tensor "x" in NumPy -// >>> y = np.from_dlpack(x) -// -//go:linkname FromDlpack py.from_dlpack -func FromDlpack(x *py.Object) *py.Object -// degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from radians to degrees. -// -// Parameters -// ---------- -// x : array_like -// Input array in radians. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray of floats -// The corresponding degree values; if `out` was supplied this is a -// reference to it. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// rad2deg : equivalent function -// -// Examples -// -------- -// Convert a radian array to degrees -// -// >>> rad = np.arange(12.)*np.pi/6 -// >>> np.degrees(rad) -// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240., -// 270., 300., 330.]) -// -// >>> out = np.zeros((rad.shape)) -// >>> r = np.degrees(rad, out) -// >>> np.all(r == out) -// True -// -//go:linkname Degrees py.degrees -func Degrees(x *py.Object, out *py.Object) *py.Object -// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns an element-wise indication of the sign of a number. -// -// The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan -// is returned for nan inputs. -// -// For complex inputs, the `sign` function returns -// ``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``. -// -// complex(nan, 0) is returned for complex nan inputs. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The sign of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// There is more than one definition of sign in common use for complex -// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` -// which is different from a common alternative, :math:`x/|x|`. -// -// Examples -// -------- -// >>> np.sign([-5., 4.5]) -// array([-1., 1.]) -// >>> np.sign(0) -// 0 -// >>> np.sign(5-2j) -// (1+0j) -// -//go:linkname Sign py.sign -func Sign(x *py.Object, out *py.Object) *py.Object -// -// Get the current way of handling floating-point errors. -// -// Returns -// ------- -// res : dict -// A dictionary with keys "divide", "over", "under", and "invalid", -// whose values are from the strings "ignore", "print", "log", "warn", -// "raise", and "call". The keys represent possible floating-point -// exceptions, and the values define how these exceptions are handled. -// -// See Also -// -------- -// geterrcall, seterr, seterrcall -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterr() -// {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// >>> oldsettings = np.seterr(all='warn', over='raise') -// >>> np.geterr() -// {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} -// >>> np.arange(3.) / np.arange(3.) -// array([nan, 1., 1.]) -// -// -// -//go:linkname Geterr py.geterr -func Geterr() *py.Object -// -// Append values to the end of an array. -// -// Parameters -// ---------- -// arr : array_like -// Values are appended to a copy of this array. -// values : array_like -// These values are appended to a copy of `arr`. It must be of the -// correct shape (the same shape as `arr`, excluding `axis`). If -// `axis` is not specified, `values` can be any shape and will be -// flattened before use. -// axis : int, optional -// The axis along which `values` are appended. If `axis` is not -// given, both `arr` and `values` are flattened before use. -// -// Returns -// ------- -// append : ndarray -// A copy of `arr` with `values` appended to `axis`. Note that -// `append` does not occur in-place: a new array is allocated and -// filled. If `axis` is None, `out` is a flattened array. -// -// See Also -// -------- -// insert : Insert elements into an array. -// delete : Delete elements from an array. -// -// Examples -// -------- -// >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]]) -// array([1, 2, 3, ..., 7, 8, 9]) -// -// When `axis` is specified, `values` must have the correct shape. -// -// >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0) -// array([[1, 2, 3], -// [4, 5, 6], -// [7, 8, 9]]) -// >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0) -// Traceback (most recent call last): -// ... -// ValueError: all the input arrays must have same number of dimensions, but -// the array at index 0 has 2 dimension(s) and the array at index 1 has 1 -// dimension(s) -// -// -// -//go:linkname Append py.append -func Append(arr *py.Object, values *py.Object, axis *py.Object) *py.Object -// -// Return the directory that contains the NumPy \*.h header files. -// -// Extension modules that need to compile against NumPy should use this -// function to locate the appropriate include directory. -// -// Notes -// ----- -// When using ``distutils``, for example in ``setup.py``:: -// -// import numpy as np -// ... -// Extension('extension_name', ... -// include_dirs=[np.get_include()]) -// ... -// -// -// -//go:linkname GetInclude py.get_include -func GetInclude() *py.Object -// Save several arrays into a single file in uncompressed ``.npz`` format. -// -// Provide arrays as keyword arguments to store them under the -// corresponding name in the output file: ``savez(fn, x=x, y=y)``. -// -// If arrays are specified as positional arguments, i.e., ``savez(fn, -// x, y)``, their names will be `arr_0`, `arr_1`, etc. -// -// Parameters -// ---------- -// file : str or file -// Either the filename (string) or an open file (file-like object) -// where the data will be saved. If file is a string or a Path, the -// ``.npz`` extension will be appended to the filename if it is not -// already there. -// args : Arguments, optional -// Arrays to save to the file. Please use keyword arguments (see -// `kwds` below) to assign names to arrays. Arrays specified as -// args will be named "arr_0", "arr_1", and so on. -// kwds : Keyword arguments, optional -// Arrays to save to the file. Each array will be saved to the -// output file with its corresponding keyword name. -// -// Returns -// ------- -// None -// -// See Also -// -------- -// save : Save a single array to a binary file in NumPy format. -// savetxt : Save an array to a file as plain text. -// savez_compressed : Save several arrays into a compressed ``.npz`` archive -// -// Notes -// ----- -// The ``.npz`` file format is a zipped archive of files named after the -// variables they contain. The archive is not compressed and each file -// in the archive contains one variable in ``.npy`` format. For a -// description of the ``.npy`` format, see :py:mod:`numpy.lib.format`. -// -// When opening the saved ``.npz`` file with `load` a `NpzFile` object is -// returned. This is a dictionary-like object which can be queried for -// its list of arrays (with the ``.files`` attribute), and for the arrays -// themselves. -// -// Keys passed in `kwds` are used as filenames inside the ZIP archive. -// Therefore, keys should be valid filenames; e.g., avoid keys that begin with -// ``/`` or contain ``.``. -// -// When naming variables with keyword arguments, it is not possible to name a -// variable ``file``, as this would cause the ``file`` argument to be defined -// twice in the call to ``savez``. -// -// Examples -// -------- -// >>> from tempfile import TemporaryFile -// >>> outfile = TemporaryFile() -// >>> x = np.arange(10) -// >>> y = np.sin(x) -// -// Using `savez` with \*args, the arrays are saved with default names. -// -// >>> np.savez(outfile, x, y) -// >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file -// >>> npzfile = np.load(outfile) -// >>> npzfile.files -// ['arr_0', 'arr_1'] -// >>> npzfile['arr_0'] -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// Using `savez` with \**kwds, the arrays are saved with the keyword names. -// -// >>> outfile = TemporaryFile() -// >>> np.savez(outfile, x=x, y=y) -// >>> _ = outfile.seek(0) -// >>> npzfile = np.load(outfile) -// >>> sorted(npzfile.files) -// ['x', 'y'] -// >>> npzfile['x'] -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// -// -//go:linkname Savez py.savez -func Savez(file *py.Object, __llgo_va_list ...interface{}) *py.Object -// -// Construct an array from a text file, using regular expression parsing. -// -// The returned array is always a structured array, and is constructed from -// all matches of the regular expression in the file. Groups in the regular -// expression are converted to fields of the structured array. -// -// Parameters -// ---------- -// file : path or file -// Filename or file object to read. -// -// .. versionchanged:: 1.22.0 -// Now accepts `os.PathLike` implementations. -// regexp : str or regexp -// Regular expression used to parse the file. -// Groups in the regular expression correspond to fields in the dtype. -// dtype : dtype or list of dtypes -// Dtype for the structured array; must be a structured datatype. -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// -// .. versionadded:: 1.14.0 -// -// Returns -// ------- -// output : ndarray -// The output array, containing the part of the content of `file` that -// was matched by `regexp`. `output` is always a structured array. -// -// Raises -// ------ -// TypeError -// When `dtype` is not a valid dtype for a structured array. -// -// See Also -// -------- -// fromstring, loadtxt -// -// Notes -// ----- -// Dtypes for structured arrays can be specified in several forms, but all -// forms specify at least the data type and field name. For details see -// `basics.rec`. -// -// Examples -// -------- -// >>> from io import StringIO -// >>> text = StringIO("1312 foo\n1534 bar\n444 qux") -// -// >>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything] -// >>> output = np.fromregex(text, regexp, -// ... [('num', np.int64), ('key', 'S3')]) -// >>> output -// array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')], -// dtype=[('num', '>> output['num'] -// array([1312, 1534, 444]) -// -// -// -//go:linkname Fromregex py.fromregex -func Fromregex(__llgo_va_list ...interface{}) *py.Object -// -// Range of values (maximum - minimum) along an axis. -// -// The name of the function comes from the acronym for 'peak to peak'. -// -// .. warning:: -// `ptp` preserves the data type of the array. This means the -// return value for an input of signed integers with n bits -// (e.g. `np.int8`, `np.int16`, etc) is also a signed integer -// with n bits. In that case, peak-to-peak values greater than -// ``2**(n-1)-1`` will be returned as negative values. An example -// with a work-around is shown below. -// -// Parameters -// ---------- -// a : array_like -// Input values. -// axis : None or int or tuple of ints, optional -// Axis along which to find the peaks. By default, flatten the -// array. `axis` may be negative, in -// which case it counts from the last to the first axis. -// -// .. versionadded:: 1.15.0 -// -// If this is a tuple of ints, a reduction is performed on multiple -// axes, instead of a single axis or all the axes as before. -// out : array_like -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type of the output values will be cast if necessary. -// -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `ptp` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// Returns -// ------- -// 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 -// -------- -// >>> x = np.array([[4, 9, 2, 10], -// ... [6, 9, 7, 12]]) -// -// >>> np.ptp(x, axis=1) -// array([8, 6]) -// -// >>> np.ptp(x, axis=0) -// array([2, 0, 5, 2]) -// -// >>> np.ptp(x) -// 10 -// -// This example shows that a negative value can be returned when -// the input is an array of signed integers. -// -// >>> y = np.array([[1, 127], -// ... [0, 127], -// ... [-1, 127], -// ... [-2, 127]], dtype=np.int8) -// >>> np.ptp(y, axis=1) -// array([ 126, 127, -128, -127], dtype=int8) -// -// A work-around is to use the `view()` method to view the result as -// unsigned integers with the same bit width: -// -// >>> np.ptp(y, axis=1).view(np.uint8) -// array([126, 127, 128, 129], dtype=uint8) -// -// -// -//go:linkname Ptp py.ptp -func Ptp(a *py.Object, axis *py.Object, out *py.Object, keepdims *py.Object) *py.Object -// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truncated value of the input, element-wise. -// -// The truncated value of the scalar `x` is the nearest integer `i` which -// is closer to zero than `x` is. In short, the fractional part of the -// signed number `x` is discarded. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The truncated value of each element in `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// ceil, floor, rint, fix -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// Examples -// -------- -// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) -// >>> np.trunc(a) -// array([-1., -1., -0., 0., 1., 1., 2.]) -// -//go:linkname Trunc py.trunc -func Trunc(x *py.Object, out *py.Object) *py.Object -// -// Return the string representation of a scalar dtype. -// -// Parameters -// ---------- -// sctype : scalar dtype or object -// If a scalar dtype, the corresponding string character is -// returned. If an object, `sctype2char` tries to infer its scalar type -// and then return the corresponding string character. -// -// Returns -// ------- -// typechar : str -// The string character corresponding to the scalar type. -// -// Raises -// ------ -// ValueError -// If `sctype` is an object for which the type can not be inferred. -// -// See Also -// -------- -// obj2sctype, issctype, issubsctype, mintypecode -// -// Examples -// -------- -// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: -// ... print(np.sctype2char(sctype)) -// l # may vary -// d -// D -// S -// O -// -// >>> x = np.array([1., 2-1.j]) -// >>> np.sctype2char(x) -// 'D' -// >>> np.sctype2char(list) -// 'O' -// -// -// -//go:linkname Sctype2char py.sctype2char -func Sctype2char(sctype *py.Object) *py.Object -// -// Return numbers spaced evenly on a log scale (a geometric progression). -// -// This is similar to `logspace`, but with endpoints specified directly. -// Each output sample is a constant multiple of the previous. -// -// .. versionchanged:: 1.16.0 -// Non-scalar `start` and `stop` are now supported. -// -// Parameters -// ---------- -// start : array_like -// The starting value of the sequence. -// stop : array_like -// The final value of the sequence, unless `endpoint` is False. -// In that case, ``num + 1`` values are spaced over the -// interval in log-space, of which all but the last (a sequence of -// length `num`) are returned. -// num : integer, optional -// Number of samples to generate. Default is 50. -// endpoint : boolean, optional -// If true, `stop` is the last sample. Otherwise, it is not included. -// Default is True. -// dtype : dtype -// The type of the output array. If `dtype` is not given, the data type -// is inferred from `start` and `stop`. The inferred dtype will never be -// an integer; `float` is chosen even if the arguments would produce an -// array of integers. -// axis : int, optional -// The axis in the result to store the samples. Relevant only if start -// or stop are array-like. By default (0), the samples will be along a -// new axis inserted at the beginning. Use -1 to get an axis at the end. -// -// .. versionadded:: 1.16.0 -// -// Returns -// ------- -// samples : ndarray -// `num` samples, equally spaced on a log scale. -// -// See Also -// -------- -// logspace : Similar to geomspace, but with endpoints specified using log -// and base. -// linspace : Similar to geomspace, but with arithmetic instead of geometric -// progression. -// arange : Similar to linspace, with the step size specified instead of the -// number of samples. -// :ref:`how-to-partition` -// -// Notes -// ----- -// If the inputs or dtype are complex, the output will follow a logarithmic -// spiral in the complex plane. (There are an infinite number of spirals -// passing through two points; the output will follow the shortest such path.) -// -// Examples -// -------- -// >>> np.geomspace(1, 1000, num=4) -// array([ 1., 10., 100., 1000.]) -// >>> np.geomspace(1, 1000, num=3, endpoint=False) -// array([ 1., 10., 100.]) -// >>> np.geomspace(1, 1000, num=4, endpoint=False) -// array([ 1. , 5.62341325, 31.6227766 , 177.827941 ]) -// >>> np.geomspace(1, 256, num=9) -// array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.]) -// -// Note that the above may not produce exact integers: -// -// >>> np.geomspace(1, 256, num=9, dtype=int) -// array([ 1, 2, 4, 7, 16, 32, 63, 127, 256]) -// >>> np.around(np.geomspace(1, 256, num=9)).astype(int) -// array([ 1, 2, 4, 8, 16, 32, 64, 128, 256]) -// -// Negative, decreasing, and complex inputs are allowed: -// -// >>> np.geomspace(1000, 1, num=4) -// array([1000., 100., 10., 1.]) -// >>> np.geomspace(-1000, -1, num=4) -// array([-1000., -100., -10., -1.]) -// >>> np.geomspace(1j, 1000j, num=4) # Straight line -// array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j]) -// >>> np.geomspace(-1+0j, 1+0j, num=5) # Circle -// array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j, -// 6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j, -// 1.00000000e+00+0.00000000e+00j]) -// -// Graphical illustration of `endpoint` parameter: -// -// >>> import matplotlib.pyplot as plt -// >>> N = 10 -// >>> y = np.zeros(N) -// >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o') -// [] -// >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o') -// [] -// >>> plt.axis([0.5, 2000, 0, 3]) -// [0.5, 2000, 0, 3] -// >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both') -// >>> plt.show() -// -// -// -//go:linkname Geomspace py.geomspace -func Geomspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, dtype *py.Object, axis *py.Object) *py.Object -// -// Stack arrays in sequence vertically (row wise). -// -// This is equivalent to concatenation along the first axis after 1-D arrays -// of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by -// `vsplit`. -// -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// 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 -// The array formed by stacking the given arrays, will be at least 2-D. -// -// See Also -// -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// hstack : Stack arrays in sequence horizontally (column wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// vsplit : Split an array into multiple sub-arrays vertically (row-wise). -// -// Examples -// -------- -// >>> a = np.array([1, 2, 3]) -// >>> b = np.array([4, 5, 6]) -// >>> np.vstack((a,b)) -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// >>> a = np.array([[1], [2], [3]]) -// >>> b = np.array([[4], [5], [6]]) -// >>> np.vstack((a,b)) -// array([[1], -// [2], -// [3], -// [4], -// [5], -// [6]]) -// -// -// -//go:linkname Vstack py.vstack -func Vstack(tup *py.Object) *py.Object -// -// Returns a bool array, where True if input element is real. -// -// If element has complex type with zero complex part, the return value -// for that element is True. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// -// Returns -// ------- -// out : ndarray, bool -// Boolean array of same shape as `x`. -// -// Notes -// ----- -// `isreal` may behave unexpectedly for string or object arrays (see examples) -// -// See Also -// -------- -// iscomplex -// isrealobj : Return True if x is not a complex type. -// -// Examples -// -------- -// >>> 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]) -// -// -// -//go:linkname Isreal py.isreal -func Isreal(x *py.Object) *py.Object -// add_ufunc_docstring(ufunc, new_docstring) -// -// Replace the docstring for a ufunc with new_docstring. -// This method will only work if the current docstring for -// the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.) -// -// Parameters -// ---------- -// ufunc : numpy.ufunc -// A ufunc whose current doc is NULL. -// new_docstring : string -// The new docstring for the ufunc. -// -// Notes -// ----- -// This method allocates memory for new_docstring on -// the heap. Technically this creates a mempory leak, since this -// memory will not be reclaimed until the end of the program -// even if the ufunc itself is removed. However this will only -// be a problem if the user is repeatedly creating ufuncs with -// no documentation, adding documentation via add_newdoc_ufunc, -// and then throwing away the ufunc. -// -//go:linkname AddNewdocUfunc py.add_newdoc_ufunc -func AddNewdocUfunc(__llgo_va_list ...interface{}) *py.Object -// -// Build a matrix object from a string, nested sequence, or array. -// -// Parameters -// ---------- -// obj : str or array_like -// Input data. If a string, variables in the current scope may be -// referenced by name. -// ldict : dict, optional -// A dictionary that replaces local operands in current frame. -// Ignored if `obj` is not a string or `gdict` is None. -// gdict : dict, optional -// A dictionary that replaces global operands in current frame. -// Ignored if `obj` is not a string. -// -// Returns -// ------- -// out : matrix -// Returns a matrix object, which is a specialized 2-D array. -// -// See Also -// -------- -// block : -// A generalization of this function for N-d arrays, that returns normal -// ndarrays. -// -// Examples -// -------- -// >>> A = np.mat('1 1; 1 1') -// >>> B = np.mat('2 2; 2 2') -// >>> C = np.mat('3 4; 5 6') -// >>> D = np.mat('7 8; 9 0') -// -// All the following expressions construct the same block matrix: -// -// >>> np.bmat([[A, B], [C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// >>> np.bmat('A,B; C,D') -// matrix([[1, 1, 2, 2], -// [1, 1, 2, 2], -// [3, 4, 7, 8], -// [5, 6, 9, 0]]) -// -// -// -//go:linkname Bmat py.bmat -func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object -// frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None) -// -// Interpret a buffer as a 1-dimensional array. -// -// Parameters -// ---------- -// buffer : buffer_like -// An object that exposes the buffer interface. -// dtype : data-type, optional -// Data-type of the returned array; default: float. -// count : int, optional -// Number of items to read. ``-1`` means all data in the buffer. -// offset : int, optional -// Start reading the buffer from this offset (in bytes); default: 0. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// 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 -// be specified as part of the data-type, e.g.:: -// -// >>> dt = np.dtype(int) -// >>> dt = dt.newbyteorder('>') -// >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP -// -// 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' -// >>> np.frombuffer(s, dtype='S1', count=5, offset=6) -// array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1') -// -// >>> np.frombuffer(b'\x01\x02', dtype=np.uint8) -// array([1, 2], dtype=uint8) -// >>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3) -// array([1, 2, 3], dtype=uint8) -// -//go:linkname Frombuffer py.frombuffer -func Frombuffer(buffer *py.Object, dtype *py.Object, count *py.Object, offset *py.Object) *py.Object -// -// Return the cumulative product of elements along a given axis. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative product is computed. By default -// the input is flattened. -// dtype : dtype, optional -// Type of the returned array, as well as of the accumulator in which -// the elements are multiplied. If *dtype* is not specified, it -// defaults to the dtype of `a`, unless `a` has an integer dtype with -// a precision less than that of the default platform integer. In -// that case, the default platform integer is used instead. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type of the resulting values will be cast if necessary. -// -// Returns -// ------- -// cumprod : ndarray -// A new array holding the result is returned unless `out` is -// specified, in which case a reference to out is returned. -// -// See Also -// -------- -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. -// -// Examples -// -------- -// >>> a = np.array([1,2,3]) -// >>> np.cumprod(a) # intermediate results 1, 1*2 -// ... # total product 1*2*3 = 6 -// array([1, 2, 6]) -// >>> a = np.array([[1, 2, 3], [4, 5, 6]]) -// >>> np.cumprod(a, dtype=float) # specify type of output -// array([ 1., 2., 6., 24., 120., 720.]) -// -// The cumulative product for each column (i.e., over the rows) of `a`: -// -// >>> np.cumprod(a, axis=0) -// array([[ 1, 2, 3], -// [ 4, 10, 18]]) -// -// The cumulative product for each row (i.e. over the columns) of `a`: -// -// >>> np.cumprod(a,axis=1) -// array([[ 1, 2, 6], -// [ 4, 20, 120]]) -// -// -// -//go:linkname Cumprod py.cumprod -func Cumprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object -// -// Return the cross product of two (arrays of) vectors. -// -// The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular -// to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors -// are defined by the last axis of `a` and `b` by default, and these axes -// can have dimensions 2 or 3. Where the dimension of either `a` or `b` is -// 2, the third component of the input vector is assumed to be zero and the -// cross product calculated accordingly. In cases where both input vectors -// have dimension 2, the z-component of the cross product is returned. -// -// Parameters -// ---------- -// a : array_like -// Components of the first vector(s). -// b : array_like -// Components of the second vector(s). -// axisa : int, optional -// Axis of `a` that defines the vector(s). By default, the last axis. -// axisb : int, optional -// Axis of `b` that defines the vector(s). By default, the last axis. -// axisc : int, optional -// Axis of `c` containing the cross product vector(s). Ignored if -// both input vectors have dimension 2, as the return is scalar. -// By default, the last axis. -// axis : int, optional -// If defined, the axis of `a`, `b` and `c` that defines the vector(s) -// and cross product(s). Overrides `axisa`, `axisb` and `axisc`. -// -// Returns -// ------- -// c : ndarray -// Vector cross product(s). -// -// Raises -// ------ -// ValueError -// When the dimension of the vector(s) in `a` and/or `b` does not -// equal 2 or 3. -// -// See Also -// -------- -// inner : Inner product -// outer : Outer product. -// ix_ : Construct index arrays. -// -// Notes -// ----- -// .. versionadded:: 1.9.0 -// -// Supports full broadcasting of the inputs. -// -// Examples -// -------- -// Vector cross-product. -// -// >>> x = [1, 2, 3] -// >>> y = [4, 5, 6] -// >>> np.cross(x, y) -// array([-3, 6, -3]) -// -// One vector with dimension 2. -// -// >>> x = [1, 2] -// >>> y = [4, 5, 6] -// >>> np.cross(x, y) -// array([12, -6, -3]) -// -// Equivalently: -// -// >>> x = [1, 2, 0] -// >>> y = [4, 5, 6] -// >>> np.cross(x, y) -// array([12, -6, -3]) -// -// Both vectors with dimension 2. -// -// >>> x = [1,2] -// >>> y = [4,5] -// >>> np.cross(x, y) -// array(-3) -// -// Multiple vector cross-products. Note that the direction of the cross -// 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]]) -// >>> np.cross(x, y) -// array([[-3, 6, -3], -// [ 3, -6, 3]]) -// -// The orientation of `c` can be changed using the `axisc` keyword. -// -// >>> np.cross(x, y, axisc=0) -// array([[-3, 3], -// [ 6, -6], -// [-3, 3]]) -// -// Change the vector definition of `x` and `y` using `axisa` and `axisb`. -// -// >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]]) -// >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]]) -// >>> np.cross(x, y) -// array([[ -6, 12, -6], -// [ 0, 0, 0], -// [ 6, -12, 6]]) -// >>> np.cross(x, y, axisa=0, axisb=0) -// array([[-24, 48, -24], -// [-30, 60, -30], -// [-36, 72, -36]]) -// -// -// -//go:linkname Cross py.cross -func Cross(a *py.Object, b *py.Object, axisa *py.Object, axisb *py.Object, axisc *py.Object, axis *py.Object) *py.Object -//go:linkname Arccosh py.arccosh -func Arccosh(__llgo_va_list ...interface{}) *py.Object -// bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise OR of two arrays element-wise. -// -// Computes the bit-wise OR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``|``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_or -// bitwise_and -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 has the binary representation ``00001101``. Likewise, -// 16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is -// then ``00011101``, or 29: -// -// >>> np.bitwise_or(13, 16) -// 29 -// >>> np.binary_repr(29) -// '11101' -// -// >>> np.bitwise_or(32, 2) -// 34 -// >>> np.bitwise_or([33, 4], 1) -// array([33, 5]) -// >>> np.bitwise_or([33, 4], [1, 2]) -// array([33, 6]) -// -// >>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) -// array([ 6, 5, 255]) -// >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) -// array([ 6, 5, 255]) -// >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), -// ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) -// array([ 6, 5, 255, 2147483647]) -// >>> np.bitwise_or([True, True], [False, True]) -// array([ True, True]) -// -// The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([4, 4, 4]) -// >>> x1 | x2 -// array([ 6, 5, 255]) -// -//go:linkname BitwiseOr py.bitwise_or -func BitwiseOr(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Change the sign of x1 to that of x2, element-wise. -// -// If `x2` is a scalar, its sign will be copied to all elements of `x1`. -// -// Parameters -// ---------- -// x1 : array_like -// Values to change the sign of. -// x2 : array_like -// The sign of `x2` is copied to `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The values of `x1` with the sign of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> np.copysign(1.3, -1) -// -1.3 -// >>> 1/np.copysign(0, 1) -// inf -// >>> 1/np.copysign(0, -1) -// -inf -// -// >>> np.copysign([-1, 0, 1], -1.1) -// array([-1., -0., -1.]) -// >>> np.copysign([-1, 0, 1], np.arange(3)-1) -// array([-1., 0., 1.]) -// -//go:linkname Copysign py.copysign -func Copysign(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the next floating-point value after x1 towards x2, element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Values to find the next representable value of. -// x2 : array_like -// The direction where to look for the next representable value of `x1`. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The next representable values of `x1` in the direction of `x2`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Examples -// -------- -// >>> eps = np.finfo(np.float64).eps -// >>> np.nextafter(1, 2) == eps + 1 -// True -// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] -// array([ True, True]) -// -//go:linkname Nextafter py.nextafter -func Nextafter(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return Pearson product-moment correlation coefficients. -// -// Please refer to the documentation for `cov` for more detail. The -// relationship between the correlation coefficient matrix, `R`, and the -// covariance matrix, `C`, is -// -// .. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } } -// -// The values of `R` are between -1 and 1, inclusive. -// -// Parameters -// ---------- -// x : array_like -// A 1-D or 2-D array containing multiple variables and observations. -// Each row of `x` represents a variable, and each column a single -// observation of all those variables. Also see `rowvar` below. -// y : array_like, optional -// An additional set of variables and observations. `y` has the same -// shape as `x`. -// rowvar : bool, optional -// If `rowvar` is True (default), then each row represents a -// variable, with observations in the columns. Otherwise, the relationship -// is transposed: each column represents a variable, while the rows -// contain observations. -// bias : _NoValue, optional -// Has no effect, do not use. -// -// .. deprecated:: 1.10.0 -// ddof : _NoValue, optional -// Has no effect, do not use. -// -// .. deprecated:: 1.10.0 -// dtype : data-type, optional -// Data-type of the result. By default, the return data-type will have -// at least `numpy.float64` precision. -// -// .. versionadded:: 1.20 -// -// Returns -// ------- -// R : ndarray -// The correlation coefficient matrix of the variables. -// -// See Also -// -------- -// cov : Covariance matrix -// -// Notes -// ----- -// Due to floating point rounding the resulting array may not be Hermitian, -// the diagonal elements may not be 1, and the elements may not satisfy the -// inequality abs(a) <= 1. The real and imaginary parts are clipped to the -// interval [-1, 1] in an attempt to improve on that situation but is not -// much help in the complex case. -// -// This function accepts but discards arguments `bias` and `ddof`. This is -// for backwards compatibility with previous versions of this function. These -// arguments had no effect on the return values of the function and can be -// safely ignored in this and previous versions of numpy. -// -// Examples -// -------- -// In this example we generate two random arrays, ``xarr`` and ``yarr``, and -// compute the row-wise and column-wise Pearson correlation coefficients, -// ``R``. Since ``rowvar`` is true by default, we first find the row-wise -// Pearson correlation coefficients between the variables of ``xarr``. -// -// >>> import numpy as np -// >>> rng = np.random.default_rng(seed=42) -// >>> xarr = rng.random((3, 3)) -// >>> xarr -// array([[0.77395605, 0.43887844, 0.85859792], -// [0.69736803, 0.09417735, 0.97562235], -// [0.7611397 , 0.78606431, 0.12811363]]) -// >>> R1 = np.corrcoef(xarr) -// >>> R1 -// array([[ 1. , 0.99256089, -0.68080986], -// [ 0.99256089, 1. , -0.76492172], -// [-0.68080986, -0.76492172, 1. ]]) -// -// If we add another set of variables and observations ``yarr``, we can -// compute the row-wise Pearson correlation coefficients between the -// variables in ``xarr`` and ``yarr``. -// -// >>> yarr = rng.random((3, 3)) -// >>> yarr -// array([[0.45038594, 0.37079802, 0.92676499], -// [0.64386512, 0.82276161, 0.4434142 ], -// [0.22723872, 0.55458479, 0.06381726]]) -// >>> R2 = np.corrcoef(xarr, yarr) -// >>> R2 -// array([[ 1. , 0.99256089, -0.68080986, 0.75008178, -0.934284 , -// -0.99004057], -// [ 0.99256089, 1. , -0.76492172, 0.82502011, -0.97074098, -// -0.99981569], -// [-0.68080986, -0.76492172, 1. , -0.99507202, 0.89721355, -// 0.77714685], -// [ 0.75008178, 0.82502011, -0.99507202, 1. , -0.93657855, -// -0.83571711], -// [-0.934284 , -0.97074098, 0.89721355, -0.93657855, 1. , -// 0.97517215], -// [-0.99004057, -0.99981569, 0.77714685, -0.83571711, 0.97517215, -// 1. ]]) -// -// Finally if we use the option ``rowvar=False``, the columns are now -// being treated as the variables and we will find the column-wise Pearson -// correlation coefficients between variables in ``xarr`` and ``yarr``. -// -// >>> R3 = np.corrcoef(xarr, yarr, rowvar=False) -// >>> R3 -// array([[ 1. , 0.77598074, -0.47458546, -0.75078643, -0.9665554 , -// 0.22423734], -// [ 0.77598074, 1. , -0.92346708, -0.99923895, -0.58826587, -// -0.44069024], -// [-0.47458546, -0.92346708, 1. , 0.93773029, 0.23297648, -// 0.75137473], -// [-0.75078643, -0.99923895, 0.93773029, 1. , 0.55627469, -// 0.47536961], -// [-0.9665554 , -0.58826587, 0.23297648, 0.55627469, 1. , -// -0.46666491], -// [ 0.22423734, -0.44069024, 0.75137473, 0.47536961, -0.46666491, -// 1. ]]) -// -// -// -//go:linkname Corrcoef py.corrcoef -func Corrcoef(x *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object) *py.Object -// -// Return the indices to access (n, n) arrays, given a masking function. -// -// Assume `mask_func` is a function that, for a square array a of size -// ``(n, n)`` with a possible offset argument `k`, when called as -// ``mask_func(a, k)`` returns a new array with zeros in certain locations -// (functions like `triu` or `tril` do precisely this). Then this function -// returns the indices where the non-zero values would be located. -// -// Parameters -// ---------- -// n : int -// The returned indices will be valid to access arrays of shape (n, n). -// mask_func : callable -// A function whose call signature is similar to that of `triu`, `tril`. -// That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`. -// `k` is an optional argument to the function. -// k : scalar -// An optional argument which is passed through to `mask_func`. Functions -// like `triu`, `tril` take a second argument that is interpreted as an -// offset. -// -// Returns -// ------- -// indices : tuple of arrays. -// The `n` arrays of indices corresponding to the locations where -// ``mask_func(np.ones((n, n)), k)`` is True. -// -// See Also -// -------- -// triu, tril, triu_indices, tril_indices -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// These are the indices that would allow you to access the upper triangular -// part of any 3x3 array: -// -// >>> iu = np.mask_indices(3, np.triu) -// -// For example, if `a` is a 3x3 array: -// -// >>> a = np.arange(9).reshape(3, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// >>> a[iu] -// array([0, 1, 2, 4, 5, 8]) -// -// An offset can be passed also to the masking function. This gets us the -// indices starting on the first diagonal right of the main one: -// -// >>> iu1 = np.mask_indices(3, np.triu, 1) -// -// with which we now extract only three elements: -// -// >>> a[iu1] -// array([1, 2, 5]) -// -// -// -//go:linkname MaskIndices py.mask_indices -func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object -// -// lexsort(keys, axis=-1) -// -// Perform an indirect stable sort using a sequence of keys. -// -// Given multiple sorting keys, which can be interpreted as columns in a -// spreadsheet, lexsort returns an array of integer indices that describes -// the sort order by multiple columns. The last key in the sequence is used -// for the primary sort order, the second-to-last key for the secondary sort -// order, and so on. The keys argument must be a sequence of objects that -// can be converted to arrays of the same shape. If a 2D array is provided -// for the keys argument, its rows are interpreted as the sorting keys and -// sorting is according to the last row, second last row etc. -// -// Parameters -// ---------- -// keys : (k, N) array or tuple containing k (N,)-shaped sequences -// The `k` different "columns" to be sorted. The last column (or row if -// `keys` is a 2D array) is the primary sort key. -// axis : int, optional -// Axis to be indirectly sorted. By default, sort over the last axis. -// -// Returns -// ------- -// indices : (N,) ndarray of ints -// Array of indices that sort the keys along the specified axis. -// -// See Also -// -------- -// argsort : Indirect sort. -// ndarray.sort : In-place sort. -// sort : Return a sorted copy of an array. -// -// Examples -// -------- -// Sort names: first by surname, then by name. -// -// >>> surnames = ('Hertz', 'Galilei', 'Hertz') -// >>> first_names = ('Heinrich', 'Galileo', 'Gustav') -// >>> ind = np.lexsort((first_names, surnames)) -// >>> ind -// array([1, 2, 0]) -// -// >>> [surnames[i] + ", " + first_names[i] for i in ind] -// ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich'] -// -// Sort two columns of numbers: -// -// >>> a = [1,5,1,4,3,4,4] # First column -// >>> b = [9,4,0,4,0,2,1] # Second column -// >>> ind = np.lexsort((b,a)) # Sort by a, then by b -// >>> ind -// array([2, 0, 4, 6, 5, 3, 1]) -// -// >>> [(a[i],b[i]) for i in ind] -// [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)] -// -// Note that sorting is first according to the elements of ``a``. -// Secondary sorting is according to the elements of ``b``. -// -// A normal ``argsort`` would have yielded: -// -// >>> [(a[i],b[i]) for i in np.argsort(a)] -// [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)] -// -// Structured arrays are sorted lexically by ``argsort``: -// -// >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)], -// ... dtype=np.dtype([('x', int), ('y', int)])) -// -// >>> np.argsort(x) # or np.argsort(x, order=('x', 'y')) -// array([2, 0, 4, 6, 5, 3, 1]) -// -// -// -//go:linkname Lexsort py.lexsort -func Lexsort(keys *py.Object, axis *py.Object) *py.Object -// -// Return an array representing the indices of a grid. -// -// Compute an array where the subarrays contain index values 0, 1, ... -// varying only along the corresponding axis. -// -// Parameters -// ---------- -// dimensions : sequence of ints -// The shape of the grid. -// dtype : dtype, optional -// Data type of the result. -// sparse : boolean, optional -// Return a sparse representation of the grid instead of a dense -// representation. Default is False. -// -// .. versionadded:: 1.17 -// -// Returns -// ------- -// grid : one ndarray or tuple of ndarrays -// If sparse is False: -// Returns one array of grid indices, -// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. -// If sparse is True: -// Returns a tuple of arrays, with -// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with -// dimensions[i] in the ith place -// -// See Also -// -------- -// mgrid, ogrid, meshgrid -// -// Notes -// ----- -// The output shape in the dense case is obtained by prepending the number -// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` -// is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is -// ``(N, r0, ..., rN-1)``. -// -// The subarrays ``grid[k]`` contains the N-D array of indices along the -// ``k-th`` axis. Explicitly:: -// -// grid[k, i0, i1, ..., iN-1] = ik -// -// Examples -// -------- -// >>> grid = np.indices((2, 3)) -// >>> grid.shape -// (2, 2, 3) -// >>> grid[0] # row indices -// array([[0, 0, 0], -// [1, 1, 1]]) -// >>> grid[1] # column indices -// array([[0, 1, 2], -// [0, 1, 2]]) -// -// The indices can be used as an index into an array. -// -// >>> x = np.arange(20).reshape(5, 4) -// >>> row, col = np.indices((2, 3)) -// >>> x[row, col] -// array([[0, 1, 2], -// [4, 5, 6]]) -// -// Note that it would be more straightforward in the above example to -// extract the required elements directly with ``x[:2, :3]``. -// -// If sparse is set to true, the grid will be returned in a sparse -// representation. -// -// >>> i, j = np.indices((2, 3), sparse=True) -// >>> i.shape -// (2, 1) -// >>> j.shape -// (1, 3) -// >>> i # row indices -// array([[0], -// [1]]) -// >>> j # column indices -// array([[0, 1, 2]]) -// -// -// -//go:linkname Indices py.indices -func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object -// -// Compute the standard deviation along the specified axis. -// -// Returns the standard deviation, a measure of the spread of a distribution, -// of the array elements. The standard deviation is computed for the -// flattened array by default, otherwise over the specified axis. -// -// Parameters -// ---------- -// a : array_like -// Calculate the standard deviation of these values. -// axis : None or int or tuple of ints, optional -// Axis or axes along which the standard deviation is computed. The -// default is to compute the standard deviation of the flattened array. -// -// .. versionadded:: 1.7.0 -// -// If this is a tuple of ints, a standard deviation is performed over -// multiple axes, instead of a single axis or all the axes as before. -// dtype : dtype, optional -// Type to use in computing the standard deviation. For arrays of -// integer type the default is float64, for arrays of float types it is -// the same as the array type. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output but the type (of the calculated -// values) will be cast if necessary. -// ddof : int, optional -// Means Delta Degrees of Freedom. The divisor used in calculations -// is ``N - ddof``, where ``N`` represents the number of elements. -// By default `ddof` is zero. -// 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 input array. -// -// If the default value is passed, then `keepdims` will not be -// passed through to the `std` method of sub-classes of -// `ndarray`, however any non-default value will be. If the -// sub-class' method does not implement `keepdims` any -// exceptions will be raised. -// -// where : array_like of bool, optional -// Elements to include in the standard deviation. -// See `~numpy.ufunc.reduce` for details. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// standard_deviation : ndarray, see dtype parameter above. -// If `out` is None, return a new array containing the standard deviation, -// otherwise return a reference to the output array. -// -// See Also -// -------- -// var, mean, nanmean, nanstd, nanvar -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// The standard deviation is the square root of the average of the squared -// deviations from the mean, i.e., ``std = sqrt(mean(x))``, where -// ``x = abs(a - a.mean())**2``. -// -// The average squared deviation is typically calculated as ``x.sum() / N``, -// where ``N = len(x)``. If, however, `ddof` is specified, the divisor -// ``N - ddof`` is used instead. In standard statistical practice, ``ddof=1`` -// provides an unbiased estimator of the variance of the infinite population. -// ``ddof=0`` provides a maximum likelihood estimate of the variance for -// normally distributed variables. The standard deviation computed in this -// function is the square root of the estimated variance, so even with -// ``ddof=1``, it will not be an unbiased estimate of the standard deviation -// per se. -// -// Note that, for complex numbers, `std` takes the absolute -// value before squaring, so that the result is always real and nonnegative. -// -// For floating-point input, the *std* is computed using the same -// precision the input has. Depending on the input data, this can cause -// the results to be inaccurate, especially for float32 (see example below). -// Specifying a higher-accuracy accumulator using the `dtype` keyword can -// alleviate this issue. -// -// Examples -// -------- -// >>> a = np.array([[1, 2], [3, 4]]) -// >>> np.std(a) -// 1.1180339887498949 # may vary -// >>> np.std(a, axis=0) -// array([1., 1.]) -// >>> np.std(a, axis=1) -// array([0.5, 0.5]) -// -// In single precision, std() can be inaccurate: -// -// >>> a = np.zeros((2, 512*512), dtype=np.float32) -// >>> a[0, :] = 1.0 -// >>> a[1, :] = 0.1 -// >>> np.std(a) -// 0.45000005 -// -// Computing the standard deviation in float64 is more accurate: -// -// >>> np.std(a, dtype=np.float64) -// 0.44999999925494177 # may vary -// -// Specifying a where argument: -// -// >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) -// >>> np.std(a) -// 2.614064523559687 # may vary -// >>> np.std(a, where=[[True], [True], [False]]) -// 2.0 -// -// -// -//go:linkname Std py.std -func Std(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, ddof *py.Object, keepdims *py.Object) *py.Object -//go:linkname Absolute py.absolute -func Absolute(__llgo_va_list ...interface{}) *py.Object -//go:linkname Add py.add -func Add(__llgo_va_list ...interface{}) *py.Object -// geterrobj() -// -// Return the current object that defines floating-point error handling. -// -// The error object contains all information that defines the error handling -// behavior in NumPy. `geterrobj` is used internally by the other -// functions that get and set error handling behavior (`geterr`, `seterr`, -// `geterrcall`, `seterrcall`). -// -// Returns -// ------- -// errobj : list -// The error object, a list containing three elements: -// [internal numpy buffer size, error mask, error callback function]. -// -// The error mask is a single integer that holds the treatment information -// on all four floating point errors. The information for each error type -// is contained in three bits of the integer. If we print it in base 8, we -// can see what treatment is set for "invalid", "under", "over", and -// "divide" (in that order). The printed string can be interpreted with -// -// * 0 : 'ignore' -// * 1 : 'warn' -// * 2 : 'raise' -// * 3 : 'call' -// * 4 : 'print' -// * 5 : 'log' -// -// See Also -// -------- -// seterrobj, seterr, geterr, seterrcall, geterrcall -// getbufsize, setbufsize -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterrobj() # first get the defaults -// [8192, 521, None] -// -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// ... -// >>> old_bufsize = np.setbufsize(20000) -// >>> old_err = np.seterr(divide='raise') -// >>> old_handler = np.seterrcall(err_handler) -// >>> np.geterrobj() -// [8192, 521, ] -// -// >>> old_err = np.seterr(all='ignore') -// >>> np.base_repr(np.geterrobj()[1], 8) -// '0' -// >>> old_err = np.seterr(divide='warn', over='log', under='call', -// ... invalid='print') -// >>> np.base_repr(np.geterrobj()[1], 8) -// '4351' -// -//go:linkname Geterrobj py.geterrobj -func Geterrobj() *py.Object -// -// Get help information for an array, function, class, or module. -// -// Parameters -// ---------- -// object : object or str, optional -// Input object or name to get information about. If `object` is -// an `ndarray` instance, information about the array is printed. -// If `object` is a numpy object, its docstring is given. If it is -// a string, available modules are searched for matching objects. -// If None, information about `info` itself is returned. -// maxwidth : int, optional -// Printing width. -// output : file like object, optional -// File like object that the output is written to, default is -// ``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. -// -// See Also -// -------- -// source, lookfor -// -// Notes -// ----- -// When used interactively with an object, ``np.info(obj)`` is equivalent -// to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython -// prompt. -// -// Examples -// -------- -// >>> np.info(np.polyval) # doctest: +SKIP -// polyval(p, x) -// Evaluate the polynomial p at x. -// ... -// -// When using a string for `object` it is possible to get multiple results. -// -// >>> np.info('fft') # doctest: +SKIP -// *** Found in numpy *** -// Core FFT routines -// ... -// *** Found in numpy.fft *** -// fft(a, n=None, axis=-1) -// ... -// *** Repeat reference found in numpy.fft.fftpack *** -// *** Total of 3 references found. *** -// -// When the argument is an array, information about the array is printed. -// -// >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) -// >>> np.info(a) -// class: ndarray -// shape: (2, 3) -// strides: (24, 8) -// itemsize: 8 -// aligned: True -// contiguous: True -// fortran: False -// data pointer: 0x562b6e0d2860 # may vary -// byteorder: little -// byteswap: False -// type: complex64 -// -// -// -//go:linkname Info py.info -func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object -// fromiter(iter, dtype, count=-1, *, like=None) -// -// Create a new 1-dimensional array from an iterable object. -// -// Parameters -// ---------- -// iter : iterable object -// 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. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// The output array. -// -// Notes -// ----- -// Specify `count` to improve performance. It allows ``fromiter`` to -// pre-allocate the output array, instead of resizing it on demand. -// -// Examples -// -------- -// >>> iterable = (x*x for x in range(5)) -// >>> 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]]) -// -//go:linkname Fromiter py.fromiter -func Fromiter(iter *py.Object, dtype *py.Object, count *py.Object) *py.Object -// Context manager for setting print options. -// -// Set print options for the scope of the `with` block, and restore the old -// options at the end. See `set_printoptions` for the full description of -// available options. -// -// Examples -// -------- -// -// >>> from numpy.testing import assert_equal -// >>> with np.printoptions(precision=2): -// ... np.array([2.0]) / 3 -// array([0.67]) -// -// The `as`-clause of the `with`-statement gives the current print options: -// -// >>> with np.printoptions(precision=2) as opts: -// ... assert_equal(opts, np.get_printoptions()) -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// -// -//go:linkname Printoptions py.printoptions -func Printoptions(__llgo_va_list ...interface{}) *py.Object -// -// Return an ndarray of the provided type that satisfies requirements. -// -// This function is useful to be sure that an array with the correct flags -// is returned for passing to compiled code (perhaps through ctypes). -// -// Parameters -// ---------- -// a : array_like -// The object to be converted to a type-and-requirement-satisfying array. -// dtype : data-type -// 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 sequence of str -// The requirements list can be any of the following -// -// * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array -// * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array -// * 'ALIGNED' ('A') - ensure a data-type aligned array -// * 'WRITEABLE' ('W') - ensure a writable array -// * 'OWNDATA' ('O') - ensure an array that owns its own data -// * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Array with specified requirements and type if given. -// -// See Also -// -------- -// asarray : Convert input to an ndarray. -// asanyarray : Convert to an ndarray, but pass through ndarray subclasses. -// ascontiguousarray : Convert input to a contiguous array. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// ndarray.flags : Information about the memory layout of the array. -// -// Notes -// ----- -// The returned array will be guaranteed to have the listed requirements -// by making a copy if needed. -// -// Examples -// -------- -// >>> x = np.arange(6).reshape(2,3) -// >>> x.flags -// C_CONTIGUOUS : True -// F_CONTIGUOUS : False -// OWNDATA : False -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) -// >>> y.flags -// C_CONTIGUOUS : False -// F_CONTIGUOUS : True -// OWNDATA : True -// WRITEABLE : True -// ALIGNED : True -// WRITEBACKIFCOPY : False -// -// -// -//go:linkname Require py.require -func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object -// -// Take values from the input array by matching 1d index and data slices. -// -// This iterates over matching 1d slices oriented along the specified axis in -// the index and data arrays, and uses the former to look up values in the -// latter. These slices can be different lengths. -// -// Functions returning an index along an axis, like `argsort` and -// `argpartition`, produce suitable indices for this function. -// -// .. versionadded:: 1.15.0 -// -// Parameters -// ---------- -// arr : ndarray (Ni..., M, Nk...) -// Source array -// indices : ndarray (Ni..., J, Nk...) -// Indices to take along each 1d slice of `arr`. This must match the -// dimension of arr, but dimensions Ni and Nj only need to broadcast -// against `arr`. -// axis : int -// The axis to take 1d slices along. If axis is None, the input array is -// treated as if it had first been flattened to 1d, for consistency with -// `sort` and `argsort`. -// -// Returns -// ------- -// out: ndarray (Ni..., J, Nk...) -// The indexed result. -// -// Notes -// ----- -// This is equivalent to (but faster than) the following use of `ndindex` and -// `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: -// -// Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] -// J = indices.shape[axis] # Need not equal M -// out = np.empty(Ni + (J,) + Nk) -// -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// a_1d = a [ii + s_[:,] + kk] -// indices_1d = indices[ii + s_[:,] + kk] -// out_1d = out [ii + s_[:,] + kk] -// for j in range(J): -// out_1d[j] = a_1d[indices_1d[j]] -// -// Equivalently, eliminating the inner loop, the last two lines would be:: -// -// out_1d[:] = a_1d[indices_1d] -// -// See Also -// -------- -// take : Take along an axis, using the same indices for every 1d slice -// put_along_axis : -// Put values into the destination array by matching 1d index and data slices -// -// Examples -// -------- -// -// For this sample array -// -// >>> a = np.array([[10, 30, 20], [60, 40, 50]]) -// -// We can sort either by using sort directly, or argsort and this function -// -// >>> np.sort(a, axis=1) -// array([[10, 20, 30], -// [40, 50, 60]]) -// >>> ai = np.argsort(a, axis=1) -// >>> ai -// array([[0, 2, 1], -// [1, 2, 0]]) -// >>> np.take_along_axis(a, ai, axis=1) -// array([[10, 20, 30], -// [40, 50, 60]]) -// -// The same works for max and min, if you maintain the trivial dimension -// with ``keepdims``: -// -// >>> np.max(a, axis=1, keepdims=True) -// array([[30], -// [60]]) -// >>> ai = np.argmax(a, axis=1, keepdims=True) -// >>> ai -// array([[1], -// [0]]) -// >>> np.take_along_axis(a, ai, axis=1) -// array([[30], -// [60]]) -// -// If we want to get the max and min at the same time, we can stack the -// indices first -// -// >>> ai_min = np.argmin(a, axis=1, keepdims=True) -// >>> ai_max = np.argmax(a, axis=1, keepdims=True) -// >>> ai = np.concatenate([ai_min, ai_max], axis=1) -// >>> ai -// array([[0, 1], -// [1, 0]]) -// >>> np.take_along_axis(a, ai, axis=1) -// array([[10, 30], -// [40, 60]]) -// -// -//go:linkname TakeAlongAxis py.take_along_axis -func TakeAlongAxis(arr *py.Object, indices *py.Object, axis *py.Object) *py.Object -// asanyarray(a, dtype=None, order=None, *, like=None) -// -// Convert the input to an ndarray, but pass ndarray subclasses through. -// -// Parameters -// ---------- -// a : array_like -// Input data, in any form that can be converted to an array. This -// includes scalars, lists, lists of tuples, tuples, tuples of tuples, -// tuples of lists, and ndarrays. -// dtype : data-type, optional -// By default, the data-type is inferred from the input data. -// order : {'C', 'F', 'A', 'K'}, optional -// Memory layout. 'A' and 'K' depend on the order of input array a. -// 'C' row-major (C-style), -// 'F' column-major (Fortran-style) memory representation. -// 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise -// 'K' (keep) preserve input order -// Defaults to 'C'. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray or an ndarray subclass -// Array interpretation of `a`. If `a` is an ndarray or a subclass -// of ndarray, it is returned as-is and no copy is performed. -// -// See Also -// -------- -// asarray : Similar function which always returns ndarrays. -// ascontiguousarray : Convert input to a contiguous array. -// asfarray : Convert input to a floating point ndarray. -// asfortranarray : Convert input to an ndarray with column-major -// memory order. -// asarray_chkfinite : Similar function which checks input for NaNs and -// Infs. -// fromiter : Create an array from an iterator. -// fromfunction : Construct an array by executing a function on grid -// positions. -// -// Examples -// -------- -// Convert a list into an array: -// -// >>> a = [1, 2] -// >>> np.asanyarray(a) -// array([1, 2]) -// -// Instances of `ndarray` subclasses are passed through as-is: -// -// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray) -// >>> np.asanyarray(a) is a -// True -// -//go:linkname Asanyarray py.asanyarray -func Asanyarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object -// -// empty_like(prototype, dtype=None, order='K', subok=True, shape=None) -// -// Return a new array with the same shape and type as a given array. -// -// Parameters -// ---------- -// prototype : array_like -// The shape and data-type of `prototype` define these same attributes -// of the returned array. -// dtype : data-type, optional -// Overrides the data type of the result. -// -// .. versionadded:: 1.6.0 -// order : {'C', 'F', 'A', or 'K'}, optional -// Overrides the memory layout of the result. 'C' means C-order, -// 'F' means F-order, 'A' means 'F' if `prototype` is Fortran -// contiguous, 'C' otherwise. 'K' means match the layout of `prototype` -// as closely as possible. -// -// .. versionadded:: 1.6.0 -// subok : bool, optional. -// If True, then the newly created array will use the sub-class -// type of `prototype`, otherwise it will be a base-class array. Defaults -// to True. -// shape : int or sequence of ints, optional. -// Overrides the shape of the result. If order='K' and the number of -// dimensions is unchanged, will try to keep order, otherwise, -// order='C' is implied. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// out : ndarray -// Array of uninitialized (arbitrary) data with the same -// shape and type as `prototype`. -// -// See Also -// -------- -// ones_like : Return an array of ones with shape and type of input. -// zeros_like : Return an array of zeros with shape and type of input. -// full_like : Return a new array with shape of input filled with value. -// empty : Return a new uninitialized array. -// -// Notes -// ----- -// This function does *not* initialize the returned array; to do that use -// `zeros_like` or `ones_like` instead. It may be marginally faster than -// the functions that do set the array values. -// -// Examples -// -------- -// >>> a = ([1,2,3], [4,5,6]) # a is array-like -// >>> np.empty_like(a) -// array([[-1073741821, -1073741821, 3], # uninitialized -// [ 0, 0, -1073741821]]) -// >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) -// >>> np.empty_like(a) -// array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], # uninitialized -// [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]]) -// -// -// -//go:linkname EmptyLike py.empty_like -func EmptyLike(prototype *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object -// -// Returns the indices of the maximum values along an axis. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// By default, the index is into the flattened array, otherwise -// along the specified axis. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. -// 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 array. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// index_array : ndarray of ints -// Array of indices into the array. It has the same shape as `a.shape` -// with the dimension along `axis` removed. If `keepdims` is set to True, -// then the size of `axis` will be 1 with the resulting array having same -// shape as `a.shape`. -// -// See Also -// -------- -// ndarray.argmax, argmin -// amax : The maximum value along a given axis. -// unravel_index : Convert a flat index into an index tuple. -// take_along_axis : Apply ``np.expand_dims(index_array, axis)`` -// from argmax to an array as if by calling max. -// -// Notes -// ----- -// In case of multiple occurrences of the maximum values, the indices -// corresponding to the first occurrence are returned. -// -// Examples -// -------- -// >>> a = np.arange(6).reshape(2,3) + 10 -// >>> a -// array([[10, 11, 12], -// [13, 14, 15]]) -// >>> np.argmax(a) -// 5 -// >>> np.argmax(a, axis=0) -// array([1, 1, 1]) -// >>> np.argmax(a, axis=1) -// array([2, 2]) -// -// Indexes of the maximal elements of a N-dimensional array: -// -// >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape) -// >>> ind -// (1, 2) -// >>> a[ind] -// 15 -// -// >>> b = np.arange(6) -// >>> b[1] = 5 -// >>> b -// array([0, 5, 2, 3, 4, 5]) -// >>> np.argmax(b) # Only the first occurrence is returned. -// 1 -// -// >>> x = np.array([[4,2,3], [1,0,3]]) -// >>> index_array = np.argmax(x, axis=-1) -// >>> # Same as np.amax(x, axis=-1, keepdims=True) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) -// array([[4], -// [3]]) -// >>> # Same as np.amax(x, axis=-1) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) -// array([4, 3]) -// -// Setting `keepdims` to `True`, -// -// >>> x = np.arange(24).reshape((2, 3, 4)) -// >>> res = np.argmax(x, axis=1, keepdims=True) -// >>> res.shape -// (2, 1, 4) -// -// -//go:linkname Argmax py.argmax -func Argmax(a *py.Object, axis *py.Object, out *py.Object) *py.Object -// -// Return the cumulative product over the given axis. -// -// .. deprecated:: 1.25.0 -// ``cumproduct`` is deprecated as of NumPy 1.25.0, and will be -// removed in NumPy 2.0. Please use `cumprod` instead. -// -// See Also -// -------- -// cumprod : equivalent function; see for details. -// -// -//go:linkname Cumproduct py.cumproduct -func Cumproduct(__llgo_va_list ...interface{}) *py.Object -// -// Interchange two axes of an array. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis1 : int -// First axis. -// axis2 : int -// Second axis. -// -// Returns -// ------- -// a_swapped : ndarray -// For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is -// returned; otherwise a new array is created. For earlier NumPy -// versions a view of `a` is returned only if the order of the -// axes is changed, otherwise the input array is returned. -// -// Examples -// -------- -// >>> x = np.array([[1,2,3]]) -// >>> np.swapaxes(x,0,1) -// array([[1], -// [2], -// [3]]) -// -// >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]]) -// >>> x -// array([[[0, 1], -// [2, 3]], -// [[4, 5], -// [6, 7]]]) -// -// >>> np.swapaxes(x,0,2) -// array([[[0, 4], -// [2, 6]], -// [[1, 5], -// [3, 7]]]) -// -// -// -//go:linkname Swapaxes py.swapaxes -func Swapaxes(a *py.Object, axis1 *py.Object, axis2 *py.Object) *py.Object -// invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute bit-wise inversion, or bit-wise NOT, element-wise. -// -// Computes the bit-wise NOT of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``~``. -// -// For signed integer inputs, the two's complement is returned. In a -// two's-complement system negative numbers are represented by the two's -// complement of the absolute value. This is the most common method of -// representing signed integers on computers [1]_. A N-bit -// two's-complement system can represent every integer in the range -// :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. -// -// Parameters -// ---------- -// x : array_like -// Only integer and boolean types are handled. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// bitwise_and, bitwise_or, bitwise_xor -// logical_not -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Notes -// ----- -// `bitwise_not` is an alias for `invert`: -// -// >>> np.bitwise_not is np.invert -// True -// -// References -// ---------- -// .. [1] Wikipedia, "Two's complement", -// https://en.wikipedia.org/wiki/Two's_complement -// -// Examples -// -------- -// We've seen that 13 is represented by ``00001101``. -// The invert or bit-wise NOT of 13 is then: -// -// >>> x = np.invert(np.array(13, dtype=np.uint8)) -// >>> x -// 242 -// >>> np.binary_repr(x, width=8) -// '11110010' -// -// The result depends on the bit-width: -// -// >>> x = np.invert(np.array(13, dtype=np.uint16)) -// >>> x -// 65522 -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types the result is the two's complement of -// the result for the unsigned type: -// -// >>> np.invert(np.array([13], dtype=np.int8)) -// array([-14], dtype=int8) -// >>> np.binary_repr(-14, width=8) -// '11110010' -// -// Booleans are accepted as well: -// -// >>> np.invert(np.array([True, False])) -// array([False, True]) -// -// The ``~`` operator can be used as a shorthand for ``np.invert`` on -// ndarrays. -// -// >>> x1 = np.array([True, False]) -// >>> ~x1 -// array([False, True]) -// -//go:linkname Invert py.invert -func Invert(x *py.Object, out *py.Object) *py.Object -// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Convert angles from degrees to radians. -// -// Parameters -// ---------- -// x : array_like -// Input array in degrees. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding radian values. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// deg2rad : equivalent function -// -// Examples -// -------- -// Convert a degree array to radians -// -// >>> deg = np.arange(12.) * 30. -// >>> np.radians(deg) -// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 , -// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898, -// 5.23598776, 5.75958653]) -// -// >>> out = np.zeros((deg.shape)) -// >>> ret = np.radians(deg, out) -// >>> ret is out -// True -// -//go:linkname Radians py.radians -func Radians(x *py.Object, out *py.Object) *py.Object -// fastCopyAndTranspose(a) -// -// .. deprecated:: 1.24 -// -// fastCopyAndTranspose is deprecated and will be removed. Use the copy and -// transpose methods instead, e.g. ``arr.T.copy()`` -// -//go:linkname FastCopyAndTranspose py.fastCopyAndTranspose -func FastCopyAndTranspose(a *py.Object) *py.Object -// -// Evenly round to the given number of decimals. -// -// Parameters -// ---------- -// a : array_like -// Input data. -// decimals : int, optional -// Number of decimal places to round to (default: 0). If -// decimals is negative, it specifies the number of positions to -// the left of the decimal point. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape as the expected output, but the type of the output -// values will be cast if necessary. See :ref:`ufuncs-output-type` for more -// details. -// -// Returns -// ------- -// rounded_array : ndarray -// An array of the same type as `a`, containing the rounded values. -// Unless `out` was specified, a new array is created. A reference to -// the result is returned. -// -// The real and imaginary parts of complex numbers are rounded -// separately. The result of rounding a float is a float. -// -// See Also -// -------- -// ndarray.round : equivalent method -// around : an alias for this function -// ceil, fix, floor, rint, trunc -// -// -// Notes -// ----- -// 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. -// -// ``np.round`` uses a fast but sometimes inexact algorithm to round -// floating-point datatypes. For positive `decimals` it is equivalent to -// ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has -// error due to the inexact representation of decimal fractions in the IEEE -// floating point standard [1]_ and errors introduced when scaling by powers -// of ten. For instance, note the extra "1" in the following: -// -// >>> np.round(56294995342131.5, 3) -// 56294995342131.51 -// -// If your goal is to print such values with a fixed number of decimals, it is -// preferable to use numpy's float printing routines to limit the number of -// printed decimals: -// -// >>> np.format_float_positional(56294995342131.5, precision=3) -// '56294995342131.5' -// -// The float printing routines use an accurate but much more computationally -// demanding algorithm to compute the number of digits after the decimal -// point. -// -// Alternatively, Python's builtin `round` function uses a more accurate -// but slower algorithm for 64-bit floating point values: -// -// >>> round(56294995342131.5, 3) -// 56294995342131.5 -// >>> np.round(16.055, 2), round(16.055, 2) # equals 16.0549999999999997 -// (16.06, 16.05) -// -// -// References -// ---------- -// .. [1] "Lecture Notes on the Status of IEEE 754", William Kahan, -// https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF -// -// Examples -// -------- -// >>> np.round([0.37, 1.64]) -// array([0., 2.]) -// >>> np.round([0.37, 1.64], decimals=1) -// array([0.4, 1.6]) -// >>> np.round([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value -// array([0., 2., 2., 4., 4.]) -// >>> np.round([1,2,3,11], decimals=1) # ndarray of ints is returned -// array([ 1, 2, 3, 11]) -// >>> np.round([1,2,3,11], decimals=-1) -// array([ 0, 0, 0, 10]) -// -// -// -//go:linkname Round py.round -func Round(a *py.Object, decimals *py.Object, out *py.Object) *py.Object -// bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise AND of two arrays element-wise. -// -// Computes the bit-wise AND of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``&``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_and -// bitwise_or -// bitwise_xor -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise AND of 13 and 17 is -// therefore ``000000001``, or 1: -// -// >>> np.bitwise_and(13, 17) -// 1 -// -// >>> np.bitwise_and(14, 13) -// 12 -// >>> np.binary_repr(12) -// '1100' -// >>> np.bitwise_and([14,3], 13) -// array([12, 1]) -// -// >>> np.bitwise_and([11,7], [4,25]) -// array([0, 1]) -// >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) -// array([ 2, 4, 16]) -// >>> np.bitwise_and([True, True], [False, True]) -// array([False, True]) -// -// The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on -// ndarrays. -// -// >>> x1 = np.array([2, 5, 255]) -// >>> x2 = np.array([3, 14, 16]) -// >>> x1 & x2 -// array([ 2, 4, 16]) -// -//go:linkname BitwiseAnd py.bitwise_and -func BitwiseAnd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return the string representation of an array. -// -// Parameters -// ---------- -// arr : ndarray -// Input array. -// max_line_width : int, optional -// Inserts newlines if text is longer than `max_line_width`. -// Defaults to ``numpy.get_printoptions()['linewidth']``. -// precision : int, optional -// Floating point precision. -// Defaults to ``numpy.get_printoptions()['precision']``. -// suppress_small : bool, optional -// Represent numbers "very close" to zero as zero; default is False. -// Very close is defined by precision: if the precision is 8, e.g., -// numbers smaller (in absolute value) than 5e-9 are represented as -// zero. -// Defaults to ``numpy.get_printoptions()['suppress']``. -// -// Returns -// ------- -// string : str -// The string representation of an array. -// -// See Also -// -------- -// array_str, array2string, set_printoptions -// -// Examples -// -------- -// >>> np.array_repr(np.array([1,2])) -// 'array([1, 2])' -// >>> np.array_repr(np.ma.array([0.])) -// 'MaskedArray([0.])' -// >>> np.array_repr(np.array([], np.int32)) -// 'array([], dtype=int32)' -// -// >>> x = np.array([1e-6, 4e-7, 2, 3]) -// >>> np.array_repr(x, precision=6, suppress_small=True) -// 'array([0.000001, 0. , 2. , 3. ])' -// -// -// -//go:linkname ArrayRepr py.array_repr -func ArrayRepr(arr *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object -// -// Return a string representation of an array. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// max_line_width : int, optional -// Inserts newlines if text is longer than `max_line_width`. -// Defaults to ``numpy.get_printoptions()['linewidth']``. -// precision : int or None, optional -// Floating point precision. -// Defaults to ``numpy.get_printoptions()['precision']``. -// suppress_small : bool, optional -// Represent numbers "very close" to zero as zero; default is False. -// Very close is defined by precision: if the precision is 8, e.g., -// numbers smaller (in absolute value) than 5e-9 are represented as -// zero. -// Defaults to ``numpy.get_printoptions()['suppress']``. -// separator : str, optional -// Inserted between elements. -// prefix : str, optional -// suffix : str, optional -// The length of the prefix and suffix strings are used to respectively -// align and wrap the output. An array is typically printed as:: -// -// prefix + array2string(a) + suffix -// -// The output is left-padded by the length of the prefix string, and -// wrapping is forced at the column ``max_line_width - len(suffix)``. -// It should be noted that the content of prefix and suffix strings are -// not included in the output. -// style : _NoValue, optional -// Has no effect, do not use. -// -// .. deprecated:: 1.14.0 -// formatter : dict of callables, optional -// If not None, the keys should indicate the type(s) that the respective -// formatting function applies to. Callables should return a string. -// Types that are not specified (by their corresponding keys) are handled -// by the default formatters. Individual types for which a formatter -// can be set are: -// -// - 'bool' -// - 'int' -// - 'timedelta' : a `numpy.timedelta64` -// - 'datetime' : a `numpy.datetime64` -// - 'float' -// - 'longfloat' : 128-bit floats -// - 'complexfloat' -// - 'longcomplexfloat' : composed of two 128-bit floats -// - 'void' : type `numpy.void` -// - 'numpystr' : types `numpy.bytes_` and `numpy.str_` -// -// Other keys that can be used to set a group of types at once are: -// -// - 'all' : sets all types -// - 'int_kind' : sets 'int' -// - 'float_kind' : sets 'float' and 'longfloat' -// - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' -// - 'str_kind' : sets 'numpystr' -// threshold : int, optional -// Total number of array elements which trigger summarization -// rather than full repr. -// Defaults to ``numpy.get_printoptions()['threshold']``. -// edgeitems : int, optional -// Number of array items in summary at beginning and end of -// each dimension. -// Defaults to ``numpy.get_printoptions()['edgeitems']``. -// sign : string, either '-', '+', or ' ', optional -// Controls printing of the sign of floating-point types. If '+', always -// print the sign of positive values. If ' ', always prints a space -// (whitespace character) in the sign position of positive values. If -// '-', omit the sign character of positive values. -// Defaults to ``numpy.get_printoptions()['sign']``. -// floatmode : str, optional -// Controls the interpretation of the `precision` option for -// floating-point types. -// Defaults to ``numpy.get_printoptions()['floatmode']``. -// Can take the following values: -// -// - 'fixed': Always print exactly `precision` fractional digits, -// even if this would print more or fewer digits than -// necessary to specify the value uniquely. -// - 'unique': Print the minimum number of fractional digits necessary -// to represent each value uniquely. Different elements may -// have a different number of digits. The value of the -// `precision` option is ignored. -// - 'maxprec': Print at most `precision` fractional digits, but if -// an element can be uniquely represented with fewer digits -// only print it with that many. -// - 'maxprec_equal': Print at most `precision` fractional digits, -// but if every element in the array can be uniquely -// represented with an equal number of fewer digits, use that -// many digits for all elements. -// legacy : string or `False`, optional -// If set to the string `'1.13'` enables 1.13 legacy printing mode. This -// approximates numpy 1.13 print output by including a space in the sign -// position of floats and different behavior for 0d arrays. If set to -// `False`, disables legacy mode. Unrecognized strings will be ignored -// with a warning for forward compatibility. -// -// .. versionadded:: 1.14.0 -// -// Returns -// ------- -// array_str : str -// String representation of the array. -// -// Raises -// ------ -// TypeError -// if a callable in `formatter` does not return a string. -// -// See Also -// -------- -// array_str, array_repr, set_printoptions, get_printoptions -// -// Notes -// ----- -// If a formatter is specified for a certain type, the `precision` keyword is -// ignored for that type. -// -// This is a very flexible function; `array_repr` and `array_str` are using -// `array2string` internally so keywords with the same name should work -// identically in all three functions. -// -// Examples -// -------- -// >>> x = np.array([1e-16,1,2,3]) -// >>> np.array2string(x, precision=2, separator=',', -// ... suppress_small=True) -// '[0.,1.,2.,3.]' -// -// >>> x = np.arange(3.) -// >>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x}) -// '[0.00 1.00 2.00]' -// -// >>> x = np.arange(3) -// >>> np.array2string(x, formatter={'int':lambda x: hex(x)}) -// '[0x0 0x1 0x2]' -// -// -// -//go:linkname Array2string py.array2string -func Array2string(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object, separator *py.Object, prefix *py.Object, style *py.Object, formatter *py.Object, threshold *py.Object, edgeitems *py.Object, sign *py.Object, floatmode *py.Object, suffix *py.Object) *py.Object -// -// Return the current callback function used on floating-point errors. -// -// When the error handling for a floating-point error (one of "divide", -// "over", "under", or "invalid") is set to 'call' or 'log', the function -// that is called or the log instance that is written to is returned by -// `geterrcall`. This function or log instance has been set with -// `seterrcall`. -// -// Returns -// ------- -// errobj : callable, log instance or None -// The current error handler. If no handler was set through `seterrcall`, -// ``None`` is returned. -// -// See Also -// -------- -// seterrcall, seterr, geterr -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> np.geterrcall() # we did not yet set a handler, returns None -// -// >>> oldsettings = np.seterr(all='call') -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// >>> oldhandler = np.seterrcall(err_handler) -// >>> np.array([1, 2, 3]) / 0.0 -// Floating point error (divide by zero), with flag 1 -// array([inf, inf, inf]) -// -// >>> cur_handler = np.geterrcall() -// >>> cur_handler is err_handler -// True -// -// -// -//go:linkname Geterrcall py.geterrcall -func Geterrcall() *py.Object -// -// Insert values along the given axis before the given indices. -// -// Parameters -// ---------- -// arr : array_like -// Input array. -// obj : int, slice or sequence of ints -// Object that defines the index or indices before which `values` is -// inserted. -// -// .. versionadded:: 1.8.0 -// -// Support for multiple insertions when `obj` is a single scalar or a -// sequence with one element (similar to calling insert multiple -// times). -// values : array_like -// Values to insert into `arr`. If the type of `values` is different -// from that of `arr`, `values` is converted to the type of `arr`. -// `values` should be shaped so that ``arr[...,obj,...] = values`` -// is legal. -// axis : int, optional -// Axis along which to insert `values`. If `axis` is None then `arr` -// is flattened first. -// -// Returns -// ------- -// out : ndarray -// A copy of `arr` with `values` inserted. Note that `insert` -// does not occur in-place: a new array is returned. If -// `axis` is None, `out` is a flattened array. -// -// See Also -// -------- -// append : Append elements at the end of an array. -// concatenate : Join a sequence of arrays along an existing axis. -// delete : Delete elements from an array. -// -// 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``. -// -// Examples -// -------- -// >>> a = np.array([[1, 1], [2, 2], [3, 3]]) -// >>> a -// array([[1, 1], -// [2, 2], -// [3, 3]]) -// >>> np.insert(a, 1, 5) -// array([1, 5, 1, ..., 2, 3, 3]) -// >>> np.insert(a, 1, 5, axis=1) -// array([[1, 5, 1], -// [2, 5, 2], -// [3, 5, 3]]) -// -// Difference between sequence and scalars: -// -// >>> np.insert(a, [1], [[1],[2],[3]], axis=1) -// array([[1, 1, 1], -// [2, 2, 2], -// [3, 3, 3]]) -// >>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1), -// ... np.insert(a, [1], [[1],[2],[3]], axis=1)) -// True -// -// >>> b = a.flatten() -// >>> b -// array([1, 1, 2, 2, 3, 3]) -// >>> np.insert(b, [2, 2], [5, 6]) -// array([1, 1, 5, ..., 2, 3, 3]) -// -// >>> np.insert(b, slice(2, 4), [5, 6]) -// array([1, 1, 5, ..., 2, 3, 3]) -// -// >>> np.insert(b, [2, 2], [7.13, False]) # type casting -// array([1, 1, 7, ..., 2, 3, 3]) -// -// >>> x = np.arange(8).reshape(2, 4) -// >>> idx = (1, 3) -// >>> np.insert(x, idx, 999, axis=1) -// array([[ 0, 999, 1, 2, 999, 3], -// [ 4, 999, 5, 6, 999, 7]]) -// -// -// -//go:linkname Insert py.insert -func Insert(arr *py.Object, obj *py.Object, values *py.Object, axis *py.Object) *py.Object -// -// An array with ones at and below the given diagonal and zeros elsewhere. -// -// Parameters -// ---------- -// N : int -// Number of rows in the array. -// M : int, optional -// Number of columns in the array. -// By default, `M` is taken equal to `N`. -// k : int, optional -// The sub-diagonal at and below which the array is filled. -// `k` = 0 is the main diagonal, while `k` < 0 is below it, -// and `k` > 0 is above. The default is 0. -// dtype : dtype, optional -// Data type of the returned array. The default is float. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// tri : ndarray of shape (N, M) -// Array with its lower triangle filled with ones and zero elsewhere; -// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. -// -// Examples -// -------- -// >>> np.tri(3, 5, 2, dtype=int) -// array([[1, 1, 1, 0, 0], -// [1, 1, 1, 1, 0], -// [1, 1, 1, 1, 1]]) -// -// >>> np.tri(3, 5, -1) -// array([[0., 0., 0., 0., 0.], -// [1., 0., 0., 0., 0.], -// [1., 1., 0., 0., 0.]]) -// -// -// -//go:linkname Tri py.tri -func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object -// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the Heaviside step function. -// -// The Heaviside step function is defined as:: -// -// 0 if x1 < 0 -// heaviside(x1, x2) = x2 if x1 == 0 -// 1 if x1 > 0 -// -// where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used. -// -// Parameters -// ---------- -// x1 : array_like -// Input values. -// x2 : array_like -// The value of the function when x1 is 0. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// The output array, element-wise Heaviside step function of `x1`. -// This is a scalar if both `x1` and `x2` are scalars. -// -// Notes -// ----- -// .. versionadded:: 1.13.0 -// -// References -// ---------- -// .. Wikipedia, "Heaviside step function", -// https://en.wikipedia.org/wiki/Heaviside_step_function -// -// Examples -// -------- -// >>> np.heaviside([-1.5, 0, 2.0], 0.5) -// array([ 0. , 0.5, 1. ]) -// >>> np.heaviside([-1.5, 0, 2.0], 1) -// array([ 0., 1., 1.]) -// -//go:linkname Heaviside py.heaviside -func Heaviside(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// Return the current print options. -// -// Returns -// ------- -// print_opts : dict -// Dictionary of current print options with keys -// -// - precision : int -// - threshold : int -// - edgeitems : int -// - linewidth : int -// - suppress : bool -// - nanstr : str -// - infstr : str -// - formatter : dict of callables -// - sign : str -// -// For a full description of these options, see `set_printoptions`. -// -// See Also -// -------- -// set_printoptions, printoptions, set_string_function -// -// -// -//go:linkname GetPrintoptions py.get_printoptions -func GetPrintoptions() *py.Object -// -// Compute the q-th quantile of the data along the specified axis. -// -// .. versionadded:: 1.15.0 -// -// Parameters -// ---------- -// a : array_like of real numbers -// Input array or object that can be converted to an array. -// q : array_like of float -// Probability or sequence of probabilities for the quantiles to compute. -// Values must be between 0 and 1 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the quantiles are computed. The default is -// to compute the quantile(s) along a flattened version of the array. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape and buffer length as the expected output, but the -// type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by -// intermediate calculations, to save memory. In this case, the -// contents of the input `a` after this function completes is -// undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// quantile. There are many different methods, some unique to NumPy. -// See the notes for explanation. The options sorted by their R type -// as summarized in the H&F paper [1]_ are: -// -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' -// -// The first three methods are discontinuous. NumPy further defines the -// following discontinuous variations of the default 'linear' (7.) option: -// -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' -// -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. -// -// 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 array `a`. -// -// interpolation : str, optional -// Deprecated name for the method keyword argument. -// -// .. deprecated:: 1.22.0 -// -// Returns -// ------- -// quantile : scalar or ndarray -// If `q` is a single probability and `axis=None`, then the result -// is a scalar. If multiple probabilies levels are given, first axis of -// the result corresponds to the quantiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the -// same as that of the input. If `out` is specified, that array is -// returned instead. -// -// See Also -// -------- -// mean -// percentile : equivalent to quantile, but with q in the range [0, 100]. -// median : equivalent to ``quantile(..., 0.5)`` -// nanquantile -// -// 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``. -// -// 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 * ( 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 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 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 gives continuous results using: -// -// * alpha = 0 -// * beta = 1 -// -// hazen: -// method 5 of H&F [1]_. -// This method gives continuous results using: -// -// * alpha = 1/2 -// * beta = 1/2 -// -// weibull: -// method 6 of H&F [1]_. -// This method gives continuous results using: -// -// * alpha = 0 -// * beta = 0 -// -// linear: -// method 7 of H&F [1]_. -// This method gives continuous results using: -// -// * alpha = 1 -// * beta = 1 -// -// median_unbiased: -// method 8 of H&F [1]_. -// This method is probably the best method if the sample -// distribution function is unknown (see reference). -// This method gives continuous results using: -// -// * alpha = 1/3 -// * beta = 1/3 -// -// normal_unbiased: -// 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 gives continuous results using: -// -// * alpha = 3/8 -// * beta = 3/8 -// -// lower: -// NumPy method kept for backwards compatibility. -// Takes ``i`` as the interpolation point. -// -// higher: -// NumPy method kept for backwards compatibility. -// Takes ``j`` as the interpolation point. -// -// nearest: -// NumPy method kept for backwards compatibility. -// Takes ``i`` or ``j``, whichever is nearest. -// -// midpoint: -// NumPy method kept for backwards compatibility. -// Uses ``(i + j) / 2``. -// -// Examples -// -------- -// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) -// >>> a -// array([[10, 7, 4], -// [ 3, 2, 1]]) -// >>> np.quantile(a, 0.5) -// 3.5 -// >>> np.quantile(a, 0.5, axis=0) -// array([6.5, 4.5, 2.5]) -// >>> np.quantile(a, 0.5, axis=1) -// array([7., 2.]) -// >>> np.quantile(a, 0.5, axis=1, keepdims=True) -// array([[7.], -// [2.]]) -// >>> m = np.quantile(a, 0.5, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.quantile(a, 0.5, axis=0, out=out) -// array([6.5, 4.5, 2.5]) -// >>> m -// array([6.5, 4.5, 2.5]) -// >>> b = a.copy() -// >>> np.quantile(b, 0.5, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a == b) -// -// See also `numpy.percentile` for a visualization of most methods. -// -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 -// -// -// -//go:linkname Quantile py.quantile -func Quantile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object -// -// Protected string evaluation. -// -// 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 -// The string to evaluate. -// -// Returns -// ------- -// obj : object -// The result of evaluating `source`. -// -// Raises -// ------ -// SyntaxError -// If the code has invalid Python syntax, or if it contains -// non-literal code. -// -// Examples -// -------- -// >>> np.safe_eval('1') -// 1 -// >>> np.safe_eval('[1, 2, 3]') -// [1, 2, 3] -// >>> np.safe_eval('{"foo": ("bar", 10.0)}') -// {'foo': ('bar', 10.0)} -// -// >>> np.safe_eval('import os') -// Traceback (most recent call last): -// ... -// SyntaxError: invalid syntax -// -// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()') -// Traceback (most recent call last): -// ... -// ValueError: malformed node or string: <_ast.Call object at 0x...> -// -// -// -//go:linkname SafeEval py.safe_eval -func SafeEval(source *py.Object) *py.Object -// -// Find the set difference of two arrays. -// -// Return the unique values in `ar1` that are not in `ar2`. -// -// Parameters -// ---------- -// ar1 : array_like -// Input array. -// ar2 : array_like -// Input comparison array. -// assume_unique : bool -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. Default is False. -// -// Returns -// ------- -// setdiff1d : ndarray -// 1D array of values in `ar1` that are not in `ar2`. The result -// is sorted when `assume_unique=False`, but otherwise only sorted -// if the input is sorted. -// -// See Also -// -------- -// numpy.lib.arraysetops : Module with a number of other functions for -// performing set operations on arrays. -// -// Examples -// -------- -// >>> a = np.array([1, 2, 3, 2, 4, 1]) -// >>> b = np.array([3, 4, 5, 6]) -// >>> np.setdiff1d(a, b) -// array([1, 2]) -// -// -// -//go:linkname Setdiff1d py.setdiff1d -func Setdiff1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object) *py.Object -// -// 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. -// -// Parameters -// ---------- -// element : array_like -// Input array. -// test_elements : array_like -// The values against which to test each value of `element`. -// This argument is flattened if it is an array or array_like. -// See notes for behavior with non-array-like parameters. -// assume_unique : bool, optional -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. Default is False. -// invert : bool, optional -// If True, the values in the returned array are inverted, as if -// 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 -// ------- -// isin : ndarray, bool -// Has the same shape as `element`. The values `element[isin]` -// are in `test_elements`. -// -// See Also -// -------- -// in1d : Flattened version of this function. -// numpy.lib.arraysetops : Module with a number of other functions for -// performing set operations on arrays. -// -// Notes -// ----- -// -// `isin` is an element-wise function version of the python keyword `in`. -// ``isin(a, b)`` is roughly equivalent to -// ``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences. -// -// `element` and `test_elements` are converted to arrays if they are not -// already. If `test_elements` is a set (or other non-sequence collection) -// it will be converted to an object array with one element, rather than an -// array of the values contained in `test_elements`. This is a consequence -// 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 -// -------- -// >>> element = 2*np.arange(4).reshape((2, 2)) -// >>> element -// array([[0, 2], -// [4, 6]]) -// >>> test_elements = [1, 2, 4, 8] -// >>> mask = np.isin(element, test_elements) -// >>> mask -// array([[False, True], -// [ True, False]]) -// >>> element[mask] -// array([2, 4]) -// -// The indices of the matched values can be obtained with `nonzero`: -// -// >>> np.nonzero(mask) -// (array([0, 1]), array([1, 0])) -// -// The test can also be inverted: -// -// >>> mask = np.isin(element, test_elements, invert=True) -// >>> mask -// array([[ True, False], -// [False, True]]) -// >>> element[mask] -// array([0, 6]) -// -// Because of how `array` handles sets, the following does not -// work as expected: -// -// >>> test_set = {1, 2, 4, 8} -// >>> np.isin(element, test_set) -// array([[False, False], -// [False, False]]) -// -// Casting the set to a list gives the expected result: -// -// >>> np.isin(element, list(test_set)) -// array([[False, True], -// [ True, False]]) -// -// -//go:linkname Isin py.isin -func Isin(element *py.Object, testElements *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object -// -// Save an array to a text file. -// -// Parameters -// ---------- -// fname : filename or file handle -// If the filename ends in ``.gz``, the file is automatically saved in -// compressed gzip format. `loadtxt` understands gzipped files -// transparently. -// X : 1D or 2D array_like -// Data to be saved to a text file. -// fmt : str or sequence of strs, optional -// A single format (%10.5f), a sequence of formats, or a -// multi-format string, e.g. 'Iteration %d -- %10.5f', in which -// case `delimiter` is ignored. For complex `X`, the legal options -// for `fmt` are: -// -// * a single specifier, `fmt='%.4e'`, resulting in numbers formatted -// like `' (%s+%sj)' % (fmt, fmt)` -// * a full string specifying every real and imaginary part, e.g. -// `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns -// * a list of specifiers, one per column - in this case, the real -// and imaginary part must have separate specifiers, -// e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns -// delimiter : str, optional -// String or character separating columns. -// newline : str, optional -// String or character separating lines. -// -// .. versionadded:: 1.5.0 -// header : str, optional -// String that will be written at the beginning of the file. -// -// .. versionadded:: 1.7.0 -// footer : str, optional -// String that will be written at the end of the file. -// -// .. versionadded:: 1.7.0 -// comments : str, optional -// String that will be prepended to the ``header`` and ``footer`` strings, -// to mark them as comments. Default: '# ', as expected by e.g. -// ``numpy.loadtxt``. -// -// .. versionadded:: 1.7.0 -// encoding : {None, str}, optional -// Encoding used to encode the outputfile. Does not apply to output -// streams. If the encoding is something other than 'bytes' or 'latin1' -// you will not be able to load the file in NumPy versions < 1.14. Default -// is 'latin1'. -// -// .. versionadded:: 1.14.0 -// -// -// See Also -// -------- -// save : Save an array to a binary file in NumPy ``.npy`` format -// savez : Save several arrays into an uncompressed ``.npz`` archive -// savez_compressed : Save several arrays into a compressed ``.npz`` archive -// -// Notes -// ----- -// Further explanation of the `fmt` parameter -// (``%[flag]width[.precision]specifier``): -// -// flags: -// ``-`` : left justify -// -// ``+`` : Forces to precede result with + or -. -// -// ``0`` : Left pad the number with zeros instead of space (see width). -// -// width: -// Minimum number of characters to be printed. The value is not truncated -// if it has more characters. -// -// precision: -// - For integer specifiers (eg. ``d,i,o,x``), the minimum number of -// digits. -// - For ``e, E`` and ``f`` specifiers, the number of digits to print -// after the decimal point. -// - For ``g`` and ``G``, the maximum number of significant digits. -// - For ``s``, the maximum number of characters. -// -// specifiers: -// ``c`` : character -// -// ``d`` or ``i`` : signed decimal integer -// -// ``e`` or ``E`` : scientific notation with ``e`` or ``E``. -// -// ``f`` : decimal floating point -// -// ``g,G`` : use the shorter of ``e,E`` or ``f`` -// -// ``o`` : signed octal -// -// ``s`` : string of characters -// -// ``u`` : unsigned decimal integer -// -// ``x,X`` : unsigned hexadecimal integer -// -// This explanation of ``fmt`` is not complete, for an exhaustive -// specification see [1]_. -// -// References -// ---------- -// .. [1] `Format Specification Mini-Language -// `_, -// Python Documentation. -// -// Examples -// -------- -// >>> x = y = z = np.arange(0.0,5.0,1.0) -// >>> np.savetxt('test.out', x, delimiter=',') # X is an array -// >>> np.savetxt('test.out', (x,y,z)) # x,y,z equal sized 1D arrays -// >>> np.savetxt('test.out', x, fmt='%1.4e') # use exponential notation -// -// -// -//go:linkname Savetxt py.savetxt -func Savetxt(fname *py.Object, X *py.Object, fmt *py.Object, delimiter *py.Object, newline *py.Object, header *py.Object, footer *py.Object, comments *py.Object, encoding *py.Object) *py.Object -// -// unpackbits(a, /, axis=None, count=None, bitorder='big') -// -// Unpacks elements of a uint8 array into a binary-valued output array. -// -// Each element of `a` represents a bit-field that should be unpacked -// into a binary-valued output array. The shape of the output array is -// either 1-D (if `axis` is ``None``) or the same shape as the input -// array with unpacking done along the axis specified. -// -// Parameters -// ---------- -// a : ndarray, uint8 type -// Input array. -// axis : int, optional -// The dimension over which bit-unpacking is done. -// ``None`` implies unpacking the flattened array. -// count : int or None, optional -// The number of elements to unpack along `axis`, provided as a way -// of undoing the effect of packing a size that is not a multiple -// of eight. A non-negative number means to only unpack `count` -// bits. A negative number means to trim off that many bits from -// the end. ``None`` means to unpack the entire array (the -// default). Counts larger than the available number of bits will -// add zero padding to the output. Negative counts must not -// exceed the available number of bits. -// -// .. versionadded:: 1.17.0 -// -// bitorder : {'big', 'little'}, optional -// The order of the returned bits. 'big' will mimic bin(val), -// ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse -// the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``. -// Defaults to 'big'. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// unpacked : ndarray, uint8 type -// The elements are binary-valued (0 or 1). -// -// See Also -// -------- -// packbits : Packs the elements of a binary-valued array into bits in -// a uint8 array. -// -// Examples -// -------- -// >>> a = np.array([[2], [7], [23]], dtype=np.uint8) -// >>> a -// array([[ 2], -// [ 7], -// [23]], dtype=uint8) -// >>> b = np.unpackbits(a, axis=1) -// >>> b -// array([[0, 0, 0, 0, 0, 0, 1, 0], -// [0, 0, 0, 0, 0, 1, 1, 1], -// [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8) -// >>> c = np.unpackbits(a, axis=1, count=-3) -// >>> c -// array([[0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0], -// [0, 0, 0, 1, 0]], dtype=uint8) -// -// >>> p = np.packbits(b, axis=0) -// >>> np.unpackbits(p, axis=0) -// array([[0, 0, 0, 0, 0, 0, 1, 0], -// [0, 0, 0, 0, 0, 1, 1, 1], -// [0, 0, 0, 1, 0, 1, 1, 1], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0], -// [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8) -// >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0])) -// True -// -// -// -//go:linkname Unpackbits py.unpackbits -func Unpackbits(a *py.Object, axis *py.Object, count *py.Object, bitorder *py.Object) *py.Object -// -// Return a sorted copy of an array. -// -// Parameters -// ---------- -// a : array_like -// Array to be sorted. -// axis : int or None, optional -// Axis along which to sort. If None, the array is flattened before -// sorting. The default is -1, which sorts along the last axis. -// kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional -// Sorting algorithm. The default is 'quicksort'. Note that both 'stable' -// and 'mergesort' use timsort or radix sort under the covers and, in general, -// the actual implementation will vary with data type. The 'mergesort' option -// is retained for backwards compatibility. -// -// .. versionchanged:: 1.15.0. -// The 'stable' option was added. -// -// order : str or list of str, optional -// When `a` is an array with fields defined, this argument specifies -// which fields to compare first, second, etc. A single field can -// be specified as a string, and not all fields need be specified, -// but unspecified fields will still be used, in the order in which -// they come up in the dtype, to break ties. -// -// Returns -// ------- -// sorted_array : ndarray -// Array of the same type and shape as `a`. -// -// See Also -// -------- -// ndarray.sort : Method to sort an array in-place. -// argsort : Indirect sort. -// lexsort : Indirect stable sort on multiple keys. -// searchsorted : Find elements in a sorted array. -// partition : Partial sort. -// -// Notes -// ----- -// The various sorting algorithms are characterized by their average speed, -// worst case performance, work space size, and whether they are stable. A -// stable sort keeps items with the same key in the same relative -// order. The four algorithms implemented in NumPy have the following -// properties: -// -// =========== ======= ============= ============ ======== -// kind speed worst case work space stable -// =========== ======= ============= ============ ======== -// 'quicksort' 1 O(n^2) 0 no -// 'heapsort' 3 O(n*log(n)) 0 no -// 'mergesort' 2 O(n*log(n)) ~n/2 yes -// 'timsort' 2 O(n*log(n)) ~n/2 yes -// =========== ======= ============= ============ ======== -// -// .. note:: The datatype determines which of 'mergesort' or 'timsort' -// is actually used, even if 'mergesort' is specified. User selection -// at a finer scale is not currently available. -// -// All the sort algorithms make temporary copies of the data when -// sorting along any but the last axis. Consequently, sorting along -// the last axis is faster and uses less space than sorting along -// any other axis. -// -// The sort order for complex numbers is lexicographic. If both the real -// and imaginary parts are non-nan then the order is determined by the -// real parts except when they are equal, in which case the order is -// determined by the imaginary parts. -// -// Previous to numpy 1.4.0 sorting real and complex arrays containing nan -// values led to undefined behaviour. In numpy versions >= 1.4.0 nan -// values are sorted to the end. The extended sort order is: -// -// * Real: [R, nan] -// * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj] -// -// where R is a non-nan real value. Complex values with the same nan -// placements are sorted according to the non-nan part if it exists. -// Non-nan values are sorted as before. -// -// .. versionadded:: 1.12.0 -// -// quicksort has been changed to `introsort `_. -// When sorting does not make enough progress it switches to -// `heapsort `_. -// This implementation makes quicksort O(n*log(n)) in the worst case. -// -// 'stable' automatically chooses the best stable sorting algorithm -// for the data type being sorted. -// It, along with 'mergesort' is currently mapped to -// `timsort `_ -// or `radix sort `_ -// depending on the data type. -// API forward compatibility currently limits the -// ability to select the implementation and it is hardwired for the different -// data types. -// -// .. versionadded:: 1.17.0 -// -// Timsort is added for better performance on already or nearly -// sorted data. On random data timsort is almost identical to -// mergesort. It is now used for stable sort while quicksort is still the -// default sort if none is chosen. For timsort details, refer to -// `CPython listsort.txt `_. -// 'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is an -// O(n) sort instead of O(n log n). -// -// .. versionchanged:: 1.18.0 -// -// NaT now sorts to the end of arrays for consistency with NaN. -// -// Examples -// -------- -// >>> a = np.array([[1,4],[3,1]]) -// >>> np.sort(a) # sort along the last axis -// array([[1, 4], -// [1, 3]]) -// >>> np.sort(a, axis=None) # sort the flattened array -// array([1, 1, 3, 4]) -// >>> np.sort(a, axis=0) # sort along the first axis -// array([[1, 1], -// [3, 4]]) -// -// Use the `order` keyword to specify a field to use when sorting a -// structured array: -// -// >>> dtype = [('name', 'S10'), ('height', float), ('age', int)] -// >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38), -// ... ('Galahad', 1.7, 38)] -// >>> a = np.array(values, dtype=dtype) # create a structured array -// >>> np.sort(a, order='height') # doctest: +SKIP -// array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41), -// ('Lancelot', 1.8999999999999999, 38)], -// dtype=[('name', '|S10'), ('height', '>> np.sort(a, order=['age', 'height']) # doctest: +SKIP -// array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38), -// ('Arthur', 1.8, 41)], -// dtype=[('name', '|S10'), ('height', '>> a = np.array([[1, 2], [3, 4]]) -// >>> a -// array([[1, 2], -// [3, 4]]) -// >>> np.transpose(a) -// array([[1, 3], -// [2, 4]]) -// -// >>> a = np.array([1, 2, 3, 4]) -// >>> a -// array([1, 2, 3, 4]) -// >>> np.transpose(a) -// array([1, 2, 3, 4]) -// -// >>> a = np.ones((1, 2, 3)) -// >>> np.transpose(a, (1, 0, 2)).shape -// (2, 1, 3) -// -// >>> a = np.ones((2, 3, 4, 5)) -// >>> np.transpose(a).shape -// (5, 4, 3, 2) -// -// -// -//go:linkname Transpose py.transpose -func Transpose(a *py.Object, axes *py.Object) *py.Object -// -// Roll the specified axis backwards, until it lies in a given position. -// -// This function continues to be supported for backward compatibility, but you -// should prefer `moveaxis`. The `moveaxis` function was added in NumPy -// 1.11. -// -// Parameters -// ---------- -// a : ndarray -// Input array. -// axis : int -// The axis to be rolled. The positions of the other axes do not -// change relative to one another. -// start : int, optional -// When ``start <= axis``, the axis is rolled back until it lies in -// this position. When ``start > axis``, the axis is rolled until it -// lies before this position. The default, 0, results in a "complete" -// roll. The following table describes how negative values of ``start`` -// are interpreted: -// -// .. table:: -// :align: left -// -// +-------------------+----------------------+ -// | ``start`` | Normalized ``start`` | -// +===================+======================+ -// | ``-(arr.ndim+1)`` | raise ``AxisError`` | -// +-------------------+----------------------+ -// | ``-arr.ndim`` | 0 | -// +-------------------+----------------------+ -// | |vdots| | |vdots| | -// +-------------------+----------------------+ -// | ``-1`` | ``arr.ndim-1`` | -// +-------------------+----------------------+ -// | ``0`` | ``0`` | -// +-------------------+----------------------+ -// | |vdots| | |vdots| | -// +-------------------+----------------------+ -// | ``arr.ndim`` | ``arr.ndim`` | -// +-------------------+----------------------+ -// | ``arr.ndim + 1`` | raise ``AxisError`` | -// +-------------------+----------------------+ -// -// .. |vdots| unicode:: U+22EE .. Vertical Ellipsis -// -// Returns -// ------- -// res : ndarray -// For NumPy >= 1.10.0 a view of `a` is always returned. For earlier -// NumPy versions a view of `a` is returned only if the order of the -// axes is changed, otherwise the input array is returned. -// -// See Also -// -------- -// moveaxis : Move array axes to new positions. -// roll : Roll the elements of an array by a number of positions along a -// given axis. -// -// Examples -// -------- -// >>> a = np.ones((3,4,5,6)) -// >>> np.rollaxis(a, 3, 1).shape -// (3, 6, 4, 5) -// >>> np.rollaxis(a, 2).shape -// (5, 3, 4, 6) -// >>> np.rollaxis(a, 1, 4).shape -// (3, 5, 6, 4) -// -// -// -//go:linkname Rollaxis py.rollaxis -func Rollaxis(a *py.Object, axis *py.Object, start *py.Object) *py.Object -// -// Returns a boolean array where two arrays are element-wise equal within a -// tolerance. -// -// The tolerance values are positive, typically very small numbers. The -// relative difference (`rtol` * abs(`b`)) and the absolute difference -// `atol` are added together to compare against the absolute difference -// between `a` and `b`. -// -// .. warning:: The default `atol` is not appropriate for comparing numbers -// that are much smaller than one (see Notes). -// -// Parameters -// ---------- -// a, b : array_like -// Input arrays to compare. -// rtol : float -// The relative tolerance parameter (see Notes). -// atol : float -// The absolute tolerance parameter (see Notes). -// equal_nan : bool -// Whether to compare NaN's as equal. If True, NaN's in `a` will be -// considered equal to NaN's in `b` in the output array. -// -// Returns -// ------- -// y : array_like -// Returns a boolean array of where `a` and `b` are equal within the -// given tolerance. If both `a` and `b` are scalars, returns a single -// boolean value. -// -// See Also -// -------- -// allclose -// math.isclose -// -// Notes -// ----- -// .. versionadded:: 1.7.0 -// -// For finite values, isclose uses the following equation to test whether -// two floating point values are equivalent. -// -// absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`)) -// -// Unlike the built-in `math.isclose`, the above equation is not symmetric -// in `a` and `b` -- it assumes `b` is the reference value -- so that -// `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore, -// the default value of atol is not zero, and is used to determine what -// small values should be considered close to zero. The default value is -// appropriate for expected values of order unity: if the expected values -// are significantly smaller than one, it can result in false positives. -// `atol` should be carefully selected for the use case at hand. A zero value -// for `atol` will result in `False` if either `a` or `b` is zero. -// -// `isclose` is not defined for non-numeric data types. -// `bool` is considered a numeric data-type for this purpose. -// -// Examples -// -------- -// >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8]) -// array([ True, False]) -// >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9]) -// array([ True, True]) -// >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9]) -// array([False, True]) -// >>> np.isclose([1.0, np.nan], [1.0, np.nan]) -// array([ True, False]) -// >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) -// array([ True, True]) -// >>> np.isclose([1e-8, 1e-7], [0.0, 0.0]) -// array([ True, False]) -// >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0) -// array([False, False]) -// >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0]) -// array([ True, True]) -// >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0) -// array([False, True]) -// -// -//go:linkname Isclose py.isclose -func Isclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object -// -// Returns the indices of the minimum values along an axis. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// By default, the index is into the flattened array, otherwise -// along the specified axis. -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. -// 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 array. -// -// .. versionadded:: 1.22.0 -// -// Returns -// ------- -// index_array : ndarray of ints -// Array of indices into the array. It has the same shape as `a.shape` -// with the dimension along `axis` removed. If `keepdims` is set to True, -// then the size of `axis` will be 1 with the resulting array having same -// shape as `a.shape`. -// -// See Also -// -------- -// ndarray.argmin, argmax -// amin : The minimum value along a given axis. -// unravel_index : Convert a flat index into an index tuple. -// take_along_axis : Apply ``np.expand_dims(index_array, axis)`` -// from argmin to an array as if by calling min. -// -// Notes -// ----- -// In case of multiple occurrences of the minimum values, the indices -// corresponding to the first occurrence are returned. -// -// Examples -// -------- -// >>> a = np.arange(6).reshape(2,3) + 10 -// >>> a -// array([[10, 11, 12], -// [13, 14, 15]]) -// >>> np.argmin(a) -// 0 -// >>> np.argmin(a, axis=0) -// array([0, 0, 0]) -// >>> np.argmin(a, axis=1) -// array([0, 0]) -// -// Indices of the minimum elements of a N-dimensional array: -// -// >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape) -// >>> ind -// (0, 0) -// >>> a[ind] -// 10 -// -// >>> b = np.arange(6) + 10 -// >>> b[4] = 10 -// >>> b -// array([10, 11, 12, 13, 10, 15]) -// >>> np.argmin(b) # Only the first occurrence is returned. -// 0 -// -// >>> x = np.array([[4,2,3], [1,0,3]]) -// >>> index_array = np.argmin(x, axis=-1) -// >>> # Same as np.amin(x, axis=-1, keepdims=True) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) -// array([[2], -// [0]]) -// >>> # Same as np.amax(x, axis=-1) -// >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) -// array([2, 0]) -// -// Setting `keepdims` to `True`, -// -// >>> x = np.arange(24).reshape((2, 3, 4)) -// >>> res = np.argmin(x, axis=1, keepdims=True) -// >>> res.shape -// (2, 1, 4) -// -// -//go:linkname Argmin py.argmin -func Argmin(a *py.Object, axis *py.Object, out *py.Object) *py.Object -// -// Round an array to the given number of decimals. -// -// `around` is an alias of `~numpy.round`. -// -// See Also -// -------- -// ndarray.round : equivalent method -// round : alias for this function -// ceil, fix, floor, rint, trunc -// -// -// -//go:linkname Around py.around -func Around(a *py.Object, decimals *py.Object, out *py.Object) *py.Object -// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the absolute values element-wise. -// -// This function returns the absolute values (positive magnitude) of the -// data in `x`. Complex values are not handled, use `absolute` to find the -// absolute values of complex data. -// -// Parameters -// ---------- -// x : array_like -// The array of numbers for which the absolute values are required. If -// `x` is a scalar, the result `y` will also be a scalar. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The absolute values of `x`, the returned values are always floats. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// absolute : Absolute values including `complex` types. -// -// Examples -// -------- -// >>> np.fabs(-1) -// 1.0 -// >>> np.fabs([-1.2, 1.2]) -// array([ 1.2, 1.2]) -// -//go:linkname Fabs py.fabs -func Fabs(x *py.Object, out *py.Object) *py.Object -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the element-wise remainder of division. -// -// Computes the remainder complementary to the `floor_divide` function. It is -// equivalent to the Python modulus operator``x1 % x2`` and has the same sign -// as the divisor `x2`. The MATLAB function equivalent to ``np.remainder`` -// is ``mod``. -// -// .. warning:: -// -// This should not be confused with: -// -// * Python 3.7's `math.remainder` and C's ``remainder``, which -// computes the IEEE remainder, which are the complement to -// ``round(x1 / x2)``. -// * The MATLAB ``rem`` function and or the C ``%`` operator which is the -// complement to ``int(x1 / x2)``. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The element-wise remainder of the quotient ``floor_divide(x1, x2)``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// floor_divide : Equivalent of Python ``//`` operator. -// divmod : Simultaneous floor division and remainder. -// fmod : Equivalent of the MATLAB ``rem`` function. -// divide, floor -// -// Notes -// ----- -// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of) -// integers. -// ``mod`` is an alias of ``remainder``. -// -// Examples -// -------- -// >>> np.remainder([4, 7], [2, 3]) -// array([0, 1]) -// >>> np.remainder(np.arange(7), 5) -// array([0, 1, 2, 3, 4, 0, 1]) -// -// The ``%`` operator can be used as a shorthand for ``np.remainder`` on -// ndarrays. -// -// >>> x1 = np.arange(7) -// >>> x1 % 5 -// array([0, 1, 2, 3, 4, 0, 1]) -// -//go:linkname Mod py.mod -func Mod(__llgo_va_list ...interface{}) *py.Object -// asfortranarray(a, dtype=None, *, like=None) -// -// Return an array (ndim >= 1) laid out in Fortran order in memory. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// dtype : str or dtype object, optional -// By default, the data-type is inferred from the input data. -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// The input `a` in Fortran, or column-major, order. -// -// See Also -// -------- -// ascontiguousarray : Convert input to a contiguous (C order) array. -// asanyarray : Convert input to an ndarray with either row or -// column-major memory order. -// require : Return an ndarray that satisfies requirements. -// ndarray.flags : Information about the memory layout of the array. -// -// Examples -// -------- -// 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) -// >>> 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. -// -//go:linkname Asfortranarray py.asfortranarray -func Asfortranarray(a *py.Object, dtype *py.Object) *py.Object -// -// Return the number of dimensions of an array. -// -// Parameters -// ---------- -// a : array_like -// Input array. If it is not already an ndarray, a conversion is -// attempted. -// -// Returns -// ------- -// number_of_dimensions : int -// The number of dimensions in `a`. Scalars are zero-dimensional. -// -// See Also -// -------- -// ndarray.ndim : equivalent method -// shape : dimensions of array -// ndarray.shape : dimensions of array -// -// Examples -// -------- -// >>> np.ndim([[1,2,3],[4,5,6]]) -// 2 -// >>> np.ndim(np.array([[1,2,3],[4,5,6]])) -// 2 -// >>> np.ndim(1) -// 0 -// -// -// -//go:linkname Ndim py.ndim -func Ndim(a *py.Object) *py.Object -// lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns the lowest common multiple of ``|x1|`` and ``|x2|`` -// -// Parameters -// ---------- -// x1, x2 : array_like, int -// Arrays of values. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// Returns -// ------- -// y : ndarray or scalar -// The lowest common multiple of the absolute value of the inputs -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// gcd : The greatest common divisor -// -// Examples -// -------- -// >>> np.lcm(12, 20) -// 60 -// >>> np.lcm.reduce([3, 12, 20]) -// 60 -// >>> np.lcm.reduce([40, 12, 20]) -// 120 -// >>> np.lcm(np.arange(6), 20) -// array([ 0, 20, 20, 60, 20, 20]) -// -//go:linkname Lcm py.lcm -func Lcm(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the reciprocal of the argument, element-wise. -// -// Calculates ``1/x``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// Return array. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// .. note:: -// This function is not designed to work with integers. -// -// For integer arguments with absolute value larger than 1 the result is -// always zero because of the way Python handles integer division. For -// integer zero the result is an overflow. -// -// Examples -// -------- -// >>> np.reciprocal(2.) -// 0.5 -// >>> np.reciprocal([1, 2., 3.33]) -// array([ 1. , 0.5 , 0.3003003]) -// -//go:linkname Reciprocal py.reciprocal -func Reciprocal(x *py.Object, out *py.Object) *py.Object -// -// Integrate along the given axis using the composite trapezoidal rule. -// -// If `x` is provided, the integration happens in sequence along its -// elements - they are not sorted. -// -// Integrate `y` (`x`) along each 1d slice on the given axis, compute -// :math:`\int y(x) dx`. -// When `x` is specified, this integrates along the parametric curve, -// computing :math:`\int_t y(t) dt = -// \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`. -// -// Parameters -// ---------- -// y : array_like -// Input array to integrate. -// x : array_like, optional -// The sample points corresponding to the `y` values. If `x` is None, -// the sample points are assumed to be evenly spaced `dx` apart. The -// default is None. -// dx : scalar, optional -// The spacing between sample points when `x` is None. The default is 1. -// axis : int, optional -// The axis along which to integrate. -// -// 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. -// -// See Also -// -------- -// sum, cumsum -// -// Notes -// ----- -// Image [2]_ illustrates trapezoidal rule -- y-axis locations of points -// will be taken from `y` array, by default x-axis distances between -// points will be 1.0, alternatively they can be provided with `x` array -// or with `dx` scalar. Return value will be equal to combined area under -// the red lines. -// -// -// References -// ---------- -// .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule -// -// .. [2] Illustration image: -// https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png -// -// Examples -// -------- -// Use the trapezoidal rule on evenly spaced points: -// -// >>> np.trapz([1, 2, 3]) -// 4.0 -// -// The spacing between sample points can be selected by either the -// ``x`` or ``dx`` arguments: -// -// >>> np.trapz([1, 2, 3], x=[4, 6, 8]) -// 8.0 -// >>> np.trapz([1, 2, 3], dx=2) -// 8.0 -// -// Using a decreasing ``x`` corresponds to integrating in reverse: -// -// >>> np.trapz([1, 2, 3], x=[8, 6, 4]) -// -8.0 -// -// More generally ``x`` is used to integrate along a parametric curve. We can -// estimate the integral :math:`\int_0^1 x^2 = 1/3` using: -// -// >>> x = np.linspace(0, 1, num=50) -// >>> y = x**2 -// >>> np.trapz(y, x) -// 0.33340274885464394 -// -// Or estimate the area of a circle, noting we repeat the sample which closes -// the curve: -// -// >>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True) -// >>> np.trapz(np.cos(theta), x=np.sin(theta)) -// 3.141571941375841 -// -// ``np.trapz`` can be applied along a specified axis to do multiple -// computations in one call: -// -// >>> a = np.arange(6).reshape(2, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5]]) -// >>> np.trapz(a, axis=0) -// array([1.5, 2.5, 3.5]) -// >>> np.trapz(a, axis=1) -// array([2., 8.]) -// -// -//go:linkname Trapz py.trapz -func Trapz(y *py.Object, x *py.Object, dx *py.Object, axis *py.Object) *py.Object -// -// Reverse the order of elements along axis 1 (left/right). -// -// For a 2-D array, this flips the entries in each row in the left/right -// direction. Columns are preserved, but appear in a different order than -// before. -// -// Parameters -// ---------- -// m : array_like -// Input array, must be at least 2-D. -// -// Returns -// ------- -// f : ndarray -// A view of `m` with the columns reversed. Since a view -// is returned, this operation is :math:`\mathcal O(1)`. -// -// See Also -// -------- -// flipud : Flip array in the up/down direction. -// flip : Flip array in one or more dimensions. -// rot90 : Rotate array counterclockwise. -// -// Notes -// ----- -// Equivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``. -// Requires the array to be at least 2-D. -// -// Examples -// -------- -// >>> A = np.diag([1.,2.,3.]) -// >>> A -// array([[1., 0., 0.], -// [0., 2., 0.], -// [0., 0., 3.]]) -// >>> np.fliplr(A) -// array([[0., 0., 1.], -// [0., 2., 0.], -// [3., 0., 0.]]) -// -// >>> A = np.random.randn(2,3,5) -// >>> np.all(np.fliplr(A) == A[:,::-1,...]) -// True -// -// -// -//go:linkname Fliplr py.fliplr -func Fliplr(m *py.Object) *py.Object -// -// Issues a DeprecationWarning, adds warning to `old_name`'s -// docstring, rebinds ``old_name.__name__`` and returns the new -// function object. -// -// This function may also be used as a decorator. -// -// Parameters -// ---------- -// func : function -// The function to be deprecated. -// old_name : str, optional -// The name of the function to be deprecated. Default is None, in -// which case the name of `func` is used. -// new_name : str, optional -// The new name for the function. Default is None, in which case the -// deprecation message is that `old_name` is deprecated. If given, the -// deprecation message is that `old_name` is deprecated and `new_name` -// should be used instead. -// message : str, optional -// Additional explanation of the deprecation. Displayed in the -// docstring after the warning. -// -// Returns -// ------- -// old_func : function -// The deprecated function. -// -// Examples -// -------- -// Note that ``olduint`` returns a value after printing Deprecation -// Warning: -// -// >>> olduint = np.deprecate(np.uint) -// DeprecationWarning: `uint64` is deprecated! # may vary -// >>> olduint(6) -// 6 -// -// -// -//go:linkname Deprecate py.deprecate -func Deprecate(__llgo_va_list ...interface{}) *py.Object -// -// Find the intersection of two arrays. -// -// Return the sorted, unique values that are in both of the input arrays. -// -// Parameters -// ---------- -// ar1, ar2 : array_like -// Input arrays. Will be flattened if not already 1D. -// assume_unique : bool -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. If True but ``ar1`` or ``ar2`` are not -// unique, incorrect results and out-of-bounds indices could result. -// Default is False. -// return_indices : bool -// If True, the indices which correspond to the intersection of the two -// arrays are returned. The first instance of a value is used if there are -// multiple. Default is False. -// -// .. versionadded:: 1.15.0 -// -// Returns -// ------- -// intersect1d : ndarray -// Sorted 1D array of common and unique elements. -// comm1 : ndarray -// The indices of the first occurrences of the common values in `ar1`. -// Only provided if `return_indices` is True. -// comm2 : ndarray -// The indices of the first occurrences of the common values in `ar2`. -// Only provided if `return_indices` is True. -// -// -// See Also -// -------- -// numpy.lib.arraysetops : Module with a number of other functions for -// performing set operations on arrays. -// -// Examples -// -------- -// >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1]) -// array([1, 3]) -// -// To intersect more than two arrays, use functools.reduce: -// -// >>> from functools import reduce -// >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) -// array([3]) -// -// To return the indices of the values common to the input arrays -// along with the intersected values: -// -// >>> x = np.array([1, 1, 2, 3, 4]) -// >>> y = np.array([2, 1, 4, 6]) -// >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True) -// >>> x_ind, y_ind -// (array([0, 2, 4]), array([1, 0, 2])) -// >>> xy, x[x_ind], y[y_ind] -// (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4])) -// -// -// -//go:linkname Intersect1d py.intersect1d -func Intersect1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, returnIndices *py.Object) *py.Object -// -// min_scalar_type(a, /) -// -// For scalar ``a``, returns the data type with the smallest size -// and smallest scalar kind which can hold its value. For non-scalar -// array ``a``, returns the vector's dtype unmodified. -// -// Floating point values are not demoted to integers, -// and complex values are not demoted to floats. -// -// Parameters -// ---------- -// a : scalar or array_like -// The value whose minimal data type is to be found. -// -// Returns -// ------- -// out : dtype -// The minimal data type. -// -// Notes -// ----- -// .. versionadded:: 1.6.0 -// -// See Also -// -------- -// result_type, promote_types, dtype, can_cast -// -// Examples -// -------- -// >>> np.min_scalar_type(10) -// dtype('uint8') -// -// >>> np.min_scalar_type(-260) -// dtype('int16') -// -// >>> np.min_scalar_type(3.1) -// dtype('float16') -// -// >>> np.min_scalar_type(1e50) -// dtype('float64') -// -// >>> np.min_scalar_type(np.arange(4,dtype='f8')) -// dtype('float64') -// -// -// -//go:linkname MinScalarType py.min_scalar_type -func MinScalarType(a *py.Object) *py.Object -// -// Return the indices of the elements that are non-zero. -// -// Returns a tuple of arrays, one for each dimension of `a`, -// containing the indices of the non-zero elements in that -// dimension. The values in `a` are always tested and returned in -// row-major, C-style order. -// -// To group the indices by element, rather than dimension, use `argwhere`, -// which returns a row for each non-zero element. -// -// .. note:: -// -// When called on a zero-d array or scalar, ``nonzero(a)`` is treated -// as ``nonzero(atleast_1d(a))``. -// -// .. deprecated:: 1.17.0 -// -// Use `atleast_1d` explicitly if this behavior is deliberate. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// -// Returns -// ------- -// tuple_of_arrays : tuple -// Indices of elements that are non-zero. -// -// See Also -// -------- -// flatnonzero : -// Return indices that are non-zero in the flattened version of the input -// array. -// ndarray.nonzero : -// Equivalent ndarray method. -// count_nonzero : -// Counts the number of non-zero elements in the input array. -// -// Notes -// ----- -// While the nonzero values can be obtained with ``a[nonzero(a)]``, it is -// recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which -// will correctly handle 0-d arrays. -// -// Examples -// -------- -// >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]]) -// >>> x -// array([[3, 0, 0], -// [0, 4, 0], -// [5, 6, 0]]) -// >>> np.nonzero(x) -// (array([0, 1, 2, 2]), array([0, 1, 0, 1])) -// -// >>> x[np.nonzero(x)] -// array([3, 4, 5, 6]) -// >>> np.transpose(np.nonzero(x)) -// array([[0, 0], -// [1, 1], -// [2, 0], -// [2, 1]]) -// -// A common use for ``nonzero`` is to find the indices of an array, where -// a condition is True. Given an array `a`, the condition `a` > 3 is a -// boolean array and since False is interpreted as 0, np.nonzero(a > 3) -// yields the indices of the `a` where the condition is true. -// -// >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) -// >>> a > 3 -// array([[False, False, False], -// [ True, True, True], -// [ True, True, True]]) -// >>> np.nonzero(a > 3) -// (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) -// -// Using this result to index `a` is equivalent to using the mask directly: -// -// >>> a[np.nonzero(a > 3)] -// array([4, 5, 6, 7, 8, 9]) -// >>> a[a > 3] # prefer this spelling -// array([4, 5, 6, 7, 8, 9]) -// -// ``nonzero`` can also be called as a method of the array. -// -// >>> (a > 3).nonzero() -// (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) -// -// -// -//go:linkname Nonzero py.nonzero -func Nonzero(a *py.Object) *py.Object -// -// Compute the median along the specified axis, while ignoring NaNs. -// -// Returns the median of the array elements. -// -// .. versionadded:: 1.9.0 -// -// Parameters -// ---------- -// a : array_like -// Input array or object that can be converted to an array. -// axis : {int, sequence of int, None}, optional -// Axis or axes along which the medians are computed. The default -// is to compute the median along a flattened version of the array. -// A sequence of axes is supported since version 1.9.0. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow use of memory of input array `a` for -// calculations. The input array will be modified by the call to -// `median`. This will save memory when you do not need to preserve -// the contents of the input array. Treat the input as undefined, -// but it will probably be fully or partially sorted. Default is -// False. If `overwrite_input` is ``True`` and `a` is not already an -// `ndarray`, an error will be raised. -// 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`. -// -// If this is anything but the default value it will be passed -// through (in the special case of an empty array) to the -// `mean` function of the underlying array. If the array is -// a sub-class and `mean` does not have the kwarg `keepdims` this -// will raise a RuntimeError. -// -// Returns -// ------- -// median : ndarray -// A new array holding the result. If the input contains integers -// or floats smaller than ``float64``, then the output data-type is -// ``np.float64``. Otherwise, the data-type of the output is the -// same as that of the input. If `out` is specified, that array is -// returned instead. -// -// See Also -// -------- -// mean, median, percentile -// -// Notes -// ----- -// Given a vector ``V`` of length ``N``, the median of ``V`` is the -// middle value of a sorted copy of ``V``, ``V_sorted`` - i.e., -// ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two -// middle values of ``V_sorted`` when ``N`` is even. -// -// Examples -// -------- -// >>> a = np.array([[10.0, 7, 4], [3, 2, 1]]) -// >>> a[0, 1] = np.nan -// >>> a -// array([[10., nan, 4.], -// [ 3., 2., 1.]]) -// >>> np.median(a) -// nan -// >>> np.nanmedian(a) -// 3.0 -// >>> np.nanmedian(a, axis=0) -// array([6.5, 2. , 2.5]) -// >>> np.median(a, axis=1) -// array([nan, 2.]) -// >>> b = a.copy() -// >>> np.nanmedian(b, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a==b) -// >>> b = a.copy() -// >>> np.nanmedian(b, axis=None, overwrite_input=True) -// 3.0 -// >>> assert not np.all(a==b) -// -// -// -//go:linkname Nanmedian py.nanmedian -func Nanmedian(a *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, keepdims *py.Object) *py.Object -// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the element-wise square of the input. -// -// Parameters -// ---------- -// x : array_like -// Input data. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise `x*x`, of the same shape and dtype as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// numpy.linalg.matrix_power -// sqrt -// power -// -// Examples -// -------- -// >>> np.square([-1j, 1]) -// array([-1.-0.j, 1.+0.j]) -// -//go:linkname Square py.square -func Square(x *py.Object, out *py.Object) *py.Object -// -// Construct an open mesh from multiple sequences. -// -// This function takes N 1-D sequences and returns N outputs with N -// dimensions each, such that the shape is 1 in all but one dimension -// and the dimension with the non-unit shape value cycles through all -// N dimensions. -// -// Using `ix_` one can quickly construct index arrays that will index -// the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array -// ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``. -// -// Parameters -// ---------- -// args : 1-D sequences -// Each sequence should be of integer or boolean type. -// Boolean sequences will be interpreted as boolean masks for the -// corresponding dimension (equivalent to passing in -// ``np.nonzero(boolean_sequence)``). -// -// Returns -// ------- -// out : tuple of ndarrays -// N arrays with N dimensions each, with N the number of input -// sequences. Together these arrays form an open mesh. -// -// See Also -// -------- -// ogrid, mgrid, meshgrid -// -// Examples -// -------- -// >>> a = np.arange(10).reshape(2, 5) -// >>> a -// array([[0, 1, 2, 3, 4], -// [5, 6, 7, 8, 9]]) -// >>> ixgrid = np.ix_([0, 1], [2, 4]) -// >>> ixgrid -// (array([[0], -// [1]]), array([[2, 4]])) -// >>> ixgrid[0].shape, ixgrid[1].shape -// ((2, 1), (1, 2)) -// >>> a[ixgrid] -// array([[2, 4], -// [7, 9]]) -// -// >>> ixgrid = np.ix_([True, True], [2, 4]) -// >>> a[ixgrid] -// array([[2, 4], -// [7, 9]]) -// >>> ixgrid = np.ix_([True, True], [False, False, True, False, True]) -// >>> a[ixgrid] -// array([[2, 4], -// [7, 9]]) -// -// -// -//go:linkname Ix_ py.ix_ -func Ix_(__llgo_va_list ...interface{}) *py.Object -// -// Return the normalized sinc function. -// -// 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. -// -// Parameters -// ---------- -// x : ndarray -// Array (possibly multi-dimensional) of values for which to calculate -// ``sinc(x)``. -// -// Returns -// ------- -// out : ndarray -// ``sinc(x)``, which has the same shape as the input. -// -// Notes -// ----- -// The name sinc is short for "sine cardinal" or "sinus cardinalis". -// -// The sinc function is used in various signal processing applications, -// including in anti-aliasing, in the construction of a Lanczos resampling -// filter, and in interpolation. -// -// For bandlimited interpolation of discrete-time signals, the ideal -// interpolation kernel is proportional to the sinc function. -// -// References -// ---------- -// .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web -// Resource. http://mathworld.wolfram.com/SincFunction.html -// .. [2] Wikipedia, "Sinc function", -// https://en.wikipedia.org/wiki/Sinc_function -// -// Examples -// -------- -// >>> import matplotlib.pyplot as plt -// >>> x = np.linspace(-4, 4, 41) -// >>> np.sinc(x) -// array([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary -// -8.90384387e-02, -5.84680802e-02, 3.89804309e-17, -// 6.68206631e-02, 1.16434881e-01, 1.26137788e-01, -// 8.50444803e-02, -3.89804309e-17, -1.03943254e-01, -// -1.89206682e-01, -2.16236208e-01, -1.55914881e-01, -// 3.89804309e-17, 2.33872321e-01, 5.04551152e-01, -// 7.56826729e-01, 9.35489284e-01, 1.00000000e+00, -// 9.35489284e-01, 7.56826729e-01, 5.04551152e-01, -// 2.33872321e-01, 3.89804309e-17, -1.55914881e-01, -// -2.16236208e-01, -1.89206682e-01, -1.03943254e-01, -// -3.89804309e-17, 8.50444803e-02, 1.26137788e-01, -// 1.16434881e-01, 6.68206631e-02, 3.89804309e-17, -// -5.84680802e-02, -8.90384387e-02, -8.40918587e-02, -// -4.92362781e-02, -3.89804309e-17]) -// -// >>> plt.plot(x, np.sinc(x)) -// [] -// >>> plt.title("Sinc Function") -// Text(0.5, 1.0, 'Sinc Function') -// >>> plt.ylabel("Amplitude") -// Text(0, 0.5, 'Amplitude') -// >>> plt.xlabel("X") -// Text(0.5, 0, 'X') -// >>> plt.show() -// -// -// -//go:linkname Sinc py.sinc -func Sinc(x *py.Object) *py.Object -// -// Return the roots of a polynomial with coefficients given in p. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// The values in the rank-1 array `p` are coefficients of a polynomial. -// If the length of `p` is n+1 then the polynomial is described by:: -// -// p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n] -// -// Parameters -// ---------- -// p : array_like -// Rank-1 array of polynomial coefficients. -// -// Returns -// ------- -// out : ndarray -// An array containing the roots of the polynomial. -// -// Raises -// ------ -// ValueError -// When `p` cannot be converted to a rank-1 array. -// -// See also -// -------- -// poly : Find the coefficients of a polynomial with a given sequence -// of roots. -// polyval : Compute polynomial values. -// polyfit : Least squares polynomial fit. -// poly1d : A one-dimensional polynomial class. -// -// Notes -// ----- -// The algorithm relies on computing the eigenvalues of the -// companion matrix [1]_. -// -// References -// ---------- -// .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*. Cambridge, UK: -// Cambridge University Press, 1999, pp. 146-7. -// -// Examples -// -------- -// >>> coeff = [3.2, 2, 1] -// >>> np.roots(coeff) -// array([-0.3125+0.46351241j, -0.3125-0.46351241j]) -// -// -// -//go:linkname Roots py.roots -func Roots(p *py.Object) *py.Object -// nested_iters(op, axes, flags=None, op_flags=None, op_dtypes=None, order="K", casting="safe", buffersize=0) -// -// Create nditers for use in nested loops -// -// Create a tuple of `nditer` objects which iterate in nested loops over -// different axes of the op argument. The first iterator is used in the -// outermost loop, the last in the innermost loop. Advancing one will change -// the subsequent iterators to point at its new element. -// -// Parameters -// ---------- -// op : ndarray or sequence of array_like -// The array(s) to iterate over. -// -// axes : list of list of int -// Each item is used as an "op_axes" argument to an nditer -// -// flags, op_flags, op_dtypes, order, casting, buffersize (optional) -// See `nditer` parameters of the same name -// -// Returns -// ------- -// iters : tuple of nditer -// An nditer for each item in `axes`, outermost first -// -// See Also -// -------- -// nditer -// -// Examples -// -------- -// -// Basic usage. Note how y is the "flattened" version of -// [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified -// the first iter's axes as [1] -// -// >>> a = np.arange(12).reshape(2, 3, 2) -// >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=["multi_index"]) -// >>> for x in i: -// ... print(i.multi_index) -// ... for y in j: -// ... print('', j.multi_index, y) -// (0,) -// (0, 0) 0 -// (0, 1) 1 -// (1, 0) 6 -// (1, 1) 7 -// (1,) -// (0, 0) 2 -// (0, 1) 3 -// (1, 0) 8 -// (1, 1) 9 -// (2,) -// (0, 0) 4 -// (0, 1) 5 -// (1, 0) 10 -// (1, 1) 11 -// -//go:linkname NestedIters py.nested_iters -func NestedIters(op *py.Object, axes *py.Object, flags *py.Object, opFlags *py.Object, opDtypes *py.Object, order *py.Object, casting *py.Object, buffersize *py.Object) *py.Object -// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Inverse hyperbolic tangent element-wise. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// emath.arctanh -// -// Notes -// ----- -// `arctanh` is a multivalued function: for each `x` there are infinitely -// many numbers `z` such that ``tanh(z) = x``. The convention is to return -// the `z` whose imaginary part lies in `[-pi/2, pi/2]`. -// -// For real-valued input data types, `arctanh` always returns real output. -// For each value that cannot be expressed as a real number or infinity, -// it yields ``nan`` and sets the `invalid` floating point error flag. -// -// For complex-valued input, `arctanh` is a complex analytical function -// that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from -// above on the former and from below on the latter. -// -// The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``. -// -// References -// ---------- -// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", -// 10th printing, 1964, pp. 86. -// https://personal.math.ubc.ca/~cbm/aands/page_86.htm -// .. [2] Wikipedia, "Inverse hyperbolic function", -// https://en.wikipedia.org/wiki/Arctanh -// -// Examples -// -------- -// >>> np.arctanh([0, -0.5]) -// array([ 0. , -0.54930614]) -// -//go:linkname Arctanh py.arctanh -func Arctanh(x *py.Object, out *py.Object) *py.Object -// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns element-wise True where signbit is set (less than zero). -// -// Parameters -// ---------- -// x : array_like -// The input value(s). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// result : ndarray of bool -// Output array, or reference to `out` if that was supplied. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> np.signbit(-1.2) -// True -// >>> np.signbit(np.array([1, -2.3, 2.1])) -// array([False, True, False]) -// -//go:linkname Signbit py.signbit -func Signbit(x *py.Object, out *py.Object) *py.Object -// -// Change elements of an array based on conditional and input values. -// -// Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that -// `place` uses the first N elements of `vals`, where N is the number of -// True values in `mask`, while `copyto` uses the elements where `mask` -// is True. -// -// Note that `extract` does the exact opposite of `place`. -// -// Parameters -// ---------- -// arr : ndarray -// Array to put data into. -// mask : array_like -// Boolean mask array. Must have the same size as `a`. -// vals : 1-D sequence -// Values to put into `a`. Only the first N elements are used, where -// N is the number of True values in `mask`. If `vals` is smaller -// than N, it will be repeated, and if elements of `a` are to be masked, -// this sequence must be non-empty. -// -// See Also -// -------- -// copyto, put, take, extract -// -// Examples -// -------- -// >>> arr = np.arange(6).reshape(2, 3) -// >>> np.place(arr, arr>2, [44, 55]) -// >>> arr -// array([[ 0, 1, 2], -// [44, 55, 44]]) -// -// -// -//go:linkname Place py.place -func Place(arr *py.Object, mask *py.Object, vals *py.Object) *py.Object -// -// Returns True if the type of `element` is a scalar type. -// -// Parameters -// ---------- -// element : any -// Input argument, can be of any type and shape. -// -// Returns -// ------- -// val : bool -// True if `element` is a scalar type, False if it is not. -// -// See Also -// -------- -// ndim : Get the number of dimensions of an array -// -// Notes -// ----- -// If you need a stricter way to identify a *numerical* scalar, use -// ``isinstance(x, numbers.Number)``, as that returns ``False`` for most -// non-numerical elements such as strings. -// -// In most cases ``np.ndim(x) == 0`` should be used instead of this function, -// as that will also return true for 0d arrays. This is how numpy overloads -// functions in the style of the ``dx`` arguments to `gradient` and the ``bins`` -// argument to `histogram`. Some key differences: -// -// +--------------------------------------+---------------+-------------------+ -// | x |``isscalar(x)``|``np.ndim(x) == 0``| -// +======================================+===============+===================+ -// | PEP 3141 numeric objects (including | ``True`` | ``True`` | -// | builtins) | | | -// +--------------------------------------+---------------+-------------------+ -// | builtin string and buffer objects | ``True`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other builtin objects, like | ``False`` | ``True`` | -// | `pathlib.Path`, `Exception`, | | | -// | the result of `re.compile` | | | -// +--------------------------------------+---------------+-------------------+ -// | third-party objects like | ``False`` | ``True`` | -// | `matplotlib.figure.Figure` | | | -// +--------------------------------------+---------------+-------------------+ -// | zero-dimensional numpy arrays | ``False`` | ``True`` | -// +--------------------------------------+---------------+-------------------+ -// | other numpy arrays | ``False`` | ``False`` | -// +--------------------------------------+---------------+-------------------+ -// | `list`, `tuple`, and other sequence | ``False`` | ``False`` | -// | objects | | | -// +--------------------------------------+---------------+-------------------+ -// -// Examples -// -------- -// >>> np.isscalar(3.1) -// True -// >>> np.isscalar(np.array(3.1)) -// False -// >>> np.isscalar([3.1]) -// False -// >>> np.isscalar(False) -// True -// >>> np.isscalar('numpy') -// True -// -// NumPy supports PEP 3141 numbers: -// -// >>> from fractions import Fraction -// >>> np.isscalar(Fraction(5, 17)) -// True -// >>> from numbers import Number -// >>> np.isscalar(Number()) -// True -// -// -// -//go:linkname Isscalar py.isscalar -func Isscalar(element *py.Object) *py.Object -// left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Shift the bits of an integer to the left. -// -// Bits are shifted to the left by appending `x2` 0s at the right of `x1`. -// Since the internal representation of numbers is in binary format, this -// operation is equivalent to multiplying `x1` by ``2**x2``. -// -// Parameters -// ---------- -// x1 : array_like of integer type -// Input values. -// x2 : array_like of integer type -// Number of zeros to append to `x1`. Has to be non-negative. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : array of integer type -// Return `x1` with bits shifted `x2` times to the left. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// right_shift : Shift the bits of an integer to the right. -// binary_repr : Return the binary representation of the input number -// as a string. -// -// Examples -// -------- -// >>> np.binary_repr(5) -// '101' -// >>> np.left_shift(5, 2) -// 20 -// >>> np.binary_repr(20) -// '10100' -// -// >>> np.left_shift(5, [1,2,3]) -// array([10, 20, 40]) -// -// Note that the dtype of the second argument may change the dtype of the -// result and can lead to unexpected results in some cases (see -// :ref:`Casting Rules `): -// -// >>> a = np.left_shift(np.uint8(255), 1) # Expect 254 -// >>> print(a, type(a)) # Unexpected result due to upcasting -// 510 -// >>> b = np.left_shift(np.uint8(255), np.uint8(1)) -// >>> print(b, type(b)) -// 254 -// -// The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on -// ndarrays. -// -// >>> x1 = 5 -// >>> x2 = np.array([1, 2, 3]) -// >>> x1 << x2 -// array([10, 20, 40]) -// -//go:linkname LeftShift py.left_shift -func LeftShift(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return (x1 != x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// equal, greater, greater_equal, less, less_equal -// -// Examples -// -------- -// >>> np.not_equal([1.,2.], [1., 3.]) -// array([False, True]) -// >>> np.not_equal([1, 2], [[1, 3],[1, 4]]) -// array([[False, True], -// [False, True]]) -// -// The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on -// ndarrays. -// -// >>> a = np.array([1., 2.]) -// >>> b = np.array([1., 3.]) -// >>> a != b -// array([False, True]) -// -//go:linkname NotEqual py.not_equal -func NotEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// seterrobj(errobj, /) -// -// Set the object that defines floating-point error handling. -// -// The error object contains all information that defines the error handling -// behavior in NumPy. `seterrobj` is used internally by the other -// functions that set error handling behavior (`seterr`, `seterrcall`). -// -// Parameters -// ---------- -// errobj : list -// The error object, a list containing three elements: -// [internal numpy buffer size, error mask, error callback function]. -// -// The error mask is a single integer that holds the treatment information -// on all four floating point errors. The information for each error type -// is contained in three bits of the integer. If we print it in base 8, we -// can see what treatment is set for "invalid", "under", "over", and -// "divide" (in that order). The printed string can be interpreted with -// -// * 0 : 'ignore' -// * 1 : 'warn' -// * 2 : 'raise' -// * 3 : 'call' -// * 4 : 'print' -// * 5 : 'log' -// -// See Also -// -------- -// geterrobj, seterr, geterr, seterrcall, geterrcall -// getbufsize, setbufsize -// -// Notes -// ----- -// For complete documentation of the types of floating-point exceptions and -// treatment options, see `seterr`. -// -// Examples -// -------- -// >>> old_errobj = np.geterrobj() # first get the defaults -// >>> old_errobj -// [8192, 521, None] -// -// >>> def err_handler(type, flag): -// ... print("Floating point error (%s), with flag %s" % (type, flag)) -// ... -// >>> new_errobj = [20000, 12, err_handler] -// >>> np.seterrobj(new_errobj) -// >>> np.base_repr(12, 8) # int for divide=4 ('print') and over=1 ('warn') -// '14' -// >>> np.geterr() -// {'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'} -// >>> np.geterrcall() is err_handler -// True -// -//go:linkname Seterrobj py.seterrobj -func Seterrobj(errobj *py.Object) *py.Object -// -// Return the scalar dtype or NumPy equivalent of Python type of an object. -// -// Parameters -// ---------- -// rep : any -// The object of which the type is returned. -// default : any, optional -// If given, this is returned for objects whose types can not be -// determined. If not given, None is returned for those objects. -// -// Returns -// ------- -// dtype : dtype or Python type -// The data type of `rep`. -// -// See Also -// -------- -// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype -// -// Examples -// -------- -// >>> np.obj2sctype(np.int32) -// -// >>> np.obj2sctype(np.array([1., 2.])) -// -// >>> np.obj2sctype(np.array([1.j])) -// -// -// >>> np.obj2sctype(dict) -// -// >>> np.obj2sctype('string') -// -// >>> np.obj2sctype(1, default=list) -// -// -// -// -//go:linkname Obj2sctype py.obj2sctype -func Obj2sctype(rep *py.Object, Default *py.Object) *py.Object -// -// einsum_path(subscripts, *operands, optimize='greedy') -// -// Evaluates the lowest cost contraction order for an einsum expression by -// considering the creation of intermediate arrays. -// -// Parameters -// ---------- -// subscripts : str -// Specifies the subscripts for summation. -// *operands : list of array_like -// These are the arrays for the operation. -// optimize : {bool, list, tuple, 'greedy', 'optimal'} -// Choose the type of path. If a tuple is provided, the second argument is -// assumed to be the maximum intermediate size created. If only a single -// argument is provided the largest input or output array size is used -// as a maximum intermediate size. -// -// * if a list is given that starts with ``einsum_path``, uses this as the -// contraction path -// * if False no optimization is taken -// * if True defaults to the 'greedy' algorithm -// * 'optimal' An algorithm that combinatorially explores all possible -// ways of contracting the listed tensors and chooses the least costly -// path. Scales exponentially with the number of terms in the -// contraction. -// * 'greedy' An algorithm that chooses the best pair contraction -// at each step. Effectively, this algorithm searches the largest inner, -// Hadamard, and then outer products at each step. Scales cubically with -// the number of terms in the contraction. Equivalent to the 'optimal' -// path for most contractions. -// -// Default is 'greedy'. -// -// Returns -// ------- -// path : list of tuples -// A list representation of the einsum path. -// string_repr : str -// A printable representation of the einsum path. -// -// Notes -// ----- -// The resulting path indicates which terms of the input contraction should be -// contracted first, the result of this contraction is then appended to the -// end of the contraction list. This list can then be iterated over until all -// intermediate contractions are complete. -// -// See Also -// -------- -// einsum, linalg.multi_dot -// -// Examples -// -------- -// -// We can begin with a chain dot example. In this case, it is optimal to -// contract the ``b`` and ``c`` tensors first as represented by the first -// element of the path ``(1, 2)``. The resulting tensor is added to the end -// of the contraction and the remaining contraction ``(0, 1)`` is then -// completed. -// -// >>> np.random.seed(123) -// >>> a = np.random.rand(2, 2) -// >>> b = np.random.rand(2, 5) -// >>> c = np.random.rand(5, 2) -// >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy') -// >>> print(path_info[0]) -// ['einsum_path', (1, 2), (0, 1)] -// >>> print(path_info[1]) -// Complete contraction: ij,jk,kl->il # may vary -// Naive scaling: 4 -// Optimized scaling: 3 -// Naive FLOP count: 1.600e+02 -// Optimized FLOP count: 5.600e+01 -// Theoretical speedup: 2.857 -// Largest intermediate: 4.000e+00 elements -// ------------------------------------------------------------------------- -// scaling current remaining -// ------------------------------------------------------------------------- -// 3 kl,jk->jl ij,jl->il -// 3 jl,ij->il il->il -// -// -// A more complex index transformation example. -// -// >>> I = np.random.rand(10, 10, 10, 10) -// >>> C = np.random.rand(10, 10) -// >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C, -// ... optimize='greedy') -// -// >>> print(path_info[0]) -// ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)] -// >>> print(path_info[1]) -// Complete contraction: ea,fb,abcd,gc,hd->efgh # may vary -// Naive scaling: 8 -// Optimized scaling: 5 -// Naive FLOP count: 8.000e+08 -// Optimized FLOP count: 8.000e+05 -// Theoretical speedup: 1000.000 -// Largest intermediate: 1.000e+04 elements -// -------------------------------------------------------------------------- -// scaling current remaining -// -------------------------------------------------------------------------- -// 5 abcd,ea->bcde fb,gc,hd,bcde->efgh -// 5 bcde,fb->cdef gc,hd,cdef->efgh -// 5 cdef,gc->defg hd,defg->efgh -// 5 defg,hd->efgh efgh->efgh -// -// -//go:linkname EinsumPath py.einsum_path -func EinsumPath(__llgo_va_list ...interface{}) *py.Object -// -// Unwrap by taking the complement of large deltas with respect to the period. -// -// This unwraps a signal `p` by changing elements which have an absolute -// difference from their predecessor of more than ``max(discont, period/2)`` -// to their `period`-complementary values. -// -// For the default case where `period` is :math:`2\pi` and `discont` is -// :math:`\pi`, this unwraps a radian phase `p` such that adjacent differences -// are never greater than :math:`\pi` by adding :math:`2k\pi` for some -// integer :math:`k`. -// -// Parameters -// ---------- -// p : array_like -// Input array. -// discont : float, optional -// Maximum discontinuity between values, default is ``period/2``. -// Values below ``period/2`` are treated as if they were ``period/2``. -// To have an effect different from the default, `discont` should be -// larger than ``period/2``. -// axis : int, optional -// Axis along which unwrap will operate, default is the last axis. -// period : float, optional -// Size of the range over which the input wraps. By default, it is -// ``2 pi``. -// -// .. versionadded:: 1.21.0 -// -// Returns -// ------- -// out : ndarray -// Output array. -// -// See Also -// -------- -// rad2deg, deg2rad -// -// Notes -// ----- -// If the discontinuity in `p` is smaller than ``period/2``, -// but larger than `discont`, no unwrapping is done because taking -// the complement would only make the discontinuity larger. -// -// Examples -// -------- -// >>> phase = np.linspace(0, np.pi, num=5) -// >>> phase[3:] += np.pi -// >>> phase -// array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) # may vary -// >>> np.unwrap(phase) -// array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) # may vary -// >>> np.unwrap([0, 1, 2, -1, 0], period=4) -// array([0, 1, 2, 3, 4]) -// >>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6) -// array([1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4) -// array([2, 3, 4, 5, 6, 7, 8, 9]) -// >>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180 -// >>> np.unwrap(phase_deg, period=360) -// array([-180., -140., -100., -60., -20., 20., 60., 100., 140., -// 180., 220., 260., 300., 340., 380., 420., 460., 500., -// 540.]) -// -// -//go:linkname Unwrap py.unwrap -func Unwrap(p *py.Object, discont *py.Object, axis *py.Object) *py.Object -// -// Function to calculate only the edges of the bins used by the `histogram` -// function. -// -// Parameters -// ---------- -// a : array_like -// Input data. The histogram is computed over the flattened array. -// bins : int or sequence of scalars or str, optional -// If `bins` is an int, it defines the number of equal-width -// bins in the given range (10, by default). If `bins` is a -// sequence, it defines the bin edges, including the rightmost -// edge, allowing for non-uniform bin widths. -// -// If `bins` is a string from the list below, `histogram_bin_edges` will use -// the method chosen to calculate the optimal bin width and -// consequently the number of bins (see `Notes` for more detail on -// the estimators) from the data that falls within the requested -// range. While the bin width will be optimal for the actual data -// in the range, the number of bins will be computed to fill the -// entire range, including the empty portions. For visualisation, -// using the 'auto' option is suggested. Weighted data is not -// supported for automated bin size selection. -// -// 'auto' -// Maximum of the 'sturges' and 'fd' estimators. Provides good -// all around performance. -// -// 'fd' (Freedman Diaconis Estimator) -// Robust (resilient to outliers) estimator that takes into -// account data variability and data size. -// -// 'doane' -// An improved version of Sturges' estimator that works better -// with non-normal datasets. -// -// 'scott' -// Less robust estimator that takes into account data variability -// and data size. -// -// 'stone' -// Estimator based on leave-one-out cross-validation estimate of -// the integrated squared error. Can be regarded as a generalization -// of Scott's rule. -// -// 'rice' -// Estimator does not take variability into account, only data -// size. Commonly overestimates number of bins required. -// -// 'sturges' -// R's default method, only accounts for data size. Only -// optimal for gaussian data and underestimates number of bins -// for large non-gaussian datasets. -// -// 'sqrt' -// Square root (of data size) estimator, used by Excel and -// other programs for its speed and simplicity. -// -// range : (float, float), optional -// The lower and upper range of the bins. If not provided, range -// is simply ``(a.min(), a.max())``. Values outside the range are -// ignored. The first element of the range must be less than or -// equal to the second. `range` affects the automatic bin -// 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. -// -// 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 -// (instead of 1). This is currently not used by any of the bin estimators, -// but may be in the future. -// -// Returns -// ------- -// bin_edges : array of dtype float -// The edges to pass into `histogram` -// -// See Also -// -------- -// histogram -// -// Notes -// ----- -// The methods to estimate the optimal number of bins are well founded -// in literature, and are inspired by the choices R provides for -// histogram visualisation. Note that having the number of bins -// proportional to :math:`n^{1/3}` is asymptotically optimal, which is -// why it appears in most estimators. These are simply plug-in methods -// that give good starting points for number of bins. In the equations -// 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 -// than what is returned by the estimators below. -// -// 'auto' (maximum of the 'sturges' and 'fd' estimators) -// A compromise to get a good value. For small datasets the Sturges -// value will usually be chosen, while larger datasets will usually -// default to FD. Avoids the overly conservative behaviour of FD -// and Sturges for small and large datasets respectively. -// Switchover point is usually :math:`a.size \approx 1000`. -// -// 'fd' (Freedman Diaconis Estimator) -// .. math:: h = 2 \frac{IQR}{n^{1/3}} -// -// The binwidth is proportional to the interquartile range (IQR) -// and inversely proportional to cube root of a.size. Can be too -// conservative for small datasets, but is quite good for large -// datasets. The IQR is very robust to outliers. -// -// 'scott' -// .. 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 -// be too conservative for small datasets, but is quite good for -// large datasets. The standard deviation is not very robust to -// outliers. Values are very similar to the Freedman-Diaconis -// estimator in the absence of outliers. -// -// 'rice' -// .. math:: n_h = 2n^{1/3} -// -// The number of bins is only proportional to cube root of -// ``a.size``. It tends to overestimate the number of bins and it -// does not take into account data variability. -// -// 'sturges' -// .. 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 -// larger, non-normal datasets. This is the default method in R's -// ``hist`` method. -// -// 'doane' -// .. math:: n_h = 1 + \log_{2}(n) + -// \log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right) -// -// g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right] -// -// \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}} -// -// An improved version of Sturges' formula that produces better -// estimates for non-normal datasets. This estimator attempts to -// account for the skew of the data. -// -// 'sqrt' -// .. math:: n_h = \sqrt n -// -// The simplest and fastest estimator. Only takes into account the -// data size. -// -// Examples -// -------- -// >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]) -// >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1)) -// array([0. , 0.25, 0.5 , 0.75, 1. ]) -// >>> np.histogram_bin_edges(arr, bins=2) -// array([0. , 2.5, 5. ]) -// -// For consistency with histogram, an array of pre-computed bins is -// passed through unmodified: -// -// >>> np.histogram_bin_edges(arr, [1, 2]) -// array([1, 2]) -// -// This function allows one set of bins to be computed, and reused across -// multiple histograms: -// -// >>> shared_bins = np.histogram_bin_edges(arr, bins='auto') -// >>> shared_bins -// array([0., 1., 2., 3., 4., 5.]) -// -// >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1]) -// >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins) -// >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins) -// -// >>> hist_0; hist_1 -// array([1, 1, 0, 1, 0]) -// array([2, 0, 1, 1, 2]) -// -// Which gives more easily comparable results than using separate bins for -// each histogram: -// -// >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto') -// >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto') -// >>> hist_0; hist_1 -// array([1, 1, 1]) -// array([2, 1, 1, 2]) -// >>> bins_0; bins_1 -// array([0., 1., 2., 3.]) -// array([0. , 1.25, 2.5 , 3.75, 5. ]) -// -// -// -//go:linkname HistogramBinEdges py.histogram_bin_edges -func HistogramBinEdges(a *py.Object, bins *py.Object, Range *py.Object, weights *py.Object) *py.Object -// -// shares_memory(a, b, /, max_work=None) -// -// Determine if two arrays share memory. -// -// .. warning:: -// -// This function can be exponentially slow for some inputs, unless -// `max_work` is set to a finite number or ``MAY_SHARE_BOUNDS``. -// If in doubt, use `numpy.may_share_memory` instead. -// -// Parameters -// ---------- -// a, b : ndarray -// Input arrays -// max_work : int, optional -// Effort to spend on solving the overlap problem (maximum number -// of candidate solutions to consider). The following special -// values are recognized: -// -// max_work=MAY_SHARE_EXACT (default) -// The problem is solved exactly. In this case, the function returns -// True only if there is an element shared between the arrays. Finding -// the exact solution may take extremely long in some cases. -// max_work=MAY_SHARE_BOUNDS -// Only the memory bounds of a and b are checked. -// -// Raises -// ------ -// numpy.exceptions.TooHardError -// Exceeded max_work. -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// may_share_memory -// -// Examples -// -------- -// >>> x = np.array([1, 2, 3, 4]) -// >>> np.shares_memory(x, np.array([5, 6, 7])) -// False -// >>> np.shares_memory(x[::2], x) -// True -// >>> np.shares_memory(x[::2], x[1::2]) -// False -// -// Checking whether two arrays share memory is NP-complete, and -// runtime may increase exponentially in the number of -// dimensions. Hence, `max_work` should generally be set to a finite -// number, as it is possible to construct examples that take -// extremely long to run: -// -// >>> from numpy.lib.stride_tricks import as_strided -// >>> x = np.zeros([192163377], dtype=np.int8) -// >>> x1 = as_strided(x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049)) -// >>> x2 = as_strided(x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1)) -// >>> np.shares_memory(x1, x2, max_work=1000) -// Traceback (most recent call last): -// ... -// numpy.exceptions.TooHardError: Exceeded max_work -// -// Running ``np.shares_memory(x1, x2)`` without `max_work` set takes -// around 1 minute for this case. It is possible to find problems -// that take still significantly longer. -// -// -// -//go:linkname SharesMemory py.shares_memory -func SharesMemory(a *py.Object, b *py.Object, maxWork *py.Object) *py.Object -// -// Return evenly spaced numbers over a specified interval. -// -// Returns `num` evenly spaced samples, calculated over the -// interval [`start`, `stop`]. -// -// The endpoint of the interval can optionally be excluded. -// -// .. versionchanged:: 1.16.0 -// Non-scalar `start` and `stop` are now supported. -// -// .. versionchanged:: 1.20.0 -// Values are rounded towards ``-inf`` instead of ``0`` when an -// integer ``dtype`` is specified. The old behavior can -// still be obtained with ``np.linspace(start, stop, num).astype(int)`` -// -// Parameters -// ---------- -// start : array_like -// The starting value of the sequence. -// stop : array_like -// The end value of the sequence, unless `endpoint` is set to False. -// In that case, the sequence consists of all but the last of ``num + 1`` -// evenly spaced samples, so that `stop` is excluded. Note that the step -// size changes when `endpoint` is False. -// num : int, optional -// Number of samples to generate. Default is 50. Must be non-negative. -// endpoint : bool, optional -// If True, `stop` is the last sample. Otherwise, it is not included. -// Default is True. -// retstep : bool, optional -// If True, return (`samples`, `step`), where `step` is the spacing -// between samples. -// dtype : dtype, optional -// The type of the output array. If `dtype` is not given, the data type -// is inferred from `start` and `stop`. The inferred dtype will never be -// an integer; `float` is chosen even if the arguments would produce an -// array of integers. -// -// .. versionadded:: 1.9.0 -// -// axis : int, optional -// The axis in the result to store the samples. Relevant only if start -// or stop are array-like. By default (0), the samples will be along a -// new axis inserted at the beginning. Use -1 to get an axis at the end. -// -// .. versionadded:: 1.16.0 -// -// Returns -// ------- -// samples : ndarray -// There are `num` equally spaced samples in the closed interval -// ``[start, stop]`` or the half-open interval ``[start, stop)`` -// (depending on whether `endpoint` is True or False). -// step : float, optional -// Only returned if `retstep` is True -// -// Size of spacing between samples. -// -// -// See Also -// -------- -// arange : Similar to `linspace`, but uses a step size (instead of the -// number of samples). -// geomspace : Similar to `linspace`, but with numbers spaced evenly on a log -// scale (a geometric progression). -// logspace : Similar to `geomspace`, but with the end points specified as -// logarithms. -// :ref:`how-to-partition` -// -// Examples -// -------- -// >>> np.linspace(2.0, 3.0, num=5) -// array([2. , 2.25, 2.5 , 2.75, 3. ]) -// >>> np.linspace(2.0, 3.0, num=5, endpoint=False) -// array([2. , 2.2, 2.4, 2.6, 2.8]) -// >>> np.linspace(2.0, 3.0, num=5, retstep=True) -// (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) -// -// Graphical illustration: -// -// >>> import matplotlib.pyplot as plt -// >>> N = 8 -// >>> y = np.zeros(N) -// >>> x1 = np.linspace(0, 10, N, endpoint=True) -// >>> x2 = np.linspace(0, 10, N, endpoint=False) -// >>> plt.plot(x1, y, 'o') -// [] -// >>> plt.plot(x2, y + 0.5, 'o') -// [] -// >>> plt.ylim([-0.5, 1]) -// (-0.5, 1) -// >>> plt.show() -// -// -// -//go:linkname Linspace py.linspace -func Linspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, retstep *py.Object, dtype *py.Object, axis *py.Object) *py.Object -// -// Find the product of two polynomials. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// Finds the polynomial resulting from the multiplication of the two input -// polynomials. Each input must be either a poly1d object or a 1D sequence -// of polynomial coefficients, from highest to lowest degree. -// -// Parameters -// ---------- -// a1, a2 : array_like or poly1d object -// Input polynomials. -// -// Returns -// ------- -// out : ndarray or poly1d object -// The polynomial resulting from the multiplication of the inputs. If -// either inputs is a poly1d object, then the output is also a poly1d -// object. Otherwise, it is a 1D array of polynomial coefficients from -// highest to lowest degree. -// -// See Also -// -------- -// poly1d : A one-dimensional polynomial class. -// poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval -// convolve : Array convolution. Same output as polymul, but has parameter -// for overlap mode. -// -// Examples -// -------- -// >>> np.polymul([1, 2, 3], [9, 5, 1]) -// array([ 9, 23, 38, 17, 3]) -// -// Using poly1d objects: -// -// >>> p1 = np.poly1d([1, 2, 3]) -// >>> p2 = np.poly1d([9, 5, 1]) -// >>> print(p1) -// 2 -// 1 x + 2 x + 3 -// >>> print(p2) -// 2 -// 9 x + 5 x + 1 -// >>> print(np.polymul(p1, p2)) -// 4 3 2 -// 9 x + 23 x + 38 x + 17 x + 3 -// -// -// -//go:linkname Polymul py.polymul -func Polymul(a1 *py.Object, a2 *py.Object) *py.Object -// -// Print information about various resources in the system -// including available intrinsic support and BLAS/LAPACK library -// in use -// -// .. versionadded:: 1.24.0 -// -// 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 if available. -// 2. SIMD related information is derived from ``__cpu_features__``, -// ``__cpu_baseline__`` and ``__cpu_dispatch__`` -// -// -// -//go:linkname ShowRuntime py.show_runtime -func ShowRuntime() *py.Object -// -// Construct an array from an index array and a list of arrays to choose from. -// -// First of all, if confused or uncertain, definitely look at the Examples - -// in its full generality, this function is less simple than it might -// seem from the following code description (below ndi = -// `numpy.lib.index_tricks`): -// -// ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``. -// -// But this omits some subtleties. Here is a fully general summary: -// -// Given an "index" array (`a`) of integers and a sequence of ``n`` arrays -// (`choices`), `a` and each choice array are first broadcast, as necessary, -// to arrays of a common shape; calling these *Ba* and *Bchoices[i], i = -// 0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape`` -// for each ``i``. Then, a new array with shape ``Ba.shape`` is created as -// follows: -// -// * if ``mode='raise'`` (the default), then, first of all, each element of -// ``a`` (and thus ``Ba``) must be in the range ``[0, n-1]``; now, suppose -// that ``i`` (in that range) is the value at the ``(j0, j1, ..., jm)`` -// position in ``Ba`` - then the value at the same position in the new array -// is the value in ``Bchoices[i]`` at that same position; -// -// * if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed) -// integer; modular arithmetic is used to map integers outside the range -// `[0, n-1]` back into that range; and then the new array is constructed -// as above; -// -// * if ``mode='clip'``, values in `a` (and thus ``Ba``) may be any (signed) -// integer; negative integers are mapped to 0; values greater than ``n-1`` -// are mapped to ``n-1``; and then the new array is constructed as above. -// -// Parameters -// ---------- -// a : int array -// This array must contain integers in ``[0, n-1]``, where ``n`` is the -// number of choices, unless ``mode=wrap`` or ``mode=clip``, in which -// cases any integers are permissible. -// choices : sequence of arrays -// Choice arrays. `a` and all of the choices must be broadcastable to the -// same shape. If `choices` is itself an array (not recommended), then -// its outermost dimension (i.e., the one corresponding to -// ``choices.shape[0]``) is taken as defining the "sequence". -// out : array, optional -// If provided, the result will be inserted into this array. It should -// be of the appropriate shape and dtype. Note that `out` is always -// buffered if ``mode='raise'``; use other modes for better performance. -// mode : {'raise' (default), 'wrap', 'clip'}, optional -// Specifies how indices outside ``[0, n-1]`` will be treated: -// -// * 'raise' : an exception is raised -// * 'wrap' : value becomes value mod ``n`` -// * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1 -// -// Returns -// ------- -// merged_array : array -// The merged result. -// -// Raises -// ------ -// ValueError: shape mismatch -// If `a` and each choice array are not all broadcastable to the same -// shape. -// -// See Also -// -------- -// ndarray.choose : equivalent method -// numpy.take_along_axis : Preferable if `choices` is an array -// -// Notes -// ----- -// To reduce the chance of misinterpretation, even though the following -// "abuse" is nominally supported, `choices` should neither be, nor be -// thought of as, a single array, i.e., the outermost sequence-like container -// should be either a list or a tuple. -// -// Examples -// -------- -// -// >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], -// ... [20, 21, 22, 23], [30, 31, 32, 33]] -// >>> np.choose([2, 3, 1, 0], choices -// ... # the first element of the result will be the first element of the -// ... # third (2+1) "array" in choices, namely, 20; the second element -// ... # will be the second element of the fourth (3+1) choice array, i.e., -// ... # 31, etc. -// ... ) -// array([20, 31, 12, 3]) -// >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1) -// array([20, 31, 12, 3]) -// >>> # because there are 4 choice arrays -// >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4) -// array([20, 1, 12, 3]) -// >>> # i.e., 0 -// -// A couple examples illustrating how choose broadcasts: -// -// >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]] -// >>> choices = [-10, 10] -// >>> np.choose(a, choices) -// array([[ 10, -10, 10], -// [-10, 10, -10], -// [ 10, -10, 10]]) -// -// >>> # With thanks to Anne Archibald -// >>> a = np.array([0, 1]).reshape((2,1,1)) -// >>> c1 = np.array([1, 2, 3]).reshape((1,3,1)) -// >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5)) -// >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 -// array([[[ 1, 1, 1, 1, 1], -// [ 2, 2, 2, 2, 2], -// [ 3, 3, 3, 3, 3]], -// [[-1, -2, -3, -4, -5], -// [-1, -2, -3, -4, -5], -// [-1, -2, -3, -4, -5]]]) -// -// -// -//go:linkname Choose py.choose -func Choose(a *py.Object, choices *py.Object, out *py.Object, mode *py.Object) *py.Object -// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate `2**p` for all `p` in the input array. -// -// Parameters -// ---------- -// x : array_like -// Input values. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Element-wise 2 to the power `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// power -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// -// -// Examples -// -------- -// >>> np.exp2([2, 3]) -// array([ 4., 8.]) -// -//go:linkname Exp2 py.exp2 -func Exp2(x *py.Object, out *py.Object) *py.Object -// -// Return the imaginary part of the complex argument. -// -// Parameters -// ---------- -// val : array_like -// Input array. -// -// Returns -// ------- -// out : ndarray or scalar -// The imaginary component of the complex argument. If `val` is real, -// the type of `val` is used for the output. If `val` has complex -// elements, the returned type is float. -// -// See Also -// -------- -// real, angle, real_if_close -// -// Examples -// -------- -// >>> a = np.array([1+2j, 3+4j, 5+6j]) -// >>> a.imag -// array([2., 4., 6.]) -// >>> a.imag = np.array([8, 10, 12]) -// >>> a -// array([1. +8.j, 3.+10.j, 5.+12.j]) -// >>> np.imag(1 + 1j) -// 1.0 -// -// -// -//go:linkname Imag py.imag -func Imag(val *py.Object) *py.Object -// -// Find the set exclusive-or of two arrays. -// -// Return the sorted, unique values that are in only one (not both) of the -// input arrays. -// -// Parameters -// ---------- -// ar1, ar2 : array_like -// Input arrays. -// assume_unique : bool -// If True, the input arrays are both assumed to be unique, which -// can speed up the calculation. Default is False. -// -// Returns -// ------- -// setxor1d : ndarray -// Sorted 1D array of unique values that are in only one of the input -// arrays. -// -// Examples -// -------- -// >>> a = np.array([1, 2, 3, 2, 4]) -// >>> b = np.array([2, 3, 5, 7, 5]) -// >>> np.setxor1d(a,b) -// array([1, 4, 5, 7]) -// -// -// -//go:linkname Setxor1d py.setxor1d -func Setxor1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object) *py.Object -// Fill the main diagonal of the given array of any dimensionality. -// -// For an array `a` with ``a.ndim >= 2``, the diagonal is the list of -// locations with indices ``a[i, ..., i]`` all identical. This function -// modifies the input array in-place, it does not return a value. -// -// Parameters -// ---------- -// a : array, at least 2-D. -// Array whose diagonal is to be filled, it gets modified in-place. -// -// val : scalar or array_like -// Value(s) to write on the diagonal. If `val` is scalar, the value is -// written along the diagonal. If array-like, the flattened `val` is -// written along the diagonal, repeating if necessary to fill all -// diagonal entries. -// -// wrap : bool -// For tall matrices in NumPy version up to 1.6.2, the -// diagonal "wrapped" after N columns. You can have this behavior -// with this option. This affects only tall matrices. -// -// See also -// -------- -// diag_indices, diag_indices_from -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// This functionality can be obtained via `diag_indices`, but internally -// this version uses a much faster implementation that never constructs the -// indices and uses simple slicing. -// -// Examples -// -------- -// >>> a = np.zeros((3, 3), int) -// >>> np.fill_diagonal(a, 5) -// >>> a -// array([[5, 0, 0], -// [0, 5, 0], -// [0, 0, 5]]) -// -// The same function can operate on a 4-D array: -// -// >>> a = np.zeros((3, 3, 3, 3), int) -// >>> np.fill_diagonal(a, 4) -// -// We only show a few blocks for clarity: -// -// >>> a[0, 0] -// array([[4, 0, 0], -// [0, 0, 0], -// [0, 0, 0]]) -// >>> a[1, 1] -// array([[0, 0, 0], -// [0, 4, 0], -// [0, 0, 0]]) -// >>> a[2, 2] -// array([[0, 0, 0], -// [0, 0, 0], -// [0, 0, 4]]) -// -// The wrap option affects only tall matrices: -// -// >>> # tall matrices no wrap -// >>> a = np.zeros((5, 3), int) -// >>> np.fill_diagonal(a, 4) -// >>> a -// array([[4, 0, 0], -// [0, 4, 0], -// [0, 0, 4], -// [0, 0, 0], -// [0, 0, 0]]) -// -// >>> # tall matrices wrap -// >>> a = np.zeros((5, 3), int) -// >>> np.fill_diagonal(a, 4, wrap=True) -// >>> a -// array([[4, 0, 0], -// [0, 4, 0], -// [0, 0, 4], -// [0, 0, 0], -// [4, 0, 0]]) -// -// >>> # wide matrices -// >>> a = np.zeros((3, 5), int) -// >>> np.fill_diagonal(a, 4, wrap=True) -// >>> a -// array([[4, 0, 0, 0, 0], -// [0, 4, 0, 0, 0], -// [0, 0, 4, 0, 0]]) -// -// The anti-diagonal can be filled by reversing the order of elements -// using either `numpy.flipud` or `numpy.fliplr`. -// -// >>> a = np.zeros((3, 3), int); -// >>> np.fill_diagonal(np.fliplr(a), [1,2,3]) # Horizontal flip -// >>> a -// array([[0, 0, 1], -// [0, 2, 0], -// [3, 0, 0]]) -// >>> np.fill_diagonal(np.flipud(a), [1,2,3]) # Vertical flip -// >>> a -// array([[0, 0, 3], -// [0, 2, 0], -// [1, 0, 0]]) -// -// Note that the order in which the diagonal is filled varies depending -// on the flip function. -// -// -//go:linkname FillDiagonal py.fill_diagonal -func FillDiagonal(a *py.Object, val *py.Object, wrap *py.Object) *py.Object -// compare_chararrays(a1, a2, cmp, rstrip) -// -// Performs element-wise comparison of two string arrays using the -// comparison operator specified by `cmp_op`. -// -// Parameters -// ---------- -// a1, a2 : array_like -// Arrays to be compared. -// cmp : {"<", "<=", "==", ">=", ">", "!="} -// Type of comparison. -// rstrip : Boolean -// If True, the spaces at the end of Strings are removed before the comparison. -// -// Returns -// ------- -// out : ndarray -// The output array of type Boolean with the same shape as a and b. -// -// Raises -// ------ -// ValueError -// If `cmp_op` is not valid. -// TypeError -// If at least one of `a` or `b` is a non-string array -// -// Examples -// -------- -// >>> a = np.array(["a", "b", "cde"]) -// >>> b = np.array(["a", "a", "dec"]) -// >>> np.compare_chararrays(a, b, ">", True) -// array([False, True, False]) -// -//go:linkname CompareChararrays py.compare_chararrays -func CompareChararrays(a1 *py.Object, a2 *py.Object, cmp *py.Object, rstrip *py.Object) *py.Object -// -// Clip (limit) the values in an array. -// -// Given an interval, values outside the interval are clipped to -// the interval edges. For example, if an interval of ``[0, 1]`` -// is specified, values smaller than 0 become 0, and values larger -// than 1 become 1. -// -// Equivalent to but faster than ``np.minimum(a_max, np.maximum(a, a_min))``. -// -// No check is performed to ensure ``a_min < a_max``. -// -// Parameters -// ---------- -// a : array_like -// Array containing elements to clip. -// a_min, a_max : array_like or None -// Minimum and maximum value. If ``None``, clipping is not performed on -// the corresponding edge. Only one of `a_min` and `a_max` may be -// ``None``. Both are broadcast against `a`. -// out : ndarray, optional -// The results will be placed in this array. It may be the input -// array for in-place clipping. `out` must be of the right shape -// to hold the output. Its type is preserved. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// .. versionadded:: 1.17.0 -// -// Returns -// ------- -// clipped_array : ndarray -// An array with the elements of `a`, but where values -// < `a_min` are replaced with `a_min`, and those > `a_max` -// with `a_max`. -// -// See Also -// -------- -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// When `a_min` is greater than `a_max`, `clip` returns an -// array in which all values are equal to `a_max`, -// as shown in the second example. -// -// Examples -// -------- -// >>> a = np.arange(10) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.clip(a, 1, 8) -// array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) -// >>> np.clip(a, 8, 1) -// array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) -// >>> np.clip(a, 3, 6, out=a) -// array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) -// >>> a -// array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) -// >>> a = np.arange(10) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) -// array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8]) -// -// -// -//go:linkname Clip py.clip -func Clip(a *py.Object, aMin *py.Object, aMax *py.Object, out *py.Object) *py.Object -// -// Return specified diagonals. -// -// If `a` is 2-D, returns the diagonal of `a` with the given offset, -// i.e., the collection of elements of the form ``a[i, i+offset]``. If -// `a` has more than two dimensions, then the axes specified by `axis1` -// and `axis2` are used to determine the 2-D sub-array whose diagonal is -// returned. The shape of the resulting array can be determined by -// removing `axis1` and `axis2` and appending an index to the right equal -// to the size of the resulting diagonals. -// -// In versions of NumPy prior to 1.7, this function always returned a new, -// independent array containing a copy of the values in the diagonal. -// -// In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, -// but depending on this fact is deprecated. Writing to the resulting -// array continues to work as it used to, but a FutureWarning is issued. -// -// Starting in NumPy 1.9 it returns a read-only view on the original array. -// Attempting to write to the resulting array will produce an error. -// -// In some future release, it will return a read/write view and writing to -// the returned array will alter your original array. The returned array -// will have the same type as the input array. -// -// If you don't write to the array returned by this function, then you can -// just ignore all of the above. -// -// If you depend on the current behavior, then we suggest copying the -// returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead -// of just ``np.diagonal(a)``. This will work with both past and future -// versions of NumPy. -// -// Parameters -// ---------- -// a : array_like -// Array from which the diagonals are taken. -// offset : int, optional -// Offset of the diagonal from the main diagonal. Can be positive or -// negative. Defaults to main diagonal (0). -// axis1 : int, optional -// Axis to be used as the first axis of the 2-D sub-arrays from which -// the diagonals should be taken. Defaults to first axis (0). -// axis2 : int, optional -// Axis to be used as the second axis of the 2-D sub-arrays from -// which the diagonals should be taken. Defaults to second axis (1). -// -// Returns -// ------- -// array_of_diagonals : ndarray -// If `a` is 2-D, then a 1-D array containing the diagonal and of the -// same type as `a` is returned unless `a` is a `matrix`, in which case -// a 1-D array rather than a (2-D) `matrix` is returned in order to -// maintain backward compatibility. -// -// If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2` -// are removed, and a new axis inserted at the end corresponding to the -// diagonal. -// -// Raises -// ------ -// ValueError -// If the dimension of `a` is less than 2. -// -// See Also -// -------- -// diag : MATLAB work-a-like for 1-D and 2-D arrays. -// diagflat : Create diagonal arrays. -// trace : Sum along diagonals. -// -// Examples -// -------- -// >>> a = np.arange(4).reshape(2,2) -// >>> a -// array([[0, 1], -// [2, 3]]) -// >>> a.diagonal() -// array([0, 3]) -// >>> a.diagonal(1) -// array([1]) -// -// A 3-D example: -// -// >>> a = np.arange(8).reshape(2,2,2); a -// array([[[0, 1], -// [2, 3]], -// [[4, 5], -// [6, 7]]]) -// >>> a.diagonal(0, # Main diagonals of two arrays created by skipping -// ... 0, # across the outer(left)-most axis last and -// ... 1) # the "middle" (row) axis first. -// array([[0, 6], -// [1, 7]]) -// -// The sub-arrays whose main diagonals we just obtained; note that each -// corresponds to fixing the right-most (column) axis, and that the -// diagonals are "packed" in rows. -// -// >>> a[:,:,0] # main diagonal is [0 6] -// array([[0, 2], -// [4, 6]]) -// >>> a[:,:,1] # main diagonal is [1 7] -// array([[1, 3], -// [5, 7]]) -// -// The anti-diagonal can be obtained by reversing the order of elements -// using either `numpy.flipud` or `numpy.fliplr`. -// -// >>> a = np.arange(9).reshape(3, 3) -// >>> a -// array([[0, 1, 2], -// [3, 4, 5], -// [6, 7, 8]]) -// >>> np.fliplr(a).diagonal() # Horizontal flip -// array([2, 4, 6]) -// >>> np.flipud(a).diagonal() # Vertical flip -// array([6, 4, 2]) -// -// Note that the order in which the diagonal is retrieved varies depending -// on the flip function. -// -// -//go:linkname Diagonal py.diagonal -func Diagonal(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Object) *py.Object -// cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the cube-root of an array, element-wise. -// -// .. versionadded:: 1.10.0 -// -// Parameters -// ---------- -// x : array_like -// The values whose cube-roots are required. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// An array of the same shape as `x`, containing the cube -// cube-root of each element in `x`. -// If `out` was provided, `y` is a reference to it. -// This is a scalar if `x` is a scalar. -// -// -// Examples -// -------- -// >>> np.cbrt([1,8,27]) -// array([ 1., 2., 3.]) -// -//go:linkname Cbrt py.cbrt -func Cbrt(x *py.Object, out *py.Object) *py.Object -// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Hyperbolic sine, element-wise. -// -// Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or -// ``-1j * np.sin(1j*x)``. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray -// The corresponding hyperbolic sine values. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// If `out` is provided, the function writes the result into it, -// and returns a reference to `out`. (See Examples) -// -// References -// ---------- -// M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. -// New York, NY: Dover, 1972, pg. 83. -// -// Examples -// -------- -// >>> np.sinh(0) -// 0.0 -// >>> np.sinh(np.pi*1j/2) -// 1j -// >>> np.sinh(np.pi*1j) # (exact value is 0) -// 1.2246063538223773e-016j -// >>> # Discrepancy due to vagaries of floating point arithmetic. -// -// >>> # Example of providing the optional output parameter -// >>> out1 = np.array([0], dtype='d') -// >>> out2 = np.sinh([0.1], out1) -// >>> out2 is out1 -// True -// -// >>> # Example of ValueError due to provision of shape mis-matched `out` -// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2))) -// Traceback (most recent call last): -// File "", line 1, in -// ValueError: operands could not be broadcast together with shapes (3,3) (2,2) -// -//go:linkname Sinh py.sinh -func Sinh(x *py.Object, out *py.Object) *py.Object -// -// Return the indices to access the main diagonal of an n-dimensional array. -// -// See `diag_indices` for full details. -// -// Parameters -// ---------- -// arr : array, at least 2-D -// -// See Also -// -------- -// diag_indices -// -// Notes -// ----- -// .. versionadded:: 1.4.0 -// -// Examples -// -------- -// -// Create a 4 by 4 array. -// -// >>> a = np.arange(16).reshape(4, 4) -// >>> a -// array([[ 0, 1, 2, 3], -// [ 4, 5, 6, 7], -// [ 8, 9, 10, 11], -// [12, 13, 14, 15]]) -// -// Get the indices of the diagonal elements. -// -// >>> di = np.diag_indices_from(a) -// >>> di -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) -// -// >>> a[di] -// array([ 0, 5, 10, 15]) -// -// This is simply syntactic sugar for diag_indices. -// -// >>> np.diag_indices(a.shape[0]) -// (array([0, 1, 2, 3]), array([0, 1, 2, 3])) -// -// -// -//go:linkname DiagIndicesFrom py.diag_indices_from -func DiagIndicesFrom(arr *py.Object) *py.Object -// -// Return the derivative of the specified order of a polynomial. -// -// .. note:: -// This forms part of the old polynomial API. Since version 1.4, the -// new polynomial API defined in `numpy.polynomial` is preferred. -// A summary of the differences can be found in the -// :doc:`transition guide `. -// -// Parameters -// ---------- -// p : poly1d or sequence -// Polynomial to differentiate. -// A sequence is interpreted as polynomial coefficients, see `poly1d`. -// m : int, optional -// Order of differentiation (default: 1) -// -// Returns -// ------- -// der : poly1d -// A new polynomial representing the derivative. -// -// See Also -// -------- -// polyint : Anti-derivative of a polynomial. -// poly1d : Class for one-dimensional polynomials. -// -// Examples -// -------- -// The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is: -// -// >>> p = np.poly1d([1,1,1,1]) -// >>> p2 = np.polyder(p) -// >>> p2 -// poly1d([3, 2, 1]) -// -// which evaluates to: -// -// >>> p2(2.) -// 17.0 -// -// We can verify this, approximating the derivative with -// ``(f(x + h) - f(x))/h``: -// -// >>> (p(2. + 0.001) - p(2.)) / 0.001 -// 17.007000999997857 -// -// The fourth-order derivative of a 3rd-order polynomial is zero: -// -// >>> np.polyder(p, 2) -// poly1d([6, 2]) -// >>> np.polyder(p, 3) -// poly1d([6]) -// >>> np.polyder(p, 4) -// poly1d([0]) -// -// -// -//go:linkname Polyder py.polyder -func Polyder(p *py.Object, m *py.Object) *py.Object -// -// Find indices where elements should be inserted to maintain order. -// -// Find the indices into a sorted array `a` such that, if the -// corresponding elements in `v` were inserted before the indices, the -// order of `a` would be preserved. -// -// Assuming that `a` is sorted: -// -// ====== ============================ -// `side` returned index `i` satisfies -// ====== ============================ -// left ``a[i-1] < v <= a[i]`` -// right ``a[i-1] <= v < a[i]`` -// ====== ============================ -// -// Parameters -// ---------- -// a : 1-D array_like -// Input array. If `sorter` is None, then it must be sorted in -// ascending order, otherwise `sorter` must be an array of indices -// that sort it. -// v : array_like -// Values to insert into `a`. -// side : {'left', 'right'}, optional -// If 'left', the index of the first suitable location found is given. -// If 'right', return the last such index. If there is no suitable -// index, return either 0 or N (where N is the length of `a`). -// sorter : 1-D array_like, optional -// Optional array of integer indices that sort array a into ascending -// order. They are typically the result of argsort. -// -// .. versionadded:: 1.7.0 -// -// Returns -// ------- -// indices : int or array of ints -// Array of insertion points with the same shape as `v`, -// or an integer if `v` is a scalar. -// -// See Also -// -------- -// sort : Return a sorted copy of an array. -// histogram : Produce histogram from 1-D data. -// -// Notes -// ----- -// Binary search is used to find the required insertion points. -// -// As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing -// `nan` values. The enhanced sort order is documented in `sort`. -// -// This function uses the same algorithm as the builtin python `bisect.bisect_left` -// (``side='left'``) and `bisect.bisect_right` (``side='right'``) functions, -// which is also vectorized in the `v` argument. -// -// Examples -// -------- -// >>> np.searchsorted([1,2,3,4,5], 3) -// 2 -// >>> np.searchsorted([1,2,3,4,5], 3, side='right') -// 3 -// >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3]) -// array([0, 5, 1, 2]) -// -// -// -//go:linkname Searchsorted py.searchsorted -func Searchsorted(a *py.Object, v *py.Object, side *py.Object, sorter *py.Object) *py.Object -// -// Returns True if first argument is a typecode lower/equal in type hierarchy. -// -// This is like the builtin :func:`issubclass`, but for `dtype`\ s. -// -// Parameters -// ---------- -// arg1, arg2 : dtype_like -// `dtype` or object coercible to one -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// :ref:`arrays.scalars` : Overview of the numpy type hierarchy. -// issubsctype, issubclass_ -// -// Examples -// -------- -// `issubdtype` can be used to check the type of arrays: -// -// >>> ints = np.array([1, 2, 3], dtype=np.int32) -// >>> np.issubdtype(ints.dtype, np.integer) -// True -// >>> np.issubdtype(ints.dtype, np.floating) -// False -// -// >>> floats = np.array([1, 2, 3], dtype=np.float32) -// >>> np.issubdtype(floats.dtype, np.integer) -// False -// >>> np.issubdtype(floats.dtype, np.floating) -// True -// -// Similar types of different sizes are not subdtypes of each other: -// -// >>> np.issubdtype(np.float64, np.float32) -// False -// >>> np.issubdtype(np.float32, np.float64) -// False -// -// but both are subtypes of `floating`: -// -// >>> np.issubdtype(np.float64, np.floating) -// True -// >>> np.issubdtype(np.float32, np.floating) -// True -// -// For convenience, dtype-like objects are allowed too: -// -// >>> np.issubdtype('S1', np.string_) -// True -// >>> np.issubdtype('i4', np.signedinteger) -// True -// -// -// -//go:linkname Issubdtype py.issubdtype -func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object -// -// unravel_index(indices, shape, order='C') -// -// Converts a flat index or array of flat indices into a tuple -// of coordinate arrays. -// -// Parameters -// ---------- -// indices : array_like -// An integer array whose elements are indices into the flattened -// version of an array of dimensions ``shape``. Before version 1.6.0, -// this function accepted just one index value. -// shape : tuple of ints -// The shape of the array to use for unraveling ``indices``. -// -// .. versionchanged:: 1.16.0 -// Renamed from ``dims`` to ``shape``. -// -// order : {'C', 'F'}, optional -// Determines whether the indices should be viewed as indexing in -// row-major (C-style) or column-major (Fortran-style) order. -// -// .. versionadded:: 1.6.0 -// -// Returns -// ------- -// unraveled_coords : tuple of ndarray -// Each array in the tuple has the same shape as the ``indices`` -// array. -// -// See Also -// -------- -// ravel_multi_index -// -// Examples -// -------- -// >>> np.unravel_index([22, 41, 37], (7,6)) -// (array([3, 6, 6]), array([4, 5, 1])) -// >>> np.unravel_index([31, 41, 13], (7,6), order='F') -// (array([3, 6, 6]), array([4, 5, 1])) -// -// >>> np.unravel_index(1621, (6,7,8,9)) -// (3, 1, 4, 1) -// -// -// -//go:linkname UnravelIndex py.unravel_index -func UnravelIndex(indices *py.Object, shape *py.Object, order *py.Object) *py.Object -// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Numerical positive, element-wise. -// -// .. versionadded:: 1.13.0 -// -// Parameters -// ---------- -// x : array_like or scalar -// Input array. -// -// Returns -// ------- -// y : ndarray or scalar -// Returned array or scalar: `y = +x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// Equivalent to `x.copy()`, but only defined for types that support -// arithmetic. -// -// Examples -// -------- -// -// >>> x1 = np.array(([1., -1.])) -// >>> np.positive(x1) -// array([ 1., -1.]) -// -// The unary ``+`` operator can be used as a shorthand for ``np.positive`` on -// ndarrays. -// -// >>> x1 = np.array(([1., -1.])) -// >>> +x1 -// array([ 1., -1.]) -// -//go:linkname Positive py.positive -func Positive(x *py.Object, out *py.Object) *py.Object -// datetime_data(dtype, /) -// -// Get information about the step size of a date or time type. -// -// The returned tuple can be passed as the second argument of `numpy.datetime64` and -// `numpy.timedelta64`. -// -// Parameters -// ---------- -// dtype : dtype -// The dtype object, which must be a `datetime64` or `timedelta64` type. -// -// Returns -// ------- -// unit : str -// The :ref:`datetime unit ` on which this dtype -// is based. -// count : int -// The number of base units in a step. -// -// Examples -// -------- -// >>> dt_25s = np.dtype('timedelta64[25s]') -// >>> np.datetime_data(dt_25s) -// ('s', 25) -// >>> np.array(10, dt_25s).astype('timedelta64[s]') -// array(250, dtype='timedelta64[s]') -// -// The result can be used to construct a datetime that uses the same units -// as a timedelta -// -// >>> np.datetime64('2010', np.datetime_data(dt_25s)) -// numpy.datetime64('2010-01-01T00:00:00','25s') -// -//go:linkname DatetimeData py.datetime_data -func DatetimeData(dtype *py.Object) *py.Object -// -// Set a Python function to be used when pretty printing arrays. -// -// Parameters -// ---------- -// f : function or None -// Function to be used to pretty print arrays. The function should expect -// a single array argument and return a string of the representation of -// the array. If None, the function is reset to the default NumPy function -// to print arrays. -// repr : bool, optional -// If True (default), the function for pretty printing (``__repr__``) -// is set, if False the function that returns the default string -// representation (``__str__``) is set. -// -// See Also -// -------- -// set_printoptions, get_printoptions -// -// Examples -// -------- -// >>> def pprint(arr): -// ... return 'HA! - What are you going to do now?' -// ... -// >>> np.set_string_function(pprint) -// >>> a = np.arange(10) -// >>> a -// HA! - What are you going to do now? -// >>> _ = a -// >>> # [0 1 2 3 4 5 6 7 8 9] -// -// We can reset the function to the default: -// -// >>> np.set_string_function(None) -// >>> a -// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) -// -// `repr` affects either pretty printing or normal string representation. -// Note that ``__repr__`` is still affected by setting ``__str__`` -// because the width of each array element in the returned string becomes -// equal to the length of the result of ``__str__()``. -// -// >>> x = np.arange(4) -// >>> np.set_string_function(lambda x:'random', repr=False) -// >>> x.__str__() -// 'random' -// >>> x.__repr__() -// 'array([0, 1, 2, 3])' -// -// -// -//go:linkname SetStringFunction py.set_string_function -func SetStringFunction(f *py.Object, repr *py.Object) *py.Object -// -// Compute the q-th percentile of the data along the specified axis. -// -// Returns the q-th percentile(s) of the array elements. -// -// Parameters -// ---------- -// a : array_like of real numbers -// Input array or object that can be converted to an array. -// q : array_like of float -// Percentage or sequence of percentages for the percentiles to compute. -// Values must be between 0 and 100 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the percentiles are computed. The -// default is to compute the percentile(s) along a flattened -// version of the array. -// -// .. versionchanged:: 1.9.0 -// A tuple of axes is supported -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output, -// but the type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by intermediate -// calculations, to save memory. In this case, the contents of the input -// `a` after this function completes is undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// percentile. There are many different methods, some unique to NumPy. -// See the notes for explanation. The options sorted by their R type -// as summarized in the H&F paper [1]_ are: -// -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' -// -// The first three methods are discontinuous. NumPy further defines the -// following discontinuous variations of the default 'linear' (7.) option: -// -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' -// -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. -// -// 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 array `a`. -// -// .. versionadded:: 1.9.0 -// -// interpolation : str, optional -// Deprecated name for the method keyword argument. -// -// .. deprecated:: 1.22.0 -// -// Returns -// ------- -// percentile : scalar or ndarray -// If `q` is a single percentile and `axis=None`, then the result -// is a scalar. If multiple percentiles are given, first axis of -// the result corresponds to the percentiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the -// same as that of the input. If `out` is specified, that array is -// returned instead. -// -// See Also -// -------- -// mean -// median : equivalent to ``percentile(..., 50)`` -// nanpercentile -// quantile : equivalent to percentile, except q in the range [0, 1]. -// -// Notes -// ----- -// 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 -// percentile if the normalized ranking does not match the location of -// ``q`` exactly. This function is the same as the median if ``q=50``, the -// same as the minimum if ``q=0`` and the same as the maximum if -// ``q=100``. -// -// 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. -// -// The following formula determines the virtual index ``i + g``, the location -// of the percentile in the sorted sample: -// -// .. math:: -// 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 -// -// 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 -// -// median_unbiased: -// 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: -// -// * alpha = 1/3 -// * beta = 1/3 -// -// normal_unbiased: -// 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: -// -// * alpha = 3/8 -// * beta = 3/8 -// -// lower: -// NumPy method kept for backwards compatibility. -// Takes ``i`` as the interpolation point. -// -// higher: -// NumPy method kept for backwards compatibility. -// Takes ``j`` as the interpolation point. -// -// nearest: -// NumPy method kept for backwards compatibility. -// Takes ``i`` or ``j``, whichever is nearest. -// -// midpoint: -// NumPy method kept for backwards compatibility. -// Uses ``(i + j) / 2``. -// -// Examples -// -------- -// >>> a = np.array([[10, 7, 4], [3, 2, 1]]) -// >>> a -// array([[10, 7, 4], -// [ 3, 2, 1]]) -// >>> np.percentile(a, 50) -// 3.5 -// >>> np.percentile(a, 50, axis=0) -// array([6.5, 4.5, 2.5]) -// >>> np.percentile(a, 50, axis=1) -// array([7., 2.]) -// >>> np.percentile(a, 50, axis=1, keepdims=True) -// array([[7.], -// [2.]]) -// -// >>> m = np.percentile(a, 50, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.percentile(a, 50, axis=0, out=out) -// array([6.5, 4.5, 2.5]) -// >>> m -// array([6.5, 4.5, 2.5]) -// -// >>> b = a.copy() -// >>> np.percentile(b, 50, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a == b) -// -// The different methods can be visualized graphically: -// -// .. plot:: -// -// import matplotlib.pyplot as plt -// -// a = np.arange(4) -// p = np.linspace(0, 100, 6001) -// ax = plt.gca() -// lines = [ -// ('linear', '-', 'C0'), -// ('inverted_cdf', ':', 'C1'), -// # Almost the same as `inverted_cdf`: -// ('averaged_inverted_cdf', '-.', 'C1'), -// ('closest_observation', ':', 'C2'), -// ('interpolated_inverted_cdf', '--', 'C1'), -// ('hazen', '--', 'C3'), -// ('weibull', '-.', 'C4'), -// ('median_unbiased', '--', 'C5'), -// ('normal_unbiased', '-.', 'C6'), -// ] -// for method, style, color in lines: -// ax.plot( -// p, np.percentile(a, p, method=method), -// label=method, linestyle=style, color=color) -// ax.set( -// title='Percentiles for different methods and data: ' + str(a), -// xlabel='Percentile', -// ylabel='Estimated percentile value', -// yticks=a) -// ax.legend(bbox_to_anchor=(1.03, 1)) -// plt.tight_layout() -// plt.show() -// -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 -// -// -// -//go:linkname Percentile py.percentile -func Percentile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object -// -// Calculate the n-th discrete difference along the given axis. -// -// The first difference is given by ``out[i] = a[i+1] - a[i]`` along -// the given axis, higher differences are calculated by using `diff` -// recursively. -// -// Parameters -// ---------- -// a : array_like -// Input array -// n : int, optional -// The number of times values are differenced. If zero, the input -// is returned as-is. -// axis : int, optional -// The axis along which the difference is taken, default is the -// last axis. -// prepend, append : array_like, optional -// Values to prepend or append to `a` along axis prior to -// performing the difference. Scalar values are expanded to -// arrays with length 1 in the direction of axis and the shape -// of the input array in along all other axes. Otherwise the -// dimension and shape must match `a` except along axis. -// -// .. versionadded:: 1.16.0 -// -// Returns -// ------- -// diff : ndarray -// The n-th differences. The shape of the output is the same as `a` -// except along `axis` where the dimension is smaller by `n`. The -// type of the output is the same as the type of the difference -// between any two elements of `a`. This is the same as the type of -// `a` in most cases. A notable exception is `datetime64`, which -// results in a `timedelta64` output array. -// -// See Also -// -------- -// gradient, ediff1d, cumsum -// -// Notes -// ----- -// Type is preserved for boolean arrays, so the result will contain -// `False` when consecutive elements are the same and `True` when they -// differ. -// -// For unsigned integer arrays, the results will also be unsigned. This -// should not be surprising, as the result is consistent with -// calculating the difference directly: -// -// >>> u8_arr = np.array([1, 0], dtype=np.uint8) -// >>> np.diff(u8_arr) -// array([255], dtype=uint8) -// >>> u8_arr[1,...] - u8_arr[0,...] -// 255 -// -// If this is not desirable, then the array should be cast to a larger -// integer type first: -// -// >>> i16_arr = u8_arr.astype(np.int16) -// >>> np.diff(i16_arr) -// array([-1], dtype=int16) -// -// Examples -// -------- -// >>> x = np.array([1, 2, 4, 7, 0]) -// >>> np.diff(x) -// array([ 1, 2, 3, -7]) -// >>> np.diff(x, n=2) -// array([ 1, 1, -10]) -// -// >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]]) -// >>> np.diff(x) -// array([[2, 3, 4], -// [5, 1, 2]]) -// >>> np.diff(x, axis=0) -// array([[-1, 2, 0, -2]]) -// -// >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64) -// >>> np.diff(x) -// array([1, 1], dtype='timedelta64[D]') -// -// -// -//go:linkname Diff py.diff -func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, append *py.Object) *py.Object -// -// Print the NumPy arrays in the given dictionary. -// -// If there is no dictionary passed in or `vardict` is None then returns -// NumPy arrays in the globals() dictionary (all NumPy arrays in the -// namespace). -// -// Parameters -// ---------- -// vardict : dict, optional -// A dictionary possibly containing ndarrays. Default is globals(). -// -// Returns -// ------- -// out : None -// Returns 'None'. -// -// Notes -// ----- -// Prints out the name, shape, bytes and type of all of the ndarrays -// present in `vardict`. -// -// Examples -// -------- -// >>> a = np.arange(10) -// >>> b = np.ones(20) -// >>> np.who() -// Name Shape Bytes Type -// =========================================================== -// a 10 80 int64 -// b 20 160 float64 -// Upper bound on total bytes = 240 -// -// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str', -// ... 'idx':5} -// >>> np.who(d) -// Name Shape Bytes Type -// =========================================================== -// x 2 16 float64 -// y 3 24 float64 -// Upper bound on total bytes = 40 -// -// -// -//go:linkname Who py.who -func Who(vardict *py.Object) *py.Object -// -// Find the unique elements of an array. -// -// Returns the sorted unique elements of an array. There are three optional -// outputs in addition to the unique elements: -// -// * the indices of the input array that give the unique values -// * the indices of the unique array that reconstruct the input array -// * the number of times each unique value comes up in the input array -// -// Parameters -// ---------- -// ar : array_like -// Input array. Unless `axis` is specified, this will be flattened if it -// is not already 1-D. -// return_index : bool, optional -// If True, also return the indices of `ar` (along the specified axis, -// if provided, or in the flattened array) that result in the unique array. -// return_inverse : bool, optional -// If True, also return the indices of the unique array (for the specified -// axis, if provided) that can be used to reconstruct `ar`. -// return_counts : bool, optional -// If True, also return the number of times each unique item appears -// in `ar`. -// 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 -// as the elements of a 1-D array with the dimension of the given axis, -// see the notes for more details. Object arrays or structured arrays -// that contain objects are not supported if the `axis` kwarg is used. The -// default is None. -// -// .. 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 -// The sorted unique values. -// unique_indices : ndarray, optional -// The indices of the first occurrences of the unique values in the -// original array. Only provided if `return_index` is True. -// unique_inverse : ndarray, optional -// The indices to reconstruct the original array from the -// unique array. Only provided if `return_inverse` is True. -// unique_counts : ndarray, optional -// The number of times each of the unique values comes up in the -// original array. Only provided if `return_counts` is True. -// -// .. versionadded:: 1.9.0 -// -// See Also -// -------- -// numpy.lib.arraysetops : Module with a number of other functions for -// performing set operations on arrays. -// repeat : Repeat elements of an array. -// -// Notes -// ----- -// When an axis is specified the subarrays indexed by the axis are sorted. -// This is done by making the specified axis the first dimension of the array -// (move the axis to the first dimension to keep the order of the other axes) -// and then flattening the subarrays in C order. The flattened subarrays are -// then viewed as a structured type with each element given a label, with the -// effect that we end up with a 1-D array of structured types that can be -// treated in the same way as any other 1-D array. The result is that the -// flattened subarrays are sorted in lexicographic order starting with the -// first element. -// -// .. versionchanged: NumPy 1.21 -// If nan values are in the input array, a single nan is put -// to the end of the sorted unique values. -// -// Also for complex arrays all NaN values are considered equivalent -// (no matter whether the NaN is in the real or imaginary part). -// As the representant for the returned array the smallest one in the -// lexicographical order is chosen - see np.sort for how the lexicographical -// order is defined for complex arrays. -// -// Examples -// -------- -// >>> np.unique([1, 1, 2, 2, 3, 3]) -// array([1, 2, 3]) -// >>> a = np.array([[1, 1], [2, 3]]) -// >>> np.unique(a) -// array([1, 2, 3]) -// -// Return the unique rows of a 2D array -// -// >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]]) -// >>> np.unique(a, axis=0) -// array([[1, 0, 0], [2, 3, 4]]) -// -// Return the indices of the original array that give the unique values: -// -// >>> a = np.array(['a', 'b', 'b', 'c', 'a']) -// >>> u, indices = np.unique(a, return_index=True) -// >>> u -// array(['a', 'b', 'c'], dtype='>> indices -// array([0, 1, 3]) -// >>> a[indices] -// array(['a', 'b', 'c'], dtype='>> a = np.array([1, 2, 6, 4, 2, 3, 2]) -// >>> u, indices = np.unique(a, return_inverse=True) -// >>> u -// array([1, 2, 3, 4, 6]) -// >>> indices -// array([0, 1, 4, 3, 1, 2, 1]) -// >>> u[indices] -// array([1, 2, 6, 4, 2, 3, 2]) -// -// Reconstruct the input values from the unique values and counts: -// -// >>> a = np.array([1, 2, 6, 4, 2, 3, 2]) -// >>> values, counts = np.unique(a, return_counts=True) -// >>> values -// array([1, 2, 3, 4, 6]) -// >>> counts -// array([1, 3, 1, 1, 1]) -// >>> np.repeat(values, counts) -// array([1, 2, 2, 2, 3, 4, 6]) # original order not preserved -// -// -// -//go:linkname Unique py.unique -func Unique(ar *py.Object, returnIndex *py.Object, returnInverse *py.Object, returnCounts *py.Object, axis *py.Object) *py.Object -// -// Check for a complex type or an array of complex numbers. -// -// The type of the input is checked, not the value. Even if the input -// has an imaginary part equal to zero, `iscomplexobj` evaluates to True. -// -// Parameters -// ---------- -// x : any -// The input can be of any type and shape. -// -// Returns -// ------- -// iscomplexobj : bool -// The return value, True if `x` is of a complex type or has at least -// one complex element. -// -// See Also -// -------- -// isrealobj, iscomplex -// -// Examples -// -------- -// >>> np.iscomplexobj(1) -// False -// >>> np.iscomplexobj(1+0j) -// True -// >>> np.iscomplexobj([3, 1+0j, True]) -// True -// -// -// -//go:linkname Iscomplexobj py.iscomplexobj -func Iscomplexobj(x *py.Object) *py.Object -// -// 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 -// `a`). -// -// Parameters -// ---------- -// a : array_like -// Input array. -// tol : float -// Tolerance in machine epsilons for the complex part of the elements -// in the array. If the tolerance is <=1, then the absolute tolerance -// is used. -// -// Returns -// ------- -// out : ndarray -// If `a` is real, the type of `a` is used for the output. If `a` -// has complex elements, the returned type is float. -// -// See Also -// -------- -// real, imag, angle -// -// Notes -// ----- -// Machine epsilon varies from machine to machine and between data types -// but Python floats on most platforms have a machine epsilon equal to -// 2.2204460492503131e-16. You can use 'np.finfo(float).eps' to print -// out the machine epsilon for floats. -// -// Examples -// -------- -// >>> np.finfo(float).eps -// 2.2204460492503131e-16 # may vary -// -// >>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000) -// array([2.1, 5.2]) -// >>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000) -// array([2.1+4.e-13j, 5.2 + 3e-15j]) -// -// -// -//go:linkname RealIfClose py.real_if_close -func RealIfClose(a *py.Object, tol *py.Object) *py.Object -// -// Split an array into multiple sub-arrays horizontally (column-wise). -// -// Please refer to the `split` documentation. `hsplit` is equivalent -// to `split` with ``axis=1``, the array is always split along the second -// axis except for 1-D arrays, where it is split at ``axis=0``. -// -// See Also -// -------- -// split : Split an array into multiple sub-arrays of equal size. -// -// Examples -// -------- -// >>> x = np.arange(16.0).reshape(4, 4) -// >>> x -// array([[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.], -// [ 8., 9., 10., 11.], -// [12., 13., 14., 15.]]) -// >>> np.hsplit(x, 2) -// [array([[ 0., 1.], -// [ 4., 5.], -// [ 8., 9.], -// [12., 13.]]), -// array([[ 2., 3.], -// [ 6., 7.], -// [10., 11.], -// [14., 15.]])] -// >>> np.hsplit(x, np.array([3, 6])) -// [array([[ 0., 1., 2.], -// [ 4., 5., 6.], -// [ 8., 9., 10.], -// [12., 13., 14.]]), -// array([[ 3.], -// [ 7.], -// [11.], -// [15.]]), -// array([], shape=(4, 0), dtype=float64)] -// -// With a higher dimensional array the split is still along the second axis. -// -// >>> x = np.arange(8.0).reshape(2, 2, 2) -// >>> x -// array([[[0., 1.], -// [2., 3.]], -// [[4., 5.], -// [6., 7.]]]) -// >>> np.hsplit(x, 2) -// [array([[[0., 1.]], -// [[4., 5.]]]), -// 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])] -// -// -// -//go:linkname Hsplit py.hsplit -func Hsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object -// -// Return the cumulative product of array elements over a given axis treating Not a -// Numbers (NaNs) as one. The cumulative product does not change when NaNs are -// encountered and leading NaNs are replaced by ones. -// -// Ones are returned for slices that are all-NaN or empty. -// -// .. versionadded:: 1.12.0 -// -// Parameters -// ---------- -// a : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative product is computed. By default -// the input is flattened. -// dtype : dtype, optional -// Type of the returned array, as well as of the accumulator in which -// the elements are multiplied. If *dtype* is not specified, it -// defaults to the dtype of `a`, unless `a` has an integer dtype with -// a precision less than that of the default platform integer. In -// that case, the default platform integer is used instead. -// out : ndarray, optional -// Alternative output array in which to place the result. It must -// have the same shape and buffer length as the expected output -// but the type of the resulting values will be cast if necessary. -// -// Returns -// ------- -// nancumprod : ndarray -// A new array holding the result is returned unless `out` is -// specified, in which case it is returned. -// -// See Also -// -------- -// numpy.cumprod : Cumulative product across array propagating NaNs. -// isnan : Show which elements are NaN. -// -// Examples -// -------- -// >>> np.nancumprod(1) -// array([1]) -// >>> np.nancumprod([1]) -// array([1]) -// >>> np.nancumprod([1, np.nan]) -// array([1., 1.]) -// >>> a = np.array([[1, 2], [3, np.nan]]) -// >>> np.nancumprod(a) -// array([1., 2., 6., 6.]) -// >>> np.nancumprod(a, axis=0) -// array([[1., 2.], -// [3., 2.]]) -// >>> np.nancumprod(a, axis=1) -// array([[1., 2.], -// [3., 3.]]) -// -// -// -//go:linkname Nancumprod py.nancumprod -func Nancumprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object -// absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Calculate the absolute value element-wise. -// -// ``np.abs`` is a shorthand for this function. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// absolute : ndarray -// An ndarray containing the absolute value of -// each element in `x`. For complex input, ``a + ib``, the -// absolute value is :math:`\sqrt{ a^2 + b^2 }`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> x = np.array([-1.2, 1.2]) -// >>> np.absolute(x) -// array([ 1.2, 1.2]) -// >>> np.absolute(1.2 + 1j) -// 1.5620499351813308 -// -// Plot the function over ``[-10, 10]``: -// -// >>> import matplotlib.pyplot as plt -// -// >>> x = np.linspace(start=-10, stop=10, num=101) -// >>> plt.plot(x, np.absolute(x)) -// >>> plt.show() -// -// Plot the function over the complex plane: -// -// >>> xx = x + 1j * x[:, np.newaxis] -// >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') -// >>> plt.show() -// -// The `abs` function can be used as a shorthand for ``np.absolute`` on -// ndarrays. -// -// >>> x = np.array([-1.2, 1.2]) -// >>> abs(x) -// array([1.2, 1.2]) -// -//go:linkname Abs py.abs -func Abs(__llgo_va_list ...interface{}) *py.Object -// -// Returns the discrete, linear convolution of two one-dimensional sequences. -// -// The convolution operator is often seen in signal processing, where it -// models the effect of a linear time-invariant system on a signal [1]_. In -// probability theory, the sum of two independent random variables is -// distributed according to the convolution of their individual -// distributions. -// -// If `v` is longer than `a`, the arrays are swapped before computation. -// -// Parameters -// ---------- -// a : (N,) array_like -// First one-dimensional input array. -// v : (M,) array_like -// Second one-dimensional input array. -// mode : {'full', 'valid', 'same'}, optional -// 'full': -// By default, mode is 'full'. This returns the convolution -// at each point of overlap, with an output shape of (N+M-1,). At -// the end-points of the convolution, the signals do not overlap -// completely, and boundary effects may be seen. -// -// 'same': -// Mode 'same' returns output of length ``max(M, N)``. Boundary -// effects are still visible. -// -// 'valid': -// Mode 'valid' returns output of length -// ``max(M, N) - min(M, N) + 1``. The convolution product is only given -// for points where the signals overlap completely. Values outside -// the signal boundary have no effect. -// -// Returns -// ------- -// out : ndarray -// Discrete, linear convolution of `a` and `v`. -// -// See Also -// -------- -// scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier -// Transform. -// scipy.linalg.toeplitz : Used to construct the convolution operator. -// polymul : Polynomial multiplication. Same output as convolve, but also -// accepts poly1d objects as input. -// -// Notes -// ----- -// The discrete convolution operation is defined as -// -// .. 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 -// domain, after appropriate padding (padding is necessary to prevent -// circular convolution). Since multiplication is more efficient (faster) -// than convolution, the function `scipy.signal.fftconvolve` exploits the -// FFT to calculate the convolution of large data-sets. -// -// References -// ---------- -// .. [1] Wikipedia, "Convolution", -// https://en.wikipedia.org/wiki/Convolution -// -// Examples -// -------- -// Note how the convolution operator flips the second array -// before "sliding" the two across one another: -// -// >>> np.convolve([1, 2, 3], [0, 1, 0.5]) -// array([0. , 1. , 2.5, 4. , 1.5]) -// -// Only return the middle values of the convolution. -// Contains boundary effects, where zeros are taken -// into account: -// -// >>> np.convolve([1,2,3],[0,1,0.5], 'same') -// array([1. , 2.5, 4. ]) -// -// The two arrays are of the same length, so there -// is only one position where they completely overlap: -// -// >>> np.convolve([1,2,3],[0,1,0.5], 'valid') -// array([2.5]) -// -// -// -//go:linkname Convolve py.convolve -func Convolve(a *py.Object, v *py.Object, mode *py.Object) *py.Object -// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Element-wise minimum of array elements. -// -// Compare two arrays and return a new array containing the element-wise -// minima. If one of the elements being compared is a NaN, then the -// non-nan element is returned. If both elements are NaNs then the first -// is returned. The latter distinction is important for complex NaNs, -// which are defined as at least one of the real or imaginary parts being -// a NaN. The net effect is that NaNs are ignored when possible. -// -// Parameters -// ---------- -// x1, x2 : array_like -// The arrays holding the elements to be compared. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The minimum of `x1` and `x2`, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// fmax : -// Element-wise maximum of two arrays, ignores NaNs. -// minimum : -// Element-wise minimum of two arrays, propagates NaNs. -// amin : -// The minimum value of an array along a given axis, propagates NaNs. -// nanmin : -// The minimum value of an array along a given axis, ignores NaNs. -// -// maximum, amax, nanmax -// -// Notes -// ----- -// .. versionadded:: 1.3.0 -// -// The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither -// x1 nor x2 are NaNs, but it is faster and does proper broadcasting. -// -// Examples -// -------- -// >>> np.fmin([2, 3, 4], [1, 5, 2]) -// array([1, 3, 2]) -// -// >>> np.fmin(np.eye(2), [0.5, 2]) -// array([[ 0.5, 0. ], -// [ 0. , 1. ]]) -// -// >>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) -// array([ 0., 0., nan]) -// -//go:linkname Fmin py.fmin -func Fmin(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Returns x1 * 2**x2, element-wise. -// -// The mantissas `x1` and twos exponents `x2` are used to construct -// floating point numbers ``x1 * 2**x2``. -// -// Parameters -// ---------- -// x1 : array_like -// Array of multipliers. -// x2 : array_like, int -// Array of twos exponents. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The result of ``x1 * 2**x2``. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`. -// -// Notes -// ----- -// Complex dtypes are not supported, they will raise a TypeError. -// -// `ldexp` is useful as the inverse of `frexp`, if used by itself it is -// more clear to simply use the expression ``x1 * 2**x2``. -// -// Examples -// -------- -// >>> np.ldexp(5, np.arange(4)) -// array([ 5., 10., 20., 40.], dtype=float16) -// -// >>> x = np.arange(6) -// >>> np.ldexp(*np.frexp(x)) -// array([ 0., 1., 2., 3., 4., 5.]) -// -//go:linkname Ldexp py.ldexp -func Ldexp(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the truth value of NOT x element-wise. -// -// Parameters -// ---------- -// x : array_like -// Logical NOT is applied to the elements of `x`. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool or ndarray of bool -// Boolean result with the same shape as `x` of the NOT operation -// on elements of `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// logical_and, logical_or, logical_xor -// -// Examples -// -------- -// >>> np.logical_not(3) -// False -// >>> np.logical_not([True, False, 0, 1]) -// array([False, True, True, False]) -// -// >>> x = np.arange(5) -// >>> np.logical_not(x<3) -// array([False, False, False, True, True]) -// -//go:linkname LogicalNot py.logical_not -func LogicalNot(x *py.Object, out *py.Object) *py.Object -// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the fractional and integral parts of an array, element-wise. -// -// The fractional and integral parts are negative if the given number is -// negative. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y1 : ndarray -// Fractional part of `x`. -// This is a scalar if `x` is a scalar. -// y2 : ndarray -// Integral part of `x`. -// This is a scalar if `x` is a scalar. -// -// Notes -// ----- -// For integer input the return values are floats. -// -// See Also -// -------- -// divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values -// switched, except it always has a positive remainder. -// -// Examples -// -------- -// >>> np.modf([0, 3.5]) -// (array([ 0. , 0.5]), array([ 0., 3.])) -// >>> np.modf(-0.5) -// (-0.5, -0) -// -//go:linkname Modf py.modf -func Modf(x *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object -// -// Format a floating-point scalar as a decimal string in scientific notation. -// -// Provides control over rounding, trimming and padding. Uses and assumes -// IEEE unbiased rounding. Uses the "Dragon4" algorithm. -// -// Parameters -// ---------- -// x : python float or numpy floating scalar -// Value to format. -// precision : non-negative integer or None, optional -// Maximum number of digits to print. May be None if `unique` is -// `True`, but must be an integer if unique is `False`. -// unique : boolean, optional -// If `True`, use a digit-generation strategy which gives the shortest -// representation which uniquely identifies the floating-point number from -// other values of the same type, by judicious rounding. If `precision` -// is given fewer digits than necessary can be printed. If `min_digits` -// is given more can be printed, in which cases the last digit is rounded -// with unbiased rounding. -// If `False`, digits are generated as if printing an infinite-precision -// value and stopping after `precision` digits, rounding the remaining -// value with unbiased rounding -// trim : one of 'k', '.', '0', '-', optional -// Controls post-processing trimming of trailing digits, as follows: -// -// * 'k' : keep trailing zeros, keep decimal point (no trimming) -// * '.' : trim all trailing zeros, leave decimal point -// * '0' : trim all but the zero before the decimal point. Insert the -// zero if it is missing. -// * '-' : trim trailing zeros and any trailing decimal point -// sign : boolean, optional -// Whether to show the sign for positive values. -// pad_left : non-negative integer, optional -// Pad the left side of the string with whitespace until at least that -// many characters are to the left of the decimal point. -// exp_digits : non-negative integer, optional -// Pad the exponent with zeros until it contains at least this many digits. -// If omitted, the exponent will be at least 2 digits. -// min_digits : non-negative integer or None, optional -// Minimum number of digits to print. This only has an effect for -// `unique=True`. In that case more digits than necessary to uniquely -// identify the value may be printed and rounded unbiased. -// -// -- versionadded:: 1.21.0 -// -// Returns -// ------- -// rep : string -// The string representation of the floating point value -// -// See Also -// -------- -// format_float_positional -// -// Examples -// -------- -// >>> np.format_float_scientific(np.float32(np.pi)) -// '3.1415927e+00' -// >>> s = np.float32(1.23e24) -// >>> np.format_float_scientific(s, unique=False, precision=15) -// '1.230000071797338e+24' -// >>> np.format_float_scientific(s, exp_digits=4) -// '1.23e+0024' -// -// -//go:linkname FormatFloatScientific py.format_float_scientific -func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object -// -// Compute the qth percentile of the data along the specified axis, -// while ignoring nan values. -// -// Returns the qth percentile(s) of the array elements. -// -// .. versionadded:: 1.9.0 -// -// Parameters -// ---------- -// a : array_like -// Input array or object that can be converted to an array, containing -// nan values to be ignored. -// q : array_like of float -// Percentile or sequence of percentiles to compute, which must be -// between 0 and 100 inclusive. -// axis : {int, tuple of int, None}, optional -// Axis or axes along which the percentiles are computed. The default -// is to compute the percentile(s) along a flattened version of the -// array. -// out : ndarray, optional -// Alternative output array in which to place the result. It must have -// the same shape and buffer length as the expected output, but the -// type (of the output) will be cast if necessary. -// overwrite_input : bool, optional -// If True, then allow the input array `a` to be modified by -// intermediate calculations, to save memory. In this case, the -// contents of the input `a` after this function completes is -// undefined. -// method : str, optional -// This parameter specifies the method to use for estimating the -// percentile. There are many different methods, some unique to NumPy. -// See the notes for explanation. The options sorted by their R type -// as summarized in the H&F paper [1]_ are: -// -// 1. 'inverted_cdf' -// 2. 'averaged_inverted_cdf' -// 3. 'closest_observation' -// 4. 'interpolated_inverted_cdf' -// 5. 'hazen' -// 6. 'weibull' -// 7. 'linear' (default) -// 8. 'median_unbiased' -// 9. 'normal_unbiased' -// -// The first three methods are discontinuous. NumPy further defines the -// following discontinuous variations of the default 'linear' (7.) option: -// -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' -// -// .. versionchanged:: 1.22.0 -// This argument was previously called "interpolation" and only -// offered the "linear" default and last four options. -// -// 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 array `a`. -// -// If this is anything but the default value it will be passed -// through (in the special case of an empty array) to the -// `mean` function of the underlying array. If the array is -// a sub-class and `mean` does not have the kwarg `keepdims` this -// will raise a RuntimeError. -// -// interpolation : str, optional -// Deprecated name for the method keyword argument. -// -// .. deprecated:: 1.22.0 -// -// Returns -// ------- -// percentile : scalar or ndarray -// If `q` is a single percentile and `axis=None`, then the result -// is a scalar. If multiple percentiles are given, first axis of -// the result corresponds to the percentiles. The other axes are -// the axes that remain after the reduction of `a`. If the input -// contains integers or floats smaller than ``float64``, the output -// data-type is ``float64``. Otherwise, the output data-type is the -// same as that of the input. If `out` is specified, that array is -// returned instead. -// -// See Also -// -------- -// nanmean -// nanmedian : equivalent to ``nanpercentile(..., 50)`` -// percentile, median, mean -// nanquantile : equivalent to nanpercentile, except q in range [0, 1]. -// -// Notes -// ----- -// For more information please see `numpy.percentile` -// -// Examples -// -------- -// >>> a = np.array([[10., 7., 4.], [3., 2., 1.]]) -// >>> a[0][1] = np.nan -// >>> a -// array([[10., nan, 4.], -// [ 3., 2., 1.]]) -// >>> np.percentile(a, 50) -// nan -// >>> np.nanpercentile(a, 50) -// 3.0 -// >>> np.nanpercentile(a, 50, axis=0) -// array([6.5, 2. , 2.5]) -// >>> np.nanpercentile(a, 50, axis=1, keepdims=True) -// array([[7.], -// [2.]]) -// >>> m = np.nanpercentile(a, 50, axis=0) -// >>> out = np.zeros_like(m) -// >>> np.nanpercentile(a, 50, axis=0, out=out) -// array([6.5, 2. , 2.5]) -// >>> m -// array([6.5, 2. , 2.5]) -// -// >>> b = a.copy() -// >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True) -// array([7., 2.]) -// >>> assert not np.all(a==b) -// -// References -// ---------- -// .. [1] R. J. Hyndman and Y. Fan, -// "Sample quantiles in statistical packages," -// The American Statistician, 50(4), pp. 361-365, 1996 -// -// -// -//go:linkname Nanpercentile py.nanpercentile -func Nanpercentile(a *py.Object, q *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, method *py.Object, keepdims *py.Object) *py.Object -// -// Stack arrays in sequence horizontally (column wise). -// -// This is equivalent to concatenation along the second axis, except for 1-D -// arrays where it concatenates along the first axis. Rebuilds arrays divided -// by `hsplit`. -// -// This function makes most sense for arrays with up to 3 dimensions. For -// instance, for pixel-data with a height (first axis), width (second axis), -// and r/g/b channels (third axis). The functions `concatenate`, `stack` and -// `block` provide more general stacking and concatenation operations. -// -// Parameters -// ---------- -// tup : sequence of ndarrays -// 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 -// The array formed by stacking the given arrays. -// -// See Also -// -------- -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// block : Assemble an nd-array from nested lists of blocks. -// vstack : Stack arrays in sequence vertically (row wise). -// dstack : Stack arrays in sequence depth wise (along third axis). -// column_stack : Stack 1-D arrays as columns into a 2-D array. -// hsplit : Split an array into multiple sub-arrays horizontally (column-wise). -// -// Examples -// -------- -// >>> a = np.array((1,2,3)) -// >>> b = np.array((4,5,6)) -// >>> np.hstack((a,b)) -// array([1, 2, 3, 4, 5, 6]) -// >>> a = np.array([[1],[2],[3]]) -// >>> b = np.array([[4],[5],[6]]) -// >>> np.hstack((a,b)) -// array([[1, 4], -// [2, 5], -// [3, 6]]) -// -// -// -//go:linkname Hstack py.hstack -func Hstack(tup *py.Object) *py.Object -// -// Split an array into multiple sub-arrays as views into `ary`. -// -// Parameters -// ---------- -// ary : ndarray -// Array to be divided into sub-arrays. -// indices_or_sections : int or 1-D array -// If `indices_or_sections` is an integer, N, the array will be divided -// into N equal arrays along `axis`. If such a split is not possible, -// an error is raised. -// -// If `indices_or_sections` is a 1-D array of sorted integers, the entries -// indicate where along `axis` the array is split. For example, -// ``[2, 3]`` would, for ``axis=0``, result in -// -// - ary[:2] -// - ary[2:3] -// - ary[3:] -// -// If an index exceeds the dimension of the array along `axis`, -// an empty sub-array is returned correspondingly. -// axis : int, optional -// The axis along which to split, default is 0. -// -// Returns -// ------- -// sub-arrays : list of ndarrays -// A list of sub-arrays as views into `ary`. -// -// Raises -// ------ -// ValueError -// If `indices_or_sections` is given as an integer, but -// a split does not result in equal division. -// -// See Also -// -------- -// array_split : Split an array into multiple sub-arrays of equal or -// near-equal size. Does not raise an exception if -// an equal division cannot be made. -// hsplit : Split array into multiple sub-arrays horizontally (column-wise). -// vsplit : Split array into multiple sub-arrays vertically (row wise). -// dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). -// concatenate : Join a sequence of arrays along an existing axis. -// stack : Join a sequence of arrays along a new axis. -// hstack : Stack arrays in sequence horizontally (column wise). -// vstack : Stack arrays in sequence vertically (row wise). -// dstack : Stack arrays in sequence depth wise (along third dimension). -// -// Examples -// -------- -// >>> x = np.arange(9.0) -// >>> np.split(x, 3) -// [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])] -// -// >>> x = np.arange(8.0) -// >>> np.split(x, [3, 5, 6, 10]) -// [array([0., 1., 2.]), -// array([3., 4.]), -// array([5.]), -// array([6., 7.]), -// array([], dtype=float64)] -// -// -// -//go:linkname Split py.split -func Split(ary *py.Object, indicesOrSections *py.Object, axis *py.Object) *py.Object -// -// Apply a function to 1-D slices along the given axis. -// -// Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays -// and `a` is a 1-D slice of `arr` along `axis`. -// -// This is equivalent to (but faster than) the following use of `ndindex` and -// `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices:: -// -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// f = func1d(arr[ii + s_[:,] + kk]) -// Nj = f.shape -// for jj in ndindex(Nj): -// out[ii + jj + kk] = f[jj] -// -// Equivalently, eliminating the inner loop, this can be expressed as:: -// -// Ni, Nk = a.shape[:axis], a.shape[axis+1:] -// for ii in ndindex(Ni): -// for kk in ndindex(Nk): -// out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk]) -// -// Parameters -// ---------- -// func1d : function (M,) -> (Nj...) -// This function should accept 1-D arrays. It is applied to 1-D -// slices of `arr` along the specified axis. -// axis : integer -// Axis along which `arr` is sliced. -// arr : ndarray (Ni..., M, Nk...) -// Input array. -// args : any -// Additional arguments to `func1d`. -// kwargs : any -// Additional named arguments to `func1d`. -// -// .. versionadded:: 1.9.0 -// -// -// Returns -// ------- -// out : ndarray (Ni..., Nj..., Nk...) -// The output array. The shape of `out` is identical to the shape of -// `arr`, except along the `axis` dimension. This axis is removed, and -// replaced with new dimensions equal to the shape of the return value -// of `func1d`. So if `func1d` returns a scalar `out` will have one -// fewer dimensions than `arr`. -// -// See Also -// -------- -// apply_over_axes : Apply a function repeatedly over multiple axes. -// -// Examples -// -------- -// >>> def my_func(a): -// ... """Average first and last element of a 1-D array""" -// ... return (a[0] + a[-1]) * 0.5 -// >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) -// >>> np.apply_along_axis(my_func, 0, b) -// array([4., 5., 6.]) -// >>> np.apply_along_axis(my_func, 1, b) -// array([2., 5., 8.]) -// -// For a function that returns a 1D array, the number of dimensions in -// `outarr` is the same as `arr`. -// -// >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]]) -// >>> np.apply_along_axis(sorted, 1, b) -// array([[1, 7, 8], -// [3, 4, 9], -// [2, 5, 6]]) -// -// For a function that returns a higher dimensional array, those dimensions -// are inserted in place of the `axis` dimension. -// -// >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) -// >>> np.apply_along_axis(np.diag, -1, b) -// array([[[1, 0, 0], -// [0, 2, 0], -// [0, 0, 3]], -// [[4, 0, 0], -// [0, 5, 0], -// [0, 0, 6]], -// [[7, 0, 0], -// [0, 8, 0], -// [0, 0, 9]]]) -// -// -//go:linkname ApplyAlongAxis py.apply_along_axis -func ApplyAlongAxis(func1d *py.Object, axis *py.Object, arr *py.Object, __llgo_va_list ...interface{}) *py.Object -// -// Do a keyword search on docstrings. -// -// A list of objects that matched the search is displayed, -// sorted by relevance. All given keywords need to be found in the -// docstring for it to be returned as a result, but the order does -// not matter. -// -// Parameters -// ---------- -// what : str -// String containing words to look for. -// module : str or list, optional -// Name of module(s) whose docstrings to go through. -// import_modules : bool, optional -// Whether to import sub-modules in packages. Default is True. -// regenerate : bool, optional -// Whether to re-generate the docstring cache. Default is False. -// output : file-like, optional -// File-like object to write the output to. If omitted, use a pager. -// -// See Also -// -------- -// source, info -// -// Notes -// ----- -// Relevance is determined only roughly, by checking if the keywords occur -// in the function name, at the start of a docstring, etc. -// -// Examples -// -------- -// >>> np.lookfor('binary representation') # doctest: +SKIP -// Search results for 'binary representation' -// ------------------------------------------ -// numpy.binary_repr -// Return the binary representation of the input number as a string. -// numpy.core.setup_common.long_double_representation -// Given a binary dump as given by GNU od -b, look for long double -// numpy.base_repr -// Return a string representation of a number in the given base system. -// ... -// -// -// -//go:linkname Lookfor py.lookfor -func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *py.Object) *py.Object -// -// Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files. -// -// .. warning:: Loading files that contain object arrays uses the ``pickle`` -// module, which is not secure against erroneous or maliciously -// constructed data. Consider passing ``allow_pickle=False`` to -// load data that is known not to contain object arrays for the -// safer handling of untrusted sources. -// -// Parameters -// ---------- -// file : file-like object, string, or pathlib.Path -// The file to read. File-like objects must support 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 -// `numpy.memmap` for a detailed description of the modes). A -// memory-mapped array is kept on disk. However, it can be accessed -// and sliced like any ndarray. Memory mapping is especially useful -// for accessing small fragments of large files without reading the -// entire file into memory. -// allow_pickle : bool, optional -// Allow loading pickled object arrays stored in npy files. Reasons for -// disallowing pickles include security, as loading pickled data can -// execute arbitrary code. If pickles are disallowed, loading object -// arrays will fail. Default: False -// -// .. versionchanged:: 1.16.3 -// Made default False in response to CVE-2019-6446. -// -// fix_imports : bool, optional -// Only useful when loading Python 2 generated pickled files on Python 3, -// which includes npy/npz files containing object arrays. If `fix_imports` -// is True, pickle will try to map the old Python 2 names to the new names -// used in Python 3. -// encoding : str, optional -// What encoding to use when reading Python 2 strings. Only useful when -// loading Python 2 generated pickled files in Python 3, which includes -// 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:func:`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 -// ------- -// result : array, tuple, dict, etc. -// Data stored in the file. For ``.npz`` files, the returned instance -// of NpzFile class must be closed to avoid leaking file descriptors. -// -// Raises -// ------ -// OSError -// If the input file does not exist or cannot be read. -// UnpicklingError -// If ``allow_pickle=True``, but the file cannot be loaded as a pickle. -// ValueError -// The file contains an object array, but ``allow_pickle=False`` given. -// EOFError -// When calling ``np.load`` multiple times on the same file handle, -// if all data has already been read -// -// See Also -// -------- -// save, savez, savez_compressed, loadtxt -// memmap : Create a memory-map to an array stored in a file on disk. -// lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. -// -// Notes -// ----- -// - If the file contains pickle data, then whatever object is stored -// in the pickle is returned. -// - If the file is a ``.npy`` file, then a single array is returned. -// - If the file is a ``.npz`` file, then a dictionary-like object is -// returned, containing ``{filename: array}`` key-value pairs, one for -// each file in the archive. -// - If the file is a ``.npz`` file, the returned value supports the -// context manager protocol in a similar fashion to the open function:: -// -// with load('foo.npz') as data: -// a = data['a'] -// -// The underlying file descriptor is closed when exiting the 'with' -// block. -// -// Examples -// -------- -// Store data to disk, and load it again: -// -// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]])) -// >>> np.load('/tmp/123.npy') -// array([[1, 2, 3], -// [4, 5, 6]]) -// -// Store compressed data to disk, and load it again: -// -// >>> a=np.array([[1, 2, 3], [4, 5, 6]]) -// >>> b=np.array([1, 2]) -// >>> np.savez('/tmp/123.npz', a=a, b=b) -// >>> data = np.load('/tmp/123.npz') -// >>> data['a'] -// array([[1, 2, 3], -// [4, 5, 6]]) -// >>> data['b'] -// array([1, 2]) -// >>> data.close() -// -// Mem-map the stored array, and then access the second row -// directly from disk: -// -// >>> X = np.load('/tmp/123.npy', mmap_mode='r') -// >>> X[1, :] -// memmap([4, 5, 6]) -// -// -// -//go:linkname Load py.load -func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object -// -// Compute the histogram of a dataset. -// -// Parameters -// ---------- -// a : array_like -// Input data. The histogram is computed over the flattened array. -// bins : int or sequence of scalars or str, optional -// If `bins` is an int, it defines the number of equal-width -// bins in the given range (10, by default). If `bins` is a -// sequence, it defines a monotonically increasing array of bin edges, -// including the rightmost edge, allowing for non-uniform bin widths. -// -// .. versionadded:: 1.11.0 -// -// If `bins` is a string, it defines the method used to calculate the -// optimal bin width, as defined by `histogram_bin_edges`. -// -// range : (float, float), optional -// The lower and upper range of the bins. If not provided, range -// is simply ``(a.min(), a.max())``. Values outside the range are -// ignored. The first element of the range must be less than or -// equal to the second. `range` affects the automatic bin -// 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. -// 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 -// (instead of 1). If `density` is True, the weights are -// normalized, so that the integral of the density over the range -// remains 1. -// density : bool, optional -// If ``False``, the result will contain the number of samples in -// each bin. If ``True``, the result is the value of the -// probability *density* function at the bin, normalized such that -// the *integral* over the range is 1. Note that the sum of the -// histogram values will not be equal to 1 unless bins of unity -// width are chosen; it is not a probability *mass* function. -// -// Returns -// ------- -// hist : array -// The values of the histogram. See `density` and `weights` for a -// description of the possible semantics. -// bin_edges : array of dtype float -// Return the bin edges ``(length(hist)+1)``. -// -// -// See Also -// -------- -// histogramdd, bincount, searchsorted, digitize, histogram_bin_edges -// -// Notes -// ----- -// All but the last (righthand-most) bin is half-open. In other words, -// if `bins` is:: -// -// [1, 2, 3, 4] -// -// then the first bin is ``[1, 2)`` (including 1, but excluding 2) and -// the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which -// *includes* 4. -// -// -// Examples -// -------- -// >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3]) -// (array([0, 2, 1]), array([0, 1, 2, 3])) -// >>> np.histogram(np.arange(4), bins=np.arange(5), density=True) -// (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4])) -// >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3]) -// (array([1, 4, 1]), array([0, 1, 2, 3])) -// -// >>> a = np.arange(5) -// >>> hist, bin_edges = np.histogram(a, density=True) -// >>> hist -// array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5]) -// >>> hist.sum() -// 2.4999999999999996 -// >>> np.sum(hist * np.diff(bin_edges)) -// 1.0 -// -// .. versionadded:: 1.11.0 -// -// Automated Bin Selection Methods example, using 2 peak random data -// with 2000 points: -// -// >>> import matplotlib.pyplot as plt -// >>> rng = np.random.RandomState(10) # deterministic random data -// >>> a = np.hstack((rng.normal(size=1000), -// ... rng.normal(loc=5, scale=2, size=1000))) -// >>> _ = plt.hist(a, bins='auto') # arguments are passed to np.histogram -// >>> plt.title("Histogram with 'auto' bins") -// Text(0.5, 1.0, "Histogram with 'auto' bins") -// >>> plt.show() -// -// -// -//go:linkname Histogram py.histogram -func Histogram(a *py.Object, bins *py.Object, Range *py.Object, density *py.Object, weights *py.Object) *py.Object -// -// Roll array elements along a given axis. -// -// Elements that roll beyond the last position are re-introduced at -// the first. -// -// Parameters -// ---------- -// a : array_like -// Input array. -// shift : int or tuple of ints -// The number of places by which elements are shifted. If a tuple, -// then `axis` must be a tuple of the same size, and each of the -// given axes is shifted by the corresponding number. If an int -// while `axis` is a tuple of ints, then the same value is used for -// all given axes. -// axis : int or tuple of ints, optional -// Axis or axes along which elements are shifted. By default, the -// array is flattened before shifting, after which the original -// shape is restored. -// -// Returns -// ------- -// res : ndarray -// Output array, with the same shape as `a`. -// -// See Also -// -------- -// rollaxis : Roll the specified axis backwards, until it lies in a -// given position. -// -// Notes -// ----- -// .. versionadded:: 1.12.0 -// -// Supports rolling over multiple dimensions simultaneously. -// -// Examples -// -------- -// >>> x = np.arange(10) -// >>> np.roll(x, 2) -// array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) -// >>> np.roll(x, -2) -// array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]) -// -// >>> x2 = np.reshape(x, (2, 5)) -// >>> x2 -// array([[0, 1, 2, 3, 4], -// [5, 6, 7, 8, 9]]) -// >>> np.roll(x2, 1) -// array([[9, 0, 1, 2, 3], -// [4, 5, 6, 7, 8]]) -// >>> np.roll(x2, -1) -// array([[1, 2, 3, 4, 5], -// [6, 7, 8, 9, 0]]) -// >>> np.roll(x2, 1, axis=0) -// array([[5, 6, 7, 8, 9], -// [0, 1, 2, 3, 4]]) -// >>> np.roll(x2, -1, axis=0) -// array([[5, 6, 7, 8, 9], -// [0, 1, 2, 3, 4]]) -// >>> np.roll(x2, 1, axis=1) -// array([[4, 0, 1, 2, 3], -// [9, 5, 6, 7, 8]]) -// >>> np.roll(x2, -1, axis=1) -// array([[1, 2, 3, 4, 0], -// [6, 7, 8, 9, 5]]) -// >>> np.roll(x2, (1, 1), axis=(1, 0)) -// array([[9, 5, 6, 7, 8], -// [4, 0, 1, 2, 3]]) -// >>> np.roll(x2, (2, 1), axis=(1, 0)) -// array([[8, 9, 5, 6, 7], -// [3, 4, 0, 1, 2]]) -// -// -// -//go:linkname Roll py.roll -func Roll(a *py.Object, shift *py.Object, axis *py.Object) *py.Object -// bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Compute the bit-wise XOR of two arrays element-wise. -// -// Computes the bit-wise XOR of the underlying binary representation of -// the integers in the input arrays. This ufunc implements the C/Python -// operator ``^``. -// -// Parameters -// ---------- -// x1, x2 : array_like -// Only integer and boolean types are handled. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : ndarray or scalar -// Result. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// logical_xor -// bitwise_and -// bitwise_or -// binary_repr : -// Return the binary representation of the input number as a string. -// -// Examples -// -------- -// The number 13 is represented by ``00001101``. Likewise, 17 is -// represented by ``00010001``. The bit-wise XOR of 13 and 17 is -// therefore ``00011100``, or 28: -// -// >>> np.bitwise_xor(13, 17) -// 28 -// >>> np.binary_repr(28) -// '11100' -// -// >>> np.bitwise_xor(31, 5) -// 26 -// >>> np.bitwise_xor([31,3], 5) -// array([26, 6]) -// -// >>> np.bitwise_xor([31,3], [5,6]) -// array([26, 5]) -// >>> np.bitwise_xor([True, True], [False, True]) -// array([ True, False]) -// -// The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on -// ndarrays. -// -// >>> x1 = np.array([True, True]) -// >>> x2 = np.array([False, True]) -// >>> x1 ^ x2 -// array([ True, False]) -// -//go:linkname BitwiseXor py.bitwise_xor -func BitwiseXor(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Divide arguments element-wise. -// -// Parameters -// ---------- -// x1 : array_like -// Dividend array. -// x2 : array_like -// Divisor array. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : ndarray or scalar -// The quotient ``x1/x2``, element-wise. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// seterr : Set whether to raise or warn on overflow, underflow and -// division by zero. -// -// Notes -// ----- -// Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting. -// -// The ``true_divide(x1, x2)`` function is an alias for -// ``divide(x1, x2)``. -// -// Examples -// -------- -// >>> np.divide(2.0, 4.0) -// 0.5 -// >>> 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. ]]) -// -// The ``/`` operator can be used as a shorthand for ``np.divide`` on -// ndarrays. -// -// >>> x1 = np.arange(9.0).reshape((3, 3)) -// >>> x2 = 2 * np.ones(3) -// >>> x1 / x2 -// array([[0. , 0.5, 1. ], -// [1.5, 2. , 2.5], -// [3. , 3.5, 4. ]]) -// -//go:linkname Divide py.divide -func Divide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Test element-wise for positive or negative infinity. -// -// Returns a boolean array of the same shape as `x`, True where ``x == -// +/-inf``, otherwise False. -// -// Parameters -// ---------- -// x : array_like -// Input values -// out : ndarray, None, or tuple of ndarray and None, optional -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// where : array_like, optional -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// y : bool (scalar) or boolean ndarray -// True where ``x`` is positive or negative infinity, false otherwise. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// isneginf, isposinf, isnan, isfinite -// -// Notes -// ----- -// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic -// (IEEE 754). -// -// Errors result if the second argument is supplied when the first -// argument is a scalar, or if the first and second arguments have -// different shapes. -// -// Examples -// -------- -// >>> np.isinf(np.inf) -// True -// >>> np.isinf(np.nan) -// False -// >>> np.isinf(np.NINF) -// True -// >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) -// array([ True, True, False, False]) -// -// >>> x = np.array([-np.inf, 0., np.inf]) -// >>> y = np.array([2, 2, 2]) -// >>> np.isinf(x, y) -// array([1, 0, 1]) -// >>> y -// array([1, 0, 1]) -// -//go:linkname Isinf py.isinf -func Isinf(x *py.Object, out *py.Object) *py.Object -// -// Determines whether the given object represents a scalar data-type. -// -// Parameters -// ---------- -// rep : any -// If `rep` is an instance of a scalar dtype, True is returned. If not, -// False is returned. -// -// Returns -// ------- -// out : bool -// Boolean result of check whether `rep` is a scalar dtype. -// -// See Also -// -------- -// issubsctype, issubdtype, obj2sctype, sctype2char -// -// Examples -// -------- -// >>> np.issctype(np.int32) -// True -// >>> np.issctype(list) -// False -// >>> np.issctype(1.1) -// False -// -// Strings are also a scalar type: -// -// >>> np.issctype(np.dtype('str')) -// True -// -// -// -//go:linkname Issctype py.issctype -func Issctype(rep *py.Object) *py.Object -// -// 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 -// Array to be sorted. -// -// Returns -// ------- -// sorted_array : ndarray -// Array of the same type and shape as `a`. -// -// See Also -// -------- -// sort -// -// Notes -// ----- -// ``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]]) -// -// -// -//go:linkname Msort py.msort -func Msort(a *py.Object) *py.Object -// -// Split array into multiple sub-arrays along the 3rd axis (depth). -// -// Please refer to the `split` documentation. `dsplit` is equivalent -// to `split` with ``axis=2``, the array is always split along the third -// axis provided the array dimension is greater than or equal to 3. -// -// See Also -// -------- -// split : Split an array into multiple sub-arrays of equal size. -// -// Examples -// -------- -// >>> x = np.arange(16.0).reshape(2, 2, 4) -// >>> x -// array([[[ 0., 1., 2., 3.], -// [ 4., 5., 6., 7.]], -// [[ 8., 9., 10., 11.], -// [12., 13., 14., 15.]]]) -// >>> np.dsplit(x, 2) -// [array([[[ 0., 1.], -// [ 4., 5.]], -// [[ 8., 9.], -// [12., 13.]]]), array([[[ 2., 3.], -// [ 6., 7.]], -// [[10., 11.], -// [14., 15.]]])] -// >>> np.dsplit(x, np.array([3, 6])) -// [array([[[ 0., 1., 2.], -// [ 4., 5., 6.]], -// [[ 8., 9., 10.], -// [12., 13., 14.]]]), -// array([[[ 3.], -// [ 7.]], -// [[11.], -// [15.]]]), -// array([], shape=(2, 2, 0), dtype=float64)] -// -// -//go:linkname Dsplit py.dsplit -func Dsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object -// -// Load data from a text file. -// -// Parameters -// ---------- -// fname : file, str, pathlib.Path, list of str, generator -// File, filename, list, or generator to read. If the filename -// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note -// that generators must return bytes or strings. The strings -// in a list or produced by a generator are treated as lines. -// dtype : data-type, optional -// Data-type of the resulting array; default: float. If this is a -// structured data-type, the resulting array will be 1-dimensional, and -// 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 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 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 -// Which columns to read, with 0 being the first. For example, -// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. -// The default, None, results in all columns being read. -// -// .. versionchanged:: 1.11.0 -// When a single column has to be read it is possible to use -// an integer instead of a tuple. E.g ``usecols = 3`` reads the -// fourth column the same way as ``usecols = (3,)`` would. -// unpack : bool, optional -// If True, the returned array is transposed, so that arguments may be -// unpacked using ``x, y, z = loadtxt(...)``. When used with a -// structured data-type, arrays are returned for each field. -// Default is False. -// ndmin : int, optional -// The returned array will have at least `ndmin` dimensions. -// Otherwise mono-dimensional axes will be squeezed. -// Legal values: 0 (default), 1 or 2. -// -// .. versionadded:: 1.6.0 -// encoding : str, optional -// Encoding used to decode the inputfile. Does not apply to input streams. -// The special value 'bytes' enables backward compatibility workarounds -// that ensures you receive byte arrays as results if possible and passes -// 'latin1' encoded strings to converters. Override this value to receive -// unicode arrays and pass strings as input to converters. If set to None -// the system default is used. The default value is 'bytes'. -// -// .. versionadded:: 1.14.0 -// max_rows : int, optional -// 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 -// 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 -// by it. In this case, it ensures the creation of an array object -// compatible with that passed in via this argument. -// -// .. versionadded:: 1.20.0 -// -// Returns -// ------- -// out : ndarray -// Data read from the text file. -// -// See Also -// -------- -// load, fromstring, fromregex -// genfromtxt : Load data with missing values handled as specified. -// scipy.io.loadmat : reads MATLAB data files -// -// Notes -// ----- -// This function aims to be a fast reader for simply formatted files. The -// `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 -// input for floats. -// -// Examples -// -------- -// >>> from io import StringIO # StringIO behaves like a file object -// >>> c = StringIO("0 1\n2 3") -// >>> np.loadtxt(c) -// array([[0., 1.], -// [2., 3.]]) -// -// >>> d = StringIO("M 21 72\nF 35 58") -// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), -// ... 'formats': ('S1', 'i4', 'f4')}) -// array([(b'M', 21, 72.), (b'F', 35, 58.)], -// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") -// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) -// >>> x -// array([1., 3.]) -// >>> 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. -// -// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') -// >>> def conv(fld): -// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) -// ... -// >>> np.loadtxt(s, converters=conv) -// array([[ 10.01, -31.25], -// [ 19.22, 64.31], -// [-17.57, 63.94]]) -// -// Using a callable as the converter can be particularly useful for handling -// values with different formatting, e.g. floats with underscores: -// -// >>> s = StringIO("1 2.7 100_000") -// >>> np.loadtxt(s, converters=float) -// array([1.e+00, 2.7e+00, 1.e+05]) -// -// This idea can be extended to automatically handle values specified in -// many different formats: -// -// >>> 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]) -// -// 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`` -// -// >>> 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]]) -// -// 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`: -// -// >>> 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', '>> 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.]]) -// -// -// -//go:linkname Loadtxt py.loadtxt -func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object