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..edcc3ea5 100644 --- a/.github/workflows/verification.yml +++ b/.github/workflows/verification.yml @@ -34,20 +34,28 @@ jobs: with: repository: '1351914167/llgo' path: .llgo - ref: presentation + ref: get_pip - name: Check out LLPyg uses: actions/checkout@v4 with: repository: 'toaction/llpyg' path: .llpyg - ref: presentation + ref: feat/v1 - name: Set up Go uses: actions/setup-go@v4 with: go-version: 1.24.x - name: Set up Tool run: | - go install -v github.com/PengPengPeng717/llpkgstore/cmd/llpkgstore@latest + 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: | @@ -55,27 +63,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 +95,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 +158,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" diff --git a/numpy/go.mod b/numpy/go.mod deleted file mode 100644 index 8ce9049a..00000000 --- a/numpy/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module github.com/PengPengPeng717/llpkg/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/llpyg.cfg b/numpy/llpyg.cfg deleted file mode 100644 index 932c66b2..00000000 --- a/numpy/llpyg.cfg +++ /dev/null @@ -1,8 +0,0 @@ -{ - "name": "numpy", - "libName": "numpy", - "libVersion": "2.3.2", - "modules": [ - "numpy" - ] -} diff --git a/numpy/numpy.go b/numpy/numpy.go deleted file mode 100644 index e0674759..00000000 --- a/numpy/numpy.go +++ /dev/null @@ -1,27552 +0,0 @@ -package numpy - -import ( - "github.com/goplus/lib/py" - _ "unsafe" -) - -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() -// -// 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 -//go:linkname Invert py.invert -func Invert(__llgo_va_list ...interface{}) *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. -// -// 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``. -// -// 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 -// -------- -// >>> 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.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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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 -// -// >>> np.flipud([1,2]) -// array([2, 1]) -// -// -// -//go:linkname Flipud py.flipud -func Flipud(m *py.Object) *py.Object -// -// can_cast(from_, to, casting='safe') -// -// Returns True if cast between data types can occur according to the -// casting rule. -// -// 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. -// -// Returns -// ------- -// out : bool -// True if cast can occur according to the casting rule. -// -// 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. -// -// See also -// -------- -// dtype, result_type -// -// Examples -// -------- -// Basic examples -// -// >>> 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.can_cast('i8', 'f8') -// True -// >>> np.can_cast('i8', 'f4') -// False -// >>> np.can_cast('i4', 'S4') -// False -// -// -// -//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. -// -// Returns -// ------- -// getbufsize : int -// Size of ufunc buffer in bytes. -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.getbufsize() -// 8192 -// -// -// -//go:linkname Getbufsize py.getbufsize -func Getbufsize() *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. -// 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 -// -// 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 -// -------- -// >>> 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) -// -// -// -//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 -// -// 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_compressed(fn, x=x, y=y)``. -// -// If arrays are specified as positional arguments, i.e., -// ``savez_compressed(fn, x, y)``, their names will be `arr_0`, `arr_1`, etc. -// -// 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. -// -// 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 `~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. -// -// 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 -// -// -// -//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 `. -// -// 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: -// -// >>> import numpy as np -// -// >>> 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(__llgo_va_list ...interface{}) *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. -// 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 -// -// 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 -// -------- -// >>> 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.]]) -// -// -// -//go:linkname Eye py.eye -func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *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 -// 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 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. -// -// See also -// -------- -// tril_indices : similar function, for lower-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// triu, tril -// -// Examples -// -------- -// >>> import numpy as np -// -// 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) -// >>> iu1 -// (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) -// -// 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.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): -// -// >>> 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]]) -// -// -// -//go:linkname TriuIndices py.triu_indices -func TriuIndices(n *py.Object, k *py.Object, m *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. -// -// 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: -// -// >>> 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. -// -// 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 -// -// >>> 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.]) -// -// >>> 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 -// -// 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 -// -------- -// >>> 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]) -// -// -// -//go:linkname Flatnonzero py.flatnonzero -func Flatnonzero(a *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. -// -// 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. -// -// 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 -// -------- -// >>> 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]) -// -// 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) -// np.float32(0.54999924) -// -// Computing the mean in float64 is more accurate: -// -// >>> np.mean(a, dtype=np.float64) -// 0.55000000074505806 # may vary -// -// Computing the mean in timedelta64 is available: -// -// >>> b = np.array([1, 3], dtype="timedelta64[D]") -// >>> np.mean(b) -// np.timedelta64(2,'D') -// -// 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 -// -// 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 zero or a positive integer. -// 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=-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()``. -// -// Raises -// ------ -// numpy.exceptions.TooHardError -// Exceeded max_work. -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// 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 -// -// 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 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. -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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(a *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object -// -// 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. -// -// 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. -// -// 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. -// -// 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. -// -// 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]) -// -// -//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. -// -// 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. -// -// 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 -// -------- -// >>> 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 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]) -// -// 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 -// -------- -// >>> 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) -// >>> 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. -// -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 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)``. -// -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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]) -// -// -// -//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. -// -// 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: -// -// >>> 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 Atan py.atan -func Atan(__llgo_va_list ...interface{}) *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. -// 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 `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 -// -------- -// >>> 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]]]) -// -// -//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 -// -// 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 '-') -// -// .. versionchanged:: 2.0 -// The sign parameter can now be an integer type, previously -// types were floating-point types. -// -// 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 ``'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. -// -// If set to `False`, disables legacy mode. -// -// Unrecognized strings will be ignored with a warning for forward -// compatibility. -// -// .. versionchanged:: 1.22.0 -// .. versionchanged:: 2.2 -// -// override_repr: callable, optional -// If set a passed function will be used for generating arrays' repr. -// Other options will be ignored. -// -// See Also -// -------- -// get_printoptions, printoptions, 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: -// -// >>> import numpy as np -// >>> 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], shape=(10,)) -// -// 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. ], shape=(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 -// -// Find the unique elements of an array, and counts, inverse, and indices. -// -// This function is an Array API compatible alternative to:: -// -// np.unique(x, return_index=True, return_inverse=True, -// return_counts=True, equal_nan=False, sorted=False) -// -// but returns a namedtuple for easier access to each output. -// -// .. 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. -// -// Returns -// ------- -// out : namedtuple -// The result containing: -// -// * 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. -// -// 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 UniqueAll py.unique_all -func UniqueAll(x *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. -// -// 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. -// -// 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 -// -------- -// >>> 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 -// -// -//go:linkname Flip py.flip -func Flip(m *py.Object, axis *py.Object) *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. https://mathworld.wolfram.com/SincFunction.html -// .. [2] Wikipedia, "Sinc function", -// https://en.wikipedia.org/wiki/Sinc_function -// -// 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]) -// -// >>> 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 -// -// 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 (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]`` -// -// -// 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.exceptions.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 `~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. -// -// 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 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 -// -// 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.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 -// -// 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 -// -// 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. -// -// 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 -// -------- -// >>> 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]]) -// -// >>> 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 -// -// 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. -// 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. -// -// 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 -// -// 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. -// -// .. 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 -// ------- -// 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 -// ----- -// 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: -// -// .. math:: -// -// \frac{\sum_i{|a_i - \bar{a}|^2 }}{N} -// -// 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. -// -// Many other libraries define the variance of an array differently, e.g.: -// -// .. math:: -// -// \frac{\sum_i{|a_i - \bar{a}|^2}}{N - 1} -// -// 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``. -// -// 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 -// -------- -// >>> 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]) -// -// 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) -// np.float32(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 -// -// 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 Var py.var -func Var(__llgo_va_list ...interface{}) *py.Object -// -// 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) -// -// but returns a namedtuple for easier access to each output. -// -// .. 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. -// -// 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`. -// -// See Also -// -------- -// unique : Find the unique elements of an array. -// -// 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]) -// -// -//go:linkname UniqueInverse py.unique_inverse -func UniqueInverse(x *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. -// 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) -// -// 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`. -// -// .. 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 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`. -// -// 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 -// -------- -// >>> 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. -// -// With ``keepdims=True``, the following result has shape (3, 1). -// -// >>> np.average(data, axis=1, keepdims=True) -// array([[0.5], -// [2.5], -// [4.5]]) -// -// >>> 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. -// -// -//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. -// -// 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`. -// -// 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. -// -// .. 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 -// -------- -// >>> 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: -// -// >>> np.nanmin([1, 2, np.nan, np.inf]) -// 1.0 -// >>> np.nanmin([1, 2, np.nan, -np.inf]) -// -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 -// -// 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. -// 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. -// -// 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 -// -------- -// >>> 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]) -// -// -//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. -// -// 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 -// -------- -// >>> 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. -// -// 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:: -// -// np.choose(a,c) == np.array([c[a[I]][I] for I in np.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 -// -------- -// -// >>> 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 -// -// 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 -// -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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: -// -// >>> import numpy as np -// -// >>> 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(__llgo_va_list ...interface{}) *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 -// -------- -// >>> 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)] -// -// -//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]) -// -// 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() -// -// 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 Absolute py.absolute -func Absolute(x *py.Object, out *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 -// -------- -// >>> 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 -// -// >>> 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 -// -// Gives a new shape to an array without changing its data. -// -// 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. -// -// -// 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 -// -------- -// >>> 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]) -// -// -// -//go:linkname Nanargmax py.nanargmax -func Nanargmax(__llgo_va_list ...interface{}) *py.Object -// -// Round to nearest integer towards zero. -// -// Round an array of floats element-wise to nearest integer towards zero. -// The rounded values have the same data-type as the input. -// -// 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. -// -// 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. -// -// See Also -// -------- -// rint, trunc, floor, ceil -// around : Round to 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.]) -// -// -// -//go:linkname Fix py.fix -func Fix(x *py.Object, out *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 -// -------- -// >>> import numpy as np -// >>> 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 -// arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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. -// -// 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, an error is -// raised. -// -// 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 -// -------- -// >>> 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 `. -// -// Returns -// ------- -// out : ndarray or scalar -// Output array of same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 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. -// 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 -// -// 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 -// -------- -// >>> 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]]) -// -// -// -//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) -// -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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]]]) -// -// >>> 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 -// -// 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. -// -// 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). -// unstack : Split an array into a tuple of sub-arrays along an axis. -// -// 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: -// -// >>> 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]]) -// -// -// -// -//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]) -// -// Return the cube-root of an array, element-wise. -// -// 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 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 -// -------- -// >>> import numpy as np -// >>> np.cbrt([1,8,27]) -// array([ 1., 2., 3.]) -// -//go:linkname Cbrt py.cbrt -func Cbrt(x *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 -// - sign : str -// - formatter : dict of callables -// - floatmode : str -// - legacy : str or False -// -// For a full description of these options, see `set_printoptions`. -// -// 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. -// -// 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. -// -// 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. -// -// Returns -// ------- -// indices : (m, 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. -// -// >>> import numpy as np -// >>> 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 according to two numerical keys, first by elements -// of ``a``, then breaking ties according to elements of ``b``: -// -// >>> 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)] -// -// Compare against `argsort`, which would sort each key independently. -// -// >>> np.argsort((b, a), kind='stable') -// array([[2, 4, 6, 5, 1, 3, 0], -// [0, 2, 4, 3, 5, 6, 1]]) -// -// 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. -// -// >>> arr = np.asarray([b, a]) -// >>> ind2 = np.lexsort(arr) -// >>> np.testing.assert_equal(ind2, ind) -// -// 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``. -// -// >>> np.testing.assert_equal(np.lexsort(arr, axis=0), -// ... np.lexsort(arr, axis=-1)) -// -// 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, -// -// >>> 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]]) -// -// Each row of the result is what we would expect if we were to perform -// `lexsort` on the corresponding row of the keys: -// -// >>> for i in range(3): -// ... print(np.lexsort((x[i], y[i]))) -// [2 3 0 1] -// [2 0 3 1] -// [1 0 3 2] -// -// -// -//go:linkname Lexsort py.lexsort -func Lexsort(keys *py.Object, axis *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 -// ----- -// 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]) -// -// >>> 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(__llgo_va_list ...interface{}) *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. -// -// 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. -// -// 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. -// 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) -// -// >>> 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 -// -// 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. -// -// 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. -// -// 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. -// -// 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]]) -// -// -// -//go:linkname RowStack py.row_stack -func RowStack(tup *py.Object) *py.Object -// -// Copies an array to a specified data type. -// -// This function is an Array API compatible alternative to -// `numpy.ndarray.astype`. -// -// 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 -// -// Returns -// ------- -// out : ndarray -// An array having the specified data type. -// -// See Also -// -------- -// ndarray.astype -// -// 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.]) -// -// Non-copy case: -// -// >>> arr = np.array([1, 2, 3]) -// >>> arr_noncpy = np.astype(arr, arr.dtype, copy=False) -// >>> np.shares_memory(arr, arr_noncpy) -// True -// -// -// -//go:linkname Astype py.astype -func Astype(x *py.Object, dtype *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``. -// 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. -// -// 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 -// -------- -// >>> 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]]) -// -// -//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. -// -// ``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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// ---------- -// 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`. -// -// 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 -// ----- -// 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. -// -// 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]]) -// -// -// -//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. -// -// 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. -// -// 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 -// -------- -// >>> 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. -// -// .. 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 -// -// 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. -// -// See Also -// -------- -// repeat : Repeat elements of an array. -// sort : Return a sorted copy 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:: 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. -// -// .. 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``. -// -// 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. -// -// 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) -// 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 -// arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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, `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``. -// -// 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 -// -------- -// >>> 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) -// -// 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 -// -------- -// >>> 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') -// -// >>> 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 -// maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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.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 -// -// 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 -// -------- -// >>> 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 -// -// -// -//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. -// -// 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 : 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. -// -// .. 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 -// -------- -// >>> 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]])) -// -// 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 -// -// 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`. -// -// .. warning:: The default `atol` is not appropriate for comparing numbers -// with magnitudes much smaller than one (see Notes). -// -// 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 : 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. -// -// 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 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`. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> np.arctanh([0, -0.5]) -// array([ 0. , -0.54930614]) -// -//go:linkname Atanh py.atanh -func Atanh(__llgo_va_list ...interface{}) *py.Object -// empty(shape, dtype=float, order='C', *, device=None, 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. -// 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 -// -// 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 -// ----- -// 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. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// 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 -// -------- -// >>> import numpy as np -// >>> 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', '`. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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(__llgo_va_list ...interface{}) *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 -// -// Examples -// -------- -// >>> import numpy as np -// -// 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 -// -// 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 -// -------- -// >>> 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 -// True -// >>> old_settings = np.seterr(**orig_settings) # restore original -// >>> old_handler = np.seterrcall(None) # restore original -// -// -// -//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. -// -// 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 -// -------- -// >>> 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]) -// -// >>> 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 -//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]) -// -// 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 ``x / abs(x)``, the -// generalization of the above (and ``0 if x==0``). -// -// .. versionchanged:: 2.0.0 -// Definition of complex sign changed to follow the Array API standard. -// -// 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, :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 -// -// 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. -// 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] -// -// 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]) -// -// 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 -// -// 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 -// -------- -// cumulative_prod : Array API compatible alternative for ``cumprod``. -// :ref:`ufuncs-output-type` -// -// Notes -// ----- -// Arithmetic is modular when using integer types, and no error is -// raised on overflow. -// -// 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.]) -// -// 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(__llgo_va_list ...interface{}) *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] -// -// >>> 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 -// -// 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. -// -// 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. -// -// 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. -// -// 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]]) -// -// -// -//go:linkname Vstack py.vstack -func Vstack(__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 -// 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. -// -// 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. -// -// 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) ` -// 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. -// -// 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)``. -// -// 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. -// -// 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. -// -// 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(subscripts *py.Object, __llgo_va_list ...interface{}) *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 | ``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 | | | -// +------------------------------------+---------------+-------------------+ -// -// Examples -// -------- -// >>> import numpy as np -// -// >>> 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 -// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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``. -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// -// 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. -// -// 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, 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. -// -// 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. -// -// .. 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. 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 -// -------- -// >>> 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 -// -// -// -//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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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. -// -// 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. -// where : array_like of bool, optional -// Elements to include in the product. See `~numpy.ufunc.reduce` -// for details. -// -// 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: -// -// >>> import numpy as np -// >>> 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 -// -// 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)) -// ... -// -// >>> import numpy as np -// -// >>> 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'} -// -// 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(orig_handler) -// -// >>> np.seterr(**orig_err) -// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} -// -// -// -//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. -// -// .. 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. -// -// .. 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. -// 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] -// >>> import numpy as np -// >>> 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.shares_memory(np.asarray(a, dtype=np.float32), a) -// True -// >>> np.shares_memory(np.asarray(a, dtype=np.float64), a) -// False -// -// Contrary to `asanyarray`, ndarray subclasses are not passed through: -// -// >>> 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 -// -//go:linkname Asarray py.asarray -func Asarray(a *py.Object, dtype *py.Object, order *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. 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. -// -// where : array_like of bool, optional -// Elements to compare for the maximum. See `~numpy.ufunc.reduce` -// for details. -// -// 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 -// -------- -// >>> 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 -// -// 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(__llgo_va_list ...interface{}) *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'. -// -// 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 -// -------- -// >>> 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) -// -// 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 -// -// 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. -// 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'. -// -// 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 -// -------- -// >>> 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 -// -// -// -//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. -// -// If element has complex type with zero imaginary 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 -// -------- -// >>> 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]) -// -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// -// 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 -// -------- -// >>> 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 -// -// 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 -// -// 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 -// -// with a and v sequences being zero-padded where necessary and -// :math:`\overline v` 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'. -// -// Returns -// ------- -// out : ndarray -// Discrete cross-correlation of `a` and `v`. -// -// See Also -// -------- -// convolve : Discrete, linear convolution of two one-dimensional sequences. -// 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 [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 -// -// 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. ]) -// -// 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 -//go:linkname Matmul py.matmul -func Matmul(__llgo_va_list ...interface{}) *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. -// -// 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. -// -// where : array_like of bool, optional -// Elements to compare for the minimum. See `~numpy.ufunc.reduce` -// for details. -// -// 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 -// -------- -// >>> 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]) -// -// 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 -// -// 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: -// -// >>> 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: -// -// >>> 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 -// floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// ----- -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 :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. -// -// 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 -// -------- -// >>> 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 -// -// >>> 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 Seterr py.seterr -func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *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. -// -// 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. -// -// 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]) -// -// -// -//go:linkname Angle py.angle -func Angle(z *py.Object, deg *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. -// 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`. -// -// 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. -// -// .. versionadded:: 2.0.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 -// ----- -// The behavior of `numpy.percentile` with percentage `q` is -// that of `numpy.quantile` with argument ``q/100``. -// For more information, please see `numpy.quantile`. -// -// 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.]]) -// -// >>> 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 -// -// 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 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. -// -// 'auto' -// Minimum bin width between 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' (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`. -// -// '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. -// -// Additionally, if the data is of integer dtype, then the binwidth will never -// be less than 1. -// -// 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. ]) -// -// 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 -// -// 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 -// -------- -// >>> 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. -// -// >>> 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 -// -// Set the size of the buffer used in ufuncs. -// -// .. 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. -// -// Parameters -// ---------- -// size : int -// Size of buffer. -// -// Returns -// ------- -// bufsize : int -// Previous size of ufunc buffer in bytes. -// -// Examples -// -------- -// When exiting a `numpy.errstate` context manager the bufsize is restored: -// -// >>> import numpy as np -// >>> with np.errstate(): -// ... np.setbufsize(4096) -// ... print(np.getbufsize()) -// ... -// 8192 -// 4096 -// >>> np.getbufsize() -// 8192 -// -// -// -//go:linkname Setbufsize py.setbufsize -func Setbufsize(size *py.Object) *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 -// -------- -// >>> 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. -// -// Examples -// -------- -// >>> import numpy as np -// -// 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 -// -// 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``. -// -// 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 -// -------- -// >>> import numpy as np -// -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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. ]]) -// -//go:linkname TrueDivide py.true_divide -func TrueDivide(__llgo_va_list ...interface{}) *py.Object -// -// Compute the median along the specified axis, while ignoring NaNs. -// -// 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 `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 -// -------- -// >>> 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) -// -// -// -//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]) -// -// 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, `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``. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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. -// -// 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 -// -------- -// >>> 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') -// -// -//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 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. -// -// 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. -// -// 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 -// -------- -// >>> 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.]) -// -// 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 -// -// 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`. -// 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. -// -// Parameters -// ---------- -// a : scalar or array_like -// The value whose minimal data type is to be found. -// -// Returns -// ------- -// out : dtype -// The minimal data type. -// -// 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. -// -// 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) -// -// 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]') -// -// -// -//go:linkname Diff py.diff -func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, append *py.Object) *py.Object -// -// Return a tuple 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. -// -// 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. -// 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 -// coordinates are used in an expression, broadcasting still leads to a -// fully-dimensonal result array. -// -// Default is False. -// -// 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. -// -// Returns -// ------- -// X1, X2,..., XN : tuple 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. -// :ref:`how-to-index` -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// 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. -// -// 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. -// -// 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 -// -------- -// >>> 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 -// -// -// -//go:linkname Squeeze py.squeeze -func Squeeze(a *py.Object, axis *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 -// -------- -// >>> import numpy as np -// >>> 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 -// 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. -// -// 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. -// -// 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 -// atleast_1d, atleast_2d, atleast_3d -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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.]]) -// -// >>> rng = np.random.default_rng() -// >>> A = rng.normal(size=(2,3,5)) -// >>> np.all(np.fliplr(A) == A[:,::-1,...]) -// True -// -// -// -//go:linkname Fliplr py.fliplr -func Fliplr(m *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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -// 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 tuple 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 -// -------- -// >>> 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 -// -// >>> 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 -// expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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. -// -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// less_equal(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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// `trapz` is deprecated in NumPy 2.0. -// -// Please use `trapezoid` instead, or one of the numerical integration -// functions in `scipy.integrate`. -// -// -//go:linkname Trapz py.trapz -func Trapz(y *py.Object, x *py.Object, dx *py.Object, axis *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. -// -// 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 -// -------- -// >>> 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.]]) -// -// -// -//go:linkname Nancumsum py.nancumsum -func Nancumsum(a *py.Object, axis *py.Object, dtype *py.Object, out *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 -// -------- -// >>> 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]]) -// -// 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 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 -// -------- -// >>> 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 Ndim py.ndim -func Ndim(__llgo_va_list ...interface{}) *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 : 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. -// -// 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 `~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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 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(__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 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]) -// -// 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 -// -------- -// >>> 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.]]) -// -// 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 -// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// Return a partitioned copy of an array. -// -// 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. -// -// 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. -// -// 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] -// -// 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 -// -// Find the unique elements and counts of an input array `x`. -// -// This function is an Array API compatible alternative to:: -// -// np.unique(x, return_counts=True, equal_nan=False, sorted=False) -// -// but returns a namedtuple for easier access to each output. -// -// .. 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. -// -// Returns -// ------- -// out : namedtuple -// The result containing: -// -// * values - The unique elements of an input array. -// * counts - The corresponding counts for each unique element. -// -// 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]) -// -// -//go:linkname UniqueCounts py.unique_counts -func UniqueCounts(x *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: -// -// >>> 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 -// -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 tuple of arrays, each with ``a.ndim >= 1``. -// Copies are made only if necessary. -// -// 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. -// -// 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 -// ----- -// 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. -// -// `argpartition` works for real/complex inputs with nan values, -// see `partition` for notes on the enhanced sort order and -// different selection algorithms. -// -// 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 -// -// Multi-dimensional array: -// -// >>> 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]]) -// -// -// -//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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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. ]]) -// -//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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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. -// -// 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]) -// -// -// -//go:linkname Setdiff1d py.setdiff1d -func Setdiff1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *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`. -// -// .. versionadded:: 2.0.0 -// -// 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 -// ------- -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// -// Use the trapezoidal rule on evenly spaced points: -// -// >>> np.trapezoid([1, 2, 3]) -// 4.0 -// -// 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: -// -// >>> np.trapezoid([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.trapezoid(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.trapezoid(np.cos(theta), x=np.sin(theta)) -// 3.141571941375841 -// -// ``np.trapezoid`` 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.trapezoid(a, axis=0) -// array([1.5, 2.5, 3.5]) -// >>> np.trapezoid(a, axis=1) -// array([2., 8.]) -// -// -//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). -// -// 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: -// -// >>> 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. -// -// 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 -// -------- -// >>> 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 Floor py.floor -func Floor(x *py.Object, out *py.Object) *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. -// -// 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 -// -------- -// >>> 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]) -// -// -//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 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.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. -// 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. -// -// .. 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. -// -// -// 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} } } -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// -// 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. -// -// 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 -// -------- -// >>> 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]]]) -// -// -// -//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, -// -// - 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. -// 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. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// -// Returns an array with axes transposed. -// -// 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]``. -// -// 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. -// -// 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. -// -// 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) -// -// >>> 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 Transpose py.transpose -func Transpose(a *py.Object, axes *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. -// -// 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 -// -------- -// >>> 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.]]) -// -// -// -//go:linkname Nancumprod py.nancumprod -func Nancumprod(a *py.Object, axis *py.Object, dtype *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 -// -------- -// 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. -// -// 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.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(__llgo_va_list ...interface{}) *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 -// -------- -// >>> 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]]) -// -// 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 -// 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``. -// -// 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 -// -------- -// >>> 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 Pow py.pow -func Pow(__llgo_va_list ...interface{}) *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 -// -------- -// >>> 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() -// -// -// -//go:linkname Hanning py.hanning -func Hanning(M *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 -// -// 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]) -// -// Inverse hyperbolic cosine, 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 -// ------- -// arccosh : ndarray -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// -// cosh, arcsinh, sinh, arctanh, tanh -// -// 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]``. -// -// 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 -// -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// -// 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], dtype=int32) -// >>> 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 -// exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.exp2([2, 3]) -// array([ 4., 8.]) -// -//go:linkname Exp2 py.exp2 -func Exp2(x *py.Object, out *py.Object) *py.Object -// greater(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. -// -// 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_equal, less, less_equal, equal, not_equal -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.greater([4,2],[2,2]) -// array([ True, False]) -// -// The ``>`` operator can be used as a shorthand for ``np.greater`` on -// ndarrays. -// -// >>> a = np.array([4, 2]) -// >>> b = np.array([2, 2]) -// >>> a > b -// array([ True, False]) -// -//go:linkname Greater py.greater -func Greater(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object -// -// 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} ]] -// -// 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 -// -// 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. -// 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. -// -// 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: -// -// >>> 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]]) -// -// 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(a *py.Object, b *py.Object, out *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 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]) -// -// Plot the window and the frequency response. -// -// .. plot:: -// :include-source: -// -// 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() -// -// -// -//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. -// -// 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 -// -------- -// >>> 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 -// -// 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 -// -------- -// >>> 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. -// -// 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.]) -// -// The cumulative product for each column (i.e., over the rows) of ``b``: -// -// >>> b = np.array([[1, 2, 3], [4, 5, 6]]) -// >>> np.cumulative_prod(b, axis=0) -// array([[ 1, 2, 3], -// [ 4, 10, 18]]) -// -// The cumulative product for each row (i.e. over the columns) of ``b``: -// -// >>> np.cumulative_prod(b, axis=1) -// array([[ 1, 2, 6], -// [ 4, 20, 120]]) -// -// -// -//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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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) -// -// >>> a = np.array([1, 2], dtype=int) -// >>> c = np.append(a, []) -// >>> c -// array([1., 2.]) -// >>> c.dtype -// float64 -// -// Default dtype for empty ndarrays is `float64` thus making the output of dtype -// `float64` when appended with dtype `int64` -// -// -// -//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. -// -// .. 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 -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// -// 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 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]') -// -// 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 -//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 -// -// Return the directory that contains the NumPy \*.h header files. -// -// Extension modules that need to compile against NumPy may need to use this -// function to locate the appropriate include directory. -// -// Notes -// ----- -// When using ``setuptools``, for example in ``setup.py``:: -// -// import numpy as np -// ... -// Extension('extension_name', ... -// include_dirs=[np.get_include()]) -// ... -// -// Note that a CLI tool ``numpy-config`` was introduced in NumPy 2.0, using -// that is likely preferred for build systems other than ``setuptools``:: -// -// $ numpy-config --cflags -// -I/path/to/site-packages/numpy/_core/include -// -// # Or rely on pkg-config: -// $ export PKG_CONFIG_PATH=$(numpy-config --pkgconfigdir) -// $ pkg-config --cflags -// -I/path/to/site-packages/numpy/_core/include -// -// Examples -// -------- -// >>> np.get_include() -// '.../site-packages/numpy/core/include' # may vary -// -// -// -//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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 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]) -// -// 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 -// -------- -// >>> 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) -// -// 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. -// -// 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 -// -------- -// >>> 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]) -// -// >>> 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 -// -// 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 -// -------- -// >>> 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. -// -// >>> 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 -// -// 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. 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. -// -// .. 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``. -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.any([[True, False], [True, True]]) -// True -// -// >>> np.any([[True, False, True ], -// ... [False, False, False]], axis=0) -// array([ True, False, True]) -// -// >>> np.any([-1, 0, 5]) -// True -// -// >>> np.any([[np.nan], [np.inf]], axis=1, keepdims=True) -// array([[ True], -// [ True]]) -// -// >>> np.any([[True, False], [False, False]], where=[[False], [True]]) -// False -// -// >>> 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]) -// -// >>> 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 -// float_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. 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). -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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]) -// -// >>> 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 -// -// 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. 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. -// -// 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. -// -// 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]]) -// -// -// -//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]) -// -// 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 -// -------- -// >>> 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 -// -// 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, array-like of ints or bools -// 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 -// -------- -// >>> 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]]) -// -// >>> 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 -// -// 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`. -// -// 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 -// -------- -// >>> 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.]) -// -// 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 -// -// 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 -// -------- -// >>> 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' -// -// -//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 -// -// 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. -// 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 -// -// 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 -// -------- -// >>> 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]]) -// -// >>> 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(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. -// -// 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 -// -------- -// >>> 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]]) -// -// -// -//go:linkname Resize py.resize -func Resize(a *py.Object, newShape *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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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 ]) -// -// Plot the window and the frequency response. -// -// .. plot:: -// :include-source: -// -// 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() -// -// 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() -// -// -// -//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 -// -// 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]) -// -//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 -// -// 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 -// -------- -// >>> 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]) -// -// -// -//go:linkname Putmask py.putmask -func Putmask(a *py.Object, mask *py.Object, values *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 -// -------- -// >>> 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]) -// -// >>> 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 -// -// 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) -// -// >>> import numpy as np -// -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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 -// -// -// -//go:linkname Imag py.imag -func Imag(val *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 -// -------- -// >>> 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]) -// -// -// -//go:linkname Isneginf py.isneginf -func Isneginf(x *py.Object, out *py.Object) *py.Object -// arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Inverse hyperbolic cosine, 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 -// ------- -// arccosh : ndarray -// Array of the same shape as `x`. -// This is a scalar if `x` is a scalar. -// -// See Also -// -------- -// -// cosh, arcsinh, sinh, arctanh, tanh -// -// 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]``. -// -// 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 -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.arccosh([np.e, 10.0]) -// array([ 1.65745445, 2.99322285]) -// >>> np.arccosh(1) -// 0.0 -// -//go:linkname Acosh py.acosh -func Acosh(__llgo_va_list ...interface{}) *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``: -// -// >>> 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='>> import numpy as np -// >>> np.unique_values([1, 1, 2]) -// array([1, 2]) # may vary -// -// -// -//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]) -// -// Computes the number of 1-bits in the absolute value of ``x``. -// Analogous to the builtin `int.bit_count` or ``popcount`` in C++. -// -// Parameters -// ---------- -// x : array_like, unsigned int -// 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 number of 1-bits in the input. -// Returns uint8 for all integer types -// This is a scalar if `x` is a scalar. -// -// References -// ---------- -// .. [1] https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel -// -// .. [2] Wikipedia, "Hamming weight", -// https://en.wikipedia.org/wiki/Hamming_weight -// -// .. [3] http://aggregate.ee.engr.uky.edu/MAGIC/#Population%20Count%20(Ones%20Count) -// -// 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]) -// -// 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 numpy as np -// -// >>> import matplotlib.pyplot as plt -// >>> import numpy as np -// -// >>> 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 -//go:linkname Rint py.rint -func Rint(__llgo_va_list ...interface{}) *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. -// 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. -// -// See Also -// -------- -// var, mean, nanmean, nanstd, nanvar -// :ref:`ufuncs-output-type` -// -// 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: -// -// .. 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. -// -// Many other libraries define the standard deviation of an array -// differently, e.g.: -// -// .. math:: -// -// \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N - 1}} -// -// 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``. -// -// 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 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. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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) -// 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% -// -// -// -//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,...]``. -// -// 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. -// 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 -// -------- -// >>> 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]) -// -// 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 -// -// 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 : file, str, or pathlib.Path -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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(file *py.Object, regexp *py.Object, dtype *py.Object, encoding *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. -// -// 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 -// -------- -// >>> 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 -// -// -//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 -// -// 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) -// -// -// -//go:linkname Concat py.concat -func Concat(__llgo_va_list ...interface{}) *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 -// -------- -// >>> 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 -// -// 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 -// -------- -// >>> 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]) -// -// -// -//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``. -// -// .. versionadded:: 2.0.0 -// -// 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. -// -// 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. -// -// 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. -// -// 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. -// -// 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). -// -// NaT now sorts to the end of arrays for consistency with NaN. -// -// 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', '`. -// -// 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. -// -// See Also -// -------- -// cos, arctan, arcsin, emath.arccos -// -// 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]`. -// -// 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. -// -// 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. -// -// The inverse `cos` is also known as `acos` or cos^-1. -// -// 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 -// -// Examples -// -------- -// >>> import numpy as np -// -// We expect the arccos of 1 to be 0, and of -1 to be pi: -// -// >>> np.arccos([1, -1]) -// array([ 0. , 3.14159265]) -// -// 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) -// -// 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: -// -// >>> import numpy as np -// >>> 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 -// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -// 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.]) -// -//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]) -// -// Vector dot product of two arrays. -// -// 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: -// -// .. math:: -// \mathbf{a} \cdot \mathbf{b} = \sum_{i=0}^{n-1} \overline{a_i}b_i -// -// 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. -// -// .. versionadded:: 2.0.0 -// -// 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 last axis removed. -// If not provided or None, a freshly-allocated array is used. -// **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. -// -// See Also -// -------- -// vdot : same but flattens arguments first -// matmul : Matrix-matrix product. -// vecmat : Vector-matrix product. -// matvec : Matrix-vector product. -// einsum : Einstein summation convention. -// -// Examples -// -------- -// >>> import numpy as np -// -// Get the projected size along a given normal for an array of vectors. -// -// >>> 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.]) -// -//go:linkname Vecdot py.vecdot -func Vecdot(x1 *py.Object, x2 *py.Object, out *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. -// -// -// 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 -// ----- -// 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 -// -------- -// >>> 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.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 -// from_dlpack(x, /, *, device=None, copy=None) -// -// 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. -// -// 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``. -// -// -// 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 # 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. -// -// 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 -// -------- -// >>> 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. -// -// 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_equal, greater_equal, equal, not_equal -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// ----- -// ``deg2rad(x)`` is ``x * pi / 180``. -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.deg2rad(180) -// 3.1415926535897931 -// -//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]) -// -// 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 -// -------- -// >>> 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]) -// -// -// -//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]) -// -// 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 -// ----- -// 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]) -// -// >>> 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 -// -// 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. -// -// 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.bytes_) -// True -// >>> np.issubdtype('i4', np.signedinteger) -// True -// -// -// -//go:linkname Issubdtype py.issubdtype -func Issubdtype(arg1 *py.Object, arg2 *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. -// -// 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. -// 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. -// -// 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)``. -// -// -// 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 -// -------- -// >>> 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])) -// -// >>> 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 -// -// Automated Bin Selection Methods example, using 2 peak random data -// with 2000 points. -// -// .. plot:: -// :include-source: -// -// import matplotlib.pyplot as plt -// import numpy as np -// -// 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 Histogram py.histogram -func Histogram(a *py.Object, bins *py.Object, range_ *py.Object, density *py.Object, weights *py.Object) *py.Object -// -// Save an array to a text file. -// -// 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 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'. -// -// 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 -// -------- -// >>> 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 -// -// -// -//go:linkname Savetxt py.savetxt -func Savetxt(__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 -// -------- -// >>> 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]) -// -// >>> 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 -// -// 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 -// -------- -// >>> 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]]) -// -// >>> 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 -// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Numerical positive, element-wise. -// -// 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 -// -------- -// >>> 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. -// -// 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. -// -// The result is a tuple of arrays split along ``axis``. -// -// .. versionadded:: 2.1.0 -// -// Parameters -// ---------- -// x : ndarray -// The array to be unstacked. -// axis : int, optional -// Axis along which the array will be split. Default: ``0``. -// -// Returns -// ------- -// unstacked : tuple of ndarrays -// The unstacked arrays. -// -// 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. -// -// Notes -// ----- -// ``unstack`` serves as the reverse operation of :py:func:`stack`, i.e., -// ``stack(unstack(x, axis=axis), axis=axis) == x``. -// -// This function is equivalent to ``tuple(np.moveaxis(x, axis, 0))``, since -// iterating on an array iterates along the first axis. -// -// 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_ -// -// -// -//go:linkname Unstack py.unstack -func Unstack(x *py.Object) *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. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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:: 2.0 -// The sign parameter can now be an integer type, previously -// types were floating-point types. -// -// 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. -// -// 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 -// -------- -// >>> 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.]' -// -// >>> 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 cumulative sum of the elements along a given axis. -// -// This function is an Array API compatible alternative to `numpy.cumsum`. -// -// Parameters -// ---------- -// x : array_like -// Input array. -// axis : int, optional -// Axis along which the cumulative sum 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 and of the accumulator in which the -// elements are summed. 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. -// 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. -// include_initial : bool, optional -// Boolean indicating whether to include the initial value (zeros) 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_sum_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``. -// -// See Also -// -------- -// 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. -// -// ``cumulative_sum(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.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 -// -// See Also -// -------- -// format_float_scientific -// -// 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. -// -// See `diag_indices` for full details. -// -// Parameters -// ---------- -// arr : array, at least 2-D -// -// See Also -// -------- -// diag_indices -// -// Examples -// -------- -// >>> import numpy as np -// -// 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 -// -// 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 -// -------- -// >>> 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]]]) -// -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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]]]) -// -// -// -//go:linkname Tril py.tril -func Tril(m *py.Object, k *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 -// -// 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 -// -// -// -//go:linkname Typename py.typename -func Typename(char *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. -// -// 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 -// -------- -// >>> 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]) -// -// 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 -// -------- -// >>> 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. -// -// >>> # 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 -// add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Add arguments element-wise. -// -// 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). -// 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 -// ------- -// add : ndarray or scalar -// The sum 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.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. -// -// 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``. -// -// .. versionadded:: 2.0.0 -// -// 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: -// -// >>> import numpy as np -// >>> 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 -// asanyarray(a, dtype=None, order=None, *, device=None, copy=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'. -// 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.1.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.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 -// -// 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. -// 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] -// >>> import numpy as np -// >>> np.asanyarray(a) -// array([1, 2]) -// -// Instances of `ndarray` subclasses are passed through as-is: -// -// >>> a = np.array([(1., 2), (3., 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 -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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: -// -// >>> 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.]) -// -// 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 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]) -// -// 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 : 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. -// -// See Also -// -------- -// greater, less, less_equal, equal, not_equal -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.greater_equal([4, 2, 1], [2, 2, 2]) -// array([ True, True, False]) -// -// 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``. -// -// This function only supports built-in NumPy's data types. -// Third-party dtypes are not yet supported. -// -// 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 -// -// Returns -// ------- -// out : bool -// -// See Also -// -------- -// issubdtype -// -// 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 -// -// -// -//go:linkname Isdtype py.isdtype -func Isdtype(dtype *py.Object, kind *py.Object) *py.Object -// -// Move axes of an array to new positions. -// -// Other axes remain in their original order. -// -// 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 -// -------- -// >>> 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) -// -// 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 -// -// 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 -// -------- -// >>> 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) -// -// -// -//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. -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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]) -// -// >>> 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 -// arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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: -// -// >>> 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.]) -// -// 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) -// -// 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 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 -// ===== ========= =================================================== -// -// 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. -// 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. -// copy: Return an array copy of the given object. -// -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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], dtype=int32) -// -// Creating an array from sub-classes: -// -// >>> np.array(np.asmatrix('1 2; 3 4')) -// array([[1, 2], -// [3, 4]]) -// -// >>> np.array(np.asmatrix('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 -// fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// with magnitudes much smaller than one (see Notes). -// -// 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. -// -// 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 -// ----- -// 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)`. -// -// 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`. -// -// `isclose` is not defined for non-numeric data types. -// :class:`bool` is considered a numeric data-type for this purpose. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// arange([start,] stop[, step,], dtype=None, *, device=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. -// 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 -// -// 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 -// -------- -// >>> 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]) -// -//go:linkname Arange py.arange -func Arange(start *py.Object, stop *py.Object, step *py.Object, dtype *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 -// -------- -// >>> import numpy as np -// >>> 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 -// heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// Compute the Heaviside step function. -// -// The Heaviside step function [1]_ 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. -// -// References -// ---------- -// .. [1] Wikipedia, "Heaviside step function", -// https://en.wikipedia.org/wiki/Heaviside_step_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.]) -// -//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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// 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. -// -// 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 -// -------- -// >>> 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 -// -// 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 -// -------- -// >>> 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])) -// -// >>> 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(__llgo_va_list ...interface{}) *py.Object -// -// Check if the array is Fortran contiguous but *not* C contiguous. -// -// This function is obsolete. 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). -// -// >>> 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 -// -// -// 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 -// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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. 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. -// -// .. 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``. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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(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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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]) -// -// >>> # 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 -// -// 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. -// -// Parameters -// ---------- -// a, b : array_like -// Tensors to "dot". -// -// 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. -// -// Returns -// ------- -// output : ndarray -// The tensor dot product of the input. -// -// See Also -// -------- -// dot, einsum -// -// 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` -// -// 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`. -// -// 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 shape of the result consists of the non-contracted axes of the -// first tensor, followed by the non-contracted axes of the second. -// -// Examples -// -------- -// An example on integer_like: -// -// >>> 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]]]]) -// -// An example on array_like: -// -// >>> 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 -// vecmat(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, axes, axis]) -// -// Vector-matrix dot product of two arrays. -// -// 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)``.) -// -// .. versionadded:: 2.2.0 -// -// 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 `. -// -// Returns -// ------- -// y : ndarray -// The vector-matrix product of the inputs. -// -// Raises -// ------ -// ValueError -// If the last dimensions of ``x1`` and the one-but-last dimension of -// ``x2`` are not the same size. -// -// If a scalar value is passed in. -// -// See Also -// -------- -// vecdot : Vector-vector product. -// matvec : Matrix-vector product. -// matmul : Matrix-matrix product. -// einsum : Einstein summation convention. -// -// 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 -// -// 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 -// `element` and `test_elements`, 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. -// * 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`, -// 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`. -// -// 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(test_elements)) > -// (log10(max(test_elements)-min(test_elements)) - 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. -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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. 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``. -// -// .. versionadded:: 2.1.0 -// **kwargs -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// 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 -// -------- -// >>> 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]) -// -// -// -//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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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.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. -// -// 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 -// -------- -// >>> 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. ]]) -// -// 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 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 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() -// -// -// -//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. -// -// 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 -// specified in the axis parameter. -// Default: 1. (see Examples below). -// -// 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. -// -// 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. -// -// Examples -// -------- -// >>> 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 ]) -// -// 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.]) -// >>> 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]])) -// (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]]), 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]]), axis=0) -// array([[ 2., 2., -1.], -// [ 2., 2., -1.]]) -// -// 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.]])) -// -// 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 -// -// 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, -// 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`. -// -// 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 -// -------- -// >>> 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) -// -// -// -//go:linkname Median py.median -func Median(a *py.Object, axis *py.Object, out *py.Object, overwriteInput *py.Object, keepdims *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 -// -------- -// >>> 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. -// -// 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: -// -// 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. For backward compatibility -// with previous versions of NumPy, the following discontinuous variations -// of the default 'linear' (7.) option are available: -// -// * 'lower' -// * 'higher', -// * 'midpoint' -// * 'nearest' -// -// See Notes for details. -// -// .. 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`. -// -// 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. -// -// .. 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 -// 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 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. -// -// 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 -// -// -// -//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 -// -// 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 -// -------- -// >>> 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]) -// -// 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 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. -// -// 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 -// -------- -// >>> 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]]) -// -// 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 -// -// 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 -// -------- -// >>> 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 -// -// >>> 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 -// -// 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 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]) -// -// -// Plot the window and the frequency response. -// -// .. 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 Kaiser py.kaiser -func Kaiser(M *py.Object, beta *py.Object) *py.Object -// Remove values along a dimension which are zero along all other. -// -// 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 -// -// Returns -// ------- -// trimmed : ndarray or sequence -// The result of trimming the input. The number of dimensions and the -// input data type are preserved. -// -// Notes -// ----- -// For all-zero arrays, the first axis is trimmed first. -// -// Examples -// -------- -// >>> 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]) -// -// Multiple dimensions are supported. -// -// >>> 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.trim_zeros(b, axis=-1) -// array([[0, 2, 3], -// [1, 0, 3], -// [0, 0, 0]]) -// -// 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, axis *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 : tuple of ndarrays -// A tuple of D arrays describing the bin edges for each dimension. -// -// See Also -// -------- -// histogram: 1-D histogram -// histogram2d: 2-D histogram -// -// 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. -// -// For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised. -// -// 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 -// -------- -// >>> 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 Nanmean py.nanmean -func Nanmean(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object, keepdims *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. -// -// 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. -// -// 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 -// 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 -// ----- -// The behavior of `numpy.nanquantile` is the same as that of -// `numpy.quantile` (ignoring nan values). -// For more information, please see `numpy.quantile`. -// -// 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.quantile(a, 0.5) -// np.float64(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 -// 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``. -// -// 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 -// -------- -// >>> 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`. -// -// See Also -// -------- -// dot : Return the dot product without using the complex conjugate of the -// first argument. -// -// 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) -// -// 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 -// 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. -// 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 -// -// Convert a list into an array. If all elements are finite, then -// ``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 -// -// 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. -// 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 -// -// 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 -// -------- -// >>> 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.]) -// -// 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 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 qth percentile of the data along the specified axis, -// while ignoring nan values. -// -// Returns the qth percentile(s) of the array elements. -// -// 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. -// -// 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. -// -// .. 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 -// ----- -// 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`. -// -// 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 -// -// -// -//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. -// -// For all-NaN slices or slices with zero degrees of freedom, NaN is -// returned and a `RuntimeWarning` is raised. -// -// 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. -// -// .. 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 var 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 -// ------- -// 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 -// -------- -// >>> 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 -// -// -// -//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 -// -// 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 -// -------- -// >>> 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)] -// -// -// -//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 `. -// -// .. 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 -// -------- -// >>> 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) -// -// -//go:linkname BroadcastShapes py.broadcast_shapes -func BroadcastShapes(__llgo_va_list ...interface{}) *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 -// -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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]) -// -// >>> 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 -//go:linkname RightShift py.right_shift -func RightShift(__llgo_va_list ...interface{}) *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 -// -------- -// >>> 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]) -// -// -// -//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 `. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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: -// -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// -// Define the signum 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 -//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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// 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 -// -------- -// >>> 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 result can be used to construct a datetime that uses the same units -// as a timedelta -// -// >>> np.datetime64('2010', np.datetime_data(dt_25s)) -// np.datetime64('2010-01-01T00:00:00','25s') -// -//go:linkname DatetimeData py.datetime_data -func DatetimeData(dtype *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 -// -// `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. -// -// 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 -// -------- -// >>> 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 -// -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// -// 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``. -// -// >>> 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]) -// -// When multiple conditions are satisfied, the first one encountered in -// `condlist` is used. -// -// >>> 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 -// -// 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 -// -// >>> import numpy as np -// -// >>> 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(__llgo_va_list ...interface{}) *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 -// -------- -// >>> 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]) -// -// -// -//go:linkname Polyval py.polyval -func Polyval(p *py.Object, x *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 -// -------- -// >>> 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.])] -// -// >>> 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 -// invert(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. -// -// 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 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`. -// -// 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 -// ----- -// ``numpy.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 -// -// 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 -// np.uint8(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 -// np.uint16(65522) -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types, the result is the bit-wise NOT of -// the unsigned type, interpreted as a signed integer: -// -// >>> 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 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. -// -// 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 -// -------- -// >>> 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. -// -// 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. `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. -// -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// 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. -// -// 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 -// -------- -// >>> import numpy as np -// >>> np.spacing(1) == np.finfo(np.float64).eps -// True -// -//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]) -// -// 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 -// -------- -// >>> 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) -// -//go:linkname Tan py.tan -func Tan(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 -// -------- -// >>> 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]]) -// -// -// -//go:linkname Ix_ py.ix_ -func Ix_(__llgo_va_list ...interface{}) *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. -// -// 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 -// -------- -// >>> 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.]) -// -// -// -//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 -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// -// -//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]) -// -// 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 -// -------- -// >>> 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) -// -// -// -//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]) -// -// 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 -// -------- -// >>> 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 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``. -// -// This function is Array API compatible. -// -// Parameters -// ---------- -// x : array_like -// Input array having shape (..., M, N) and whose two innermost -// dimensions form ``MxN`` matrices. -// -// Returns -// ------- -// out : ndarray -// An array containing the transpose for each matrix and having shape -// (..., N, M). -// -// See Also -// -------- -// transpose : Generic transpose method. -// -// Examples -// -------- -// >>> import numpy as np -// >>> np.matrix_transpose([[1, 2], [3, 4]]) -// array([[1, 3], -// [2, 4]]) -// -// >>> np.matrix_transpose([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) -// array([[[1, 3], -// [2, 4]], -// [[5, 7], -// [6, 8]]]) -// -// -// -//go:linkname MatrixTranspose py.matrix_transpose -func MatrixTranspose(__llgo_va_list ...interface{}) *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 -// ----- -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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. 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. -// where : array_like of bool, optional -// Elements to include in the sum. See `~numpy.ufunc.reduce` for details. -// -// 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: ``numpy.add.reduce`` equivalent function. -// cumsum : Cumulative sum of array elements. -// trapezoid : Integration of array values using 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 -// -------- -// >>> 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.]) -// -// If the accumulator is too small, overflow occurs: -// -// >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8) -// 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(__llgo_va_list ...interface{}) *py.Object -// -// Insert values along the given axis before the given indices. -// -// 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. -// -// .. 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. -// -// 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``. This is because of the difference between basic -// and advanced :ref:`indexing `. -// -// Examples -// -------- -// >>> import numpy as np -// >>> a = np.arange(6).reshape(3, 2) -// >>> 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 -// -// >>> 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]) -// -// >>> np.insert(b, slice(2, 4), [7, 8]) -// array([0, 1, 7, 2, 8, 3, 4, 5]) -// -// >>> np.insert(b, [2, 2], [7.13, False]) # type casting -// array([0, 1, 7, 0, 2, 3, 4, 5]) -// -// >>> 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 -// -// 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. -// -// 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 -// -------- -// >>> 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 -// -// 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 -// -// 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 -// invert(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. -// -// 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 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`. -// -// 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 -// ----- -// ``numpy.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 -// -// 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 -// np.uint8(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 -// np.uint16(65522) -// >>> np.binary_repr(x, width=16) -// '1111111111110010' -// -// When using signed integer types, the result is the bit-wise NOT of -// the unsigned type, interpreted as a signed integer: -// -// >>> 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 -// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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'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)``. -// -// 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 -// -------- -// >>> 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]) -// -// 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 -// -// 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. -// -// 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. -// -// Examples -// -------- -// >>> 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]) -// -// 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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``. -// order : {'C', 'F'}, optional -// Determines whether the indices should be viewed as indexing in -// row-major (C-style) or column-major (Fortran-style) order. -// -// 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 -// -------- -// >>> 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. -// -// 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. -// -// .. 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 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 -// `_. -// -// 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', '>> 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 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 -// -// 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. -// 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`. -// -// .. 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`. -// -// The strings produced by the Python float.hex method can be used as -// input for floats. -// -// 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.]]) -// -// `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("-") 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, such as hex values: -// -// >>> 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]) -// -// Or a format where the ``-`` sign comes after the number: -// -// >>> 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]]) -// -// 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 -// -// 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 -//go:linkname Log py.log -func Log(__llgo_va_list ...interface{}) *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. -// -// 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 -// -------- -// >>> import numpy as np -// -// 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 -// 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 -// -// 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]]) -// -// -//go:linkname BroadcastTo py.broadcast_to -func BroadcastTo(array *py.Object, shape *py.Object, subok *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 -// -------- -// >>> import numpy as np -// -// 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 -// -// -//go:linkname TriuIndicesFrom py.triu_indices_from -func TriuIndicesFrom(arr *py.Object, k *py.Object) *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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -// Examples -// -------- -// >>> import numpy as np -// >>> 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 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 -// -------- -// >>> 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]) -// -// >>> 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 -// -// 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 -// -------- -// >>> 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. -// -// 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.]]) -// -// 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 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 -// -// 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]]) -// -// 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 -// -// 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 -// -------- -// >>> 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]]]) -// -// -// -//go:linkname Dstack py.dstack -func Dstack(tup *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 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). -// -// 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 -// -------- -// >>> 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]]]) -// -// >>> 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 -// -// 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 -// 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 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. -// -// See also -// -------- -// triu_indices : similar function, for upper-triangular. -// mask_indices : generic function accepting an arbitrary mask function. -// tril, triu -// -// Examples -// -------- -// >>> import numpy as np -// -// 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) -// >>> il1 -// (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) -// -// 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.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): -// -// >>> 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]]) -// -// -// -//go:linkname TrilIndices py.tril_indices -func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *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. -// -// 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 -// -// Returns an array with axes transposed. -// -// 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]``. -// -// 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. -// -// 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. -// -// 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) -// -// >>> 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 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]) -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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). -// -// 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 -// -// 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`. -// -// Examples -// -------- -// >>> import numpy as np -// -// 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]) -// -// -//go:linkname Copy py.copy -func Copy(a *py.Object, order *py.Object, subok *py.Object) *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 -// -------- -// >>> 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.]) -// -// -//go:linkname Unwrap py.unwrap -func Unwrap(p *py.Object, discont *py.Object, axis *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 different versions of Python). -// Default: True -// fix_imports : bool, optional -// The `fix_imports` flag is deprecated and has no effect. -// -// .. 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. -// -// 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 -// -------- -// >>> 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 -// -// 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 -// -------- -// >>> import numpy as np -// >>> 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 -// -// 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 -// -------- -// >>> 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 -// -// -// -//go:linkname Real py.real -func Real(val *py.Object) *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 -// -------- -// >>> 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') -// -// 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 -// conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature]) -// -// 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 -// -------- -// >>> 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 Conjugate py.conjugate -func Conjugate(x *py.Object, out *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 -// -------- -// >>> 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]]) -// -// >>> 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