From fecb2eb3c7b75b1149e8df7b230e6243eb178ce9 Mon Sep 17 00:00:00 2001 From: Eli Belash Date: Mon, 20 Jul 2026 21:17:07 +0300 Subject: [PATCH 1/3] Add NumPy API coverage dashboard and CI artifact --- .github/workflows/build-and-release.yml | 40 +- .github/workflows/docs.yml | 1 + README.md | 10 + coverage/README.md | 34 + coverage/audit_documentation.py | 78 + coverage/generate_coverage.py | 683 + coverage/generated/coverage.csv | 795 + coverage/generated/coverage.json | 19979 ++++++++++++++++ coverage/generated/manifest.json | 349 + coverage/generated/summary.md | 74 + coverage/overrides.json | 115 + docs/website-src/docfx.json | 5 + .../docs/coverage-support-dashboard.md | 851 + docs/website-src/docs/toc.yml | 2 + .../coverage-support-capability-map.png | Bin 0 -> 50603 bytes .../coverage-support-surface-scoreboard.png | Bin 0 -> 54448 bytes docs/website-src/toc.yml | 2 + .../NumSharp.ApiInventory.csproj | 14 + tools/NumSharp.ApiInventory/Program.cs | 168 + 19 files changed, 23199 insertions(+), 1 deletion(-) create mode 100644 coverage/README.md create mode 100644 coverage/audit_documentation.py create mode 100644 coverage/generate_coverage.py create mode 100644 coverage/generated/coverage.csv create mode 100644 coverage/generated/coverage.json create mode 100644 coverage/generated/manifest.json create mode 100644 coverage/generated/summary.md create mode 100644 coverage/overrides.json create mode 100644 docs/website-src/docs/coverage-support-dashboard.md create mode 100644 docs/website-src/images/coverage-support-capability-map.png create mode 100644 docs/website-src/images/coverage-support-surface-scoreboard.png create mode 100644 tools/NumSharp.ApiInventory/NumSharp.ApiInventory.csproj create mode 100644 tools/NumSharp.ApiInventory/Program.cs diff --git a/.github/workflows/build-and-release.yml b/.github/workflows/build-and-release.yml index 4e45f0771..8a3b3c1dd 100644 --- a/.github/workflows/build-and-release.yml +++ b/.github/workflows/build-and-release.yml @@ -19,6 +19,44 @@ env: DOTNET_NOWARN: CS1570%3BCS1571%3BCS1572%3BCS1573%3BCS1574%3BCS1587%3BCS1591%3BCS1711%3BCS1734%3BCS8981%3BNU5048 jobs: + api-coverage: + name: NumPy ↔ NumSharp API coverage + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: 8.0.x + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: '3.12' + + - name: Install pinned NumPy reference + run: python -m pip install numpy==2.4.2 + + - name: Generate coverage artifact + run: python coverage/generate_coverage.py --output artifacts/numpy-numsharp-coverage + + - name: Audit latest NumPy documentation links + run: python coverage/audit_documentation.py artifacts/numpy-numsharp-coverage/coverage.json + + - name: Verify checked-in dashboard data + run: diff --recursive --unified coverage/generated artifacts/numpy-numsharp-coverage + + - name: Upload coverage artifact + uses: actions/upload-artifact@v4 + if: always() + with: + name: numpy-numsharp-api-coverage + path: artifacts/numpy-numsharp-coverage/ + if-no-files-found: error + retention-days: 14 + test: strategy: fail-fast: false @@ -90,7 +128,7 @@ jobs: retention-days: 5 validate-release: - needs: test + needs: [test, api-coverage] if: startsWith(github.ref, 'refs/tags/v') runs-on: ubuntu-latest outputs: diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 00e82720c..4146b6612 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -5,6 +5,7 @@ on: branches: ["master", "main"] paths: - 'src/**' + - 'coverage/generated/**' - 'docs/website-src/**' workflow_dispatch: diff --git a/README.md b/README.md index 56ace902e..cd8ec6fee 100644 --- a/README.md +++ b/README.md @@ -74,6 +74,16 @@ NumSharp focuses on: raw reports, and subsystem matrices. See the [benchmark dashboard](https://scisharp.github.io/NumSharp/docs/benchmarks-dashboard.md). +## Features Support and Implementation Map + +[NumSharp's Coverage & Support Dashboard](https://scisharp.github.io/NumSharp/docs/coverage-support-dashboard.html) is presenting the full implementation +roadmap to complete 100% NumPy porting with an explorer allowing you to quickly check your favorite functions! + +

+ NumSharp API coverage surface scoreboard + NumSharp API coverage capability map +

+ ## Performance [NumSharp benchmarks](https://scisharp.github.io/NumSharp/docs/benchmarks-dashboard.html) are published as tracked release snapshots, not ad hoc diff --git a/coverage/README.md b/coverage/README.md new file mode 100644 index 000000000..aad57c88c --- /dev/null +++ b/coverage/README.md @@ -0,0 +1,34 @@ +# NumPy ↔ NumSharp API coverage + +This directory is the reproducible source for NumSharp's public API coverage artifact. It compares the public exports of pinned NumPy **2.4.2** with the public surface of the compiled NumSharp assembly. + +## Generate or verify + +```bash +python -m pip install numpy==2.4.2 +python coverage/generate_coverage.py +python coverage/generate_coverage.py --check +python coverage/audit_documentation.py +``` + +Generated, reviewable outputs live in `coverage/generated/`: + +- `coverage.json` — complete machine-readable inventory used by the documentation dashboard. +- `coverage.csv` — flat data for spreadsheets and downstream tooling. +- `summary.md` — human-readable totals and the highest-priority gaps. +- `manifest.json` — schema, tool versions, scope, and counting rules. + +CI generates a fresh copy under `artifacts/numpy-numsharp-coverage/`, validates every headline-scope link against NumPy's official latest-stable Sphinx inventory, compares the result byte-for-byte with the checked-in dashboard data, and uploads the fresh directory as the `numpy-numsharp-api-coverage` artifact. + +## What the numbers mean + +The default denominator includes NumPy top-level callables, `ndarray` methods and properties, and callables from `numpy.random`, `numpy.linalg`, and `numpy.fft`. NumPy types, constants, and modules are catalogued but do not affect the headline percentage. NumSharp-only APIs are catalogued separately and also do not affect it. + +- **Exact** — the corresponding NumSharp surface has the same public member name. +- **Alias** — a reviewed or mechanically safe C# equivalent exists under another name or surface. +- **Partial** — an API exists, but the reviewed mapping has a known semantic limitation. +- **Unsupported** — a public compatibility symbol exists but does not implement the NumPy capability. +- **Missing** — no NumSharp public API mapping was found. +- **NumSharp-only** — an unmatched public member declared by `np`, `NDArray`, or `NumPyRandom`; these rows link directly to their declaration on GitHub. + +API availability is not a blanket behavioral-parity claim. Exact edge-case, dtype, layout, and signature parity still requires differential tests. Record reviewed exceptions and cross-surface aliases in `coverage/overrides.json`; the generator validates every referenced NumSharp target. diff --git a/coverage/audit_documentation.py b/coverage/audit_documentation.py new file mode 100644 index 000000000..5a31ba722 --- /dev/null +++ b/coverage/audit_documentation.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""Audit dashboard links against NumPy's official latest-stable Sphinx inventory.""" + +from __future__ import annotations + +import argparse +import json +import time +import urllib.request +import zlib +from pathlib import Path + + +INVENTORY_URL = "https://numpy.org/doc/stable/objects.inv" +DOCS_BASE_URL = "https://numpy.org/doc/stable/" + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "coverage_json", + nargs="?", + type=Path, + default=Path(__file__).resolve().parent / "generated" / "coverage.json", + ) + return parser.parse_args() + + +def download_inventory() -> bytes: + request = urllib.request.Request(INVENTORY_URL, headers={"User-Agent": "NumSharp coverage audit/1.0"}) + error: Exception | None = None + for attempt in range(3): + try: + with urllib.request.urlopen(request, timeout=30) as response: + return response.read() + except Exception as current_error: # pragma: no cover - network-dependent retry + error = current_error + if attempt < 2: + time.sleep(1 + attempt) + raise SystemExit(f"Unable to download NumPy documentation inventory: {error}") + + +def documented_pages(raw: bytes) -> set[str]: + position = 0 + for _ in range(4): + position = raw.index(b"\n", position) + 1 + entries = zlib.decompress(raw[position:]).decode("utf-8").splitlines() + pages: set[str] = set() + for entry in entries: + parts = entry.split(" ", 4) + if len(parts) != 5: + continue + uri = parts[3].replace("$", parts[0]).split("#", 1)[0] + pages.add(DOCS_BASE_URL + uri) + return pages + + +def main() -> None: + args = parse_args() + payload = json.loads(args.coverage_json.read_text(encoding="utf-8")) + pages = documented_pages(download_inventory()) + rows = [ + row for row in payload["rows"] + if row["origin"] == "numpy" and row["in_default_scope"] + ] + missing = [ + (row["id"], row["documentation_url"]) + for row in rows + if not row["documentation_url"] or row["documentation_url"].split("#", 1)[0] not in pages + ] + if missing: + details = "\n".join(f" - {api_id}: {url or ''}" for api_id, url in missing) + raise SystemExit(f"{len(missing)} coverage links are absent from NumPy's official inventory:\n{details}") + print(f"Validated {len(rows)} latest-stable NumPy documentation links against objects.inv.") + + +if __name__ == "__main__": + main() diff --git a/coverage/generate_coverage.py b/coverage/generate_coverage.py new file mode 100644 index 000000000..be5bba822 --- /dev/null +++ b/coverage/generate_coverage.py @@ -0,0 +1,683 @@ +#!/usr/bin/env python3 +"""Generate the deterministic NumPy <-> NumSharp public API coverage artifact.""" + +from __future__ import annotations + +import argparse +import csv +import inspect +import io +import json +import re +import subprocess +import sys +from collections import Counter +from pathlib import Path +from typing import Any +from urllib.parse import quote + + +ROOT = Path(__file__).resolve().parents[1] +PINNED_NUMPY_VERSION = "2.4.2" +GENERATOR_VERSION = "1.1.0" +OUTPUT_FILES = ("coverage.json", "coverage.csv", "summary.md", "manifest.json") +NUMSHARP_SOURCE_BASE_URL = "https://github.com/SciSharp/NumSharp/blob/master/" + +CALLABLE_KINDS = {"function", "ufunc", "callable", "method"} +VALID_SUPPORT = {"declared", "partial", "unsupported", "missing", "extension"} + +CREATION = { + "arange", "array", "asanyarray", "asarray", "asarray_chkfinite", "ascontiguousarray", + "asfortranarray", "asmatrix", "copy", "empty", "empty_like", "eye", "frombuffer", + "from_dlpack", "fromfile", "fromfunction", "fromiter", "fromregex", "fromstring", "full", + "full_like", "genfromtxt", "identity", "loadtxt", "linspace", "logspace", "meshgrid", + "mgrid", "ogrid", "ones", "ones_like", "require", "tri", "tril", "triu", "vander", + "zeros", "zeros_like" +} +MANIPULATION = { + "append", "apply_along_axis", "apply_over_axes", "array_split", "atleast_1d", "atleast_2d", + "atleast_3d", "block", "broadcast_arrays", "broadcast_to", "column_stack", "concat", + "concatenate", "delete", "dsplit", "dstack", "expand_dims", "flip", "fliplr", "flipud", + "hsplit", "hstack", "insert", "matrix_transpose", "moveaxis", "pad", "permute_dims", + "ravel", "repeat", "reshape", "resize", "roll", "rollaxis", "rot90", "row_stack", + "split", "squeeze", "stack", "swapaxes", "tile", "transpose", "trim_zeros", "unstack", + "vsplit", "vstack" +} +REDUCTIONS = { + "all", "amax", "amin", "any", "argmax", "argmin", "average", "count_nonzero", "cumprod", + "cumsum", "cumulative_prod", "cumulative_sum", "max", "mean", "median", "min", "nanargmax", + "nanargmin", "nancumprod", "nancumsum", "nanmax", "nanmean", "nanmedian", "nanmin", + "nanpercentile", "nanprod", "nanquantile", "nanstd", "nansum", "nanvar", "percentile", + "prod", "ptp", "quantile", "std", "sum", "var" +} +LOGIC = { + "allclose", "array_equal", "array_equiv", "equal", "fmax", "fmin", "greater", "greater_equal", + "isclose", "iscomplex", "iscomplexobj", "isfinite", "isfortran", "isinf", "isnan", "isneginf", + "isposinf", "isreal", "isrealobj", "isscalar", "less", "less_equal", "logical_and", + "logical_not", "logical_or", "logical_xor", "maximum", "minimum", "not_equal" +} +DTYPE = { + "can_cast", "common_type", "dtype", "finfo", "find_common_type", "iinfo", "issubdtype", + "min_scalar_type", "mintypecode", "promote_types", "result_type", "sctypeDict", "typecodes" +} +SELECTION = { + "choose", "compress", "diag_indices", "diag_indices_from", "extract", "indices", "ix_", "mask_indices", + "place", "put", "put_along_axis", "ravel_multi_index", "select", "take", "take_along_axis", + "tril_indices", "tril_indices_from", "triu_indices", "triu_indices_from", "unravel_index", "where" +} +SORTING = {"argpartition", "argsort", "argwhere", "flatnonzero", "lexsort", "nonzero", "partition", "searchsorted", "sort"} +IO = {"fromfile", "fromregex", "fromstring", "genfromtxt", "load", "loads", "loadtxt", "save", "savetxt", "savez", "savez_compressed"} +MATH = { + "abs", "absolute", "acos", "acosh", "add", "arccos", "arccosh", "arcsin", "arcsinh", "arctan", + "arctan2", "arctanh", "asin", "asinh", "atan", "atan2", "atanh", "bitwise_and", "bitwise_count", + "bitwise_invert", "bitwise_left_shift", "bitwise_not", "bitwise_or", "bitwise_right_shift", "bitwise_xor", + "cbrt", "ceil", "clip", "conj", "conjugate", "convolve", "copysign", "cos", "cosh", "cross", + "deg2rad", "degrees", "diff", "divide", "divmod", "dot", "ediff1d", "exp", "exp2", "expm1", + "fabs", "fix", "floor", "floor_divide", "fmod", "frexp", "gcd", "heaviside", "hypot", "inner", + "invert", "kron", "lcm", "ldexp", "left_shift", "log", "log10", "log1p", "log2", "logaddexp", + "logaddexp2", "matmul", "mod", "modf", "multiply", "negative", "nextafter", "outer", "positive", + "pow", "power", "rad2deg", "radians", "reciprocal", "remainder", "right_shift", "rint", "round", + "sign", "signbit", "sin", "sinc", "sinh", "spacing", "sqrt", "square", "subtract", "tan", "tanh", + "trace", "true_divide", "trunc" +} + +# NumPy exposes several coherent routine families from the top-level namespace that +# do not fit the broad creation/manipulation/math buckets above. Keep these explicit +# so the dashboard's capability map remains useful instead of hiding gaps in "Other". +CATEGORY_OVERRIDES = { + **dict.fromkeys({"copyto", "iterable", "may_share_memory", "nested_iters", "shares_memory"}, "Array metadata & memory"), + **dict.fromkeys({"busday_count", "busday_offset", "datetime_as_string", "datetime_data", "is_busday", "isnat"}, "Date & time"), + **dict.fromkeys({"getbufsize", "geterr", "geterrcall", "nan_to_num", "setbufsize", "seterr", "seterrcall"}, "Floating-point handling"), + **dict.fromkeys({"bmat", "diag", "diagflat", "diagonal", "einsum", "einsum_path", "fill_diagonal", "matvec", "tensordot", "vdot", "vecdot", "vecmat"}, "Linear algebra"), + **dict.fromkeys({"poly", "polyadd", "polyder", "polydiv", "polyfit", "polyint", "polymul", "polysub", "polyval", "roots"}, "Polynomials"), + **dict.fromkeys({"get_include", "info", "show_config", "show_runtime", "test"}, "Runtime & diagnostics"), + **dict.fromkeys({"intersect1d", "isin", "setdiff1d", "setxor1d", "union1d", "unique", "unique_all", "unique_counts", "unique_inverse", "unique_values"}, "Set operations"), + **dict.fromkeys({"bincount", "corrcoef", "correlate", "cov", "digitize", "histogram", "histogram2d", "histogram_bin_edges", "histogramdd"}, "Statistics & histograms"), + **dict.fromkeys({"array2string", "array_repr", "array_str", "base_repr", "binary_repr", "format_float_positional", "format_float_scientific", "get_printoptions", "printoptions", "set_printoptions", "typename"}, "Text & formatting"), + **dict.fromkeys({"bartlett", "blackman", "hamming", "hanning", "kaiser"}, "Window functions"), +} + +MATH.update({"angle", "around", "float_power", "frompyfunc", "gradient", "i0", "imag", "interp", "packbits", "piecewise", "real", "real_if_close", "trapezoid", "unpackbits", "unwrap"}) +CREATION.add("geomspace") +DTYPE.update({"astype", "isdtype"}) +MANIPULATION.update({"broadcast_shapes", "ndim", "shape", "size"}) +SELECTION.add("putmask") +SORTING.add("sort_complex") + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, default=ROOT / "coverage" / "generated") + parser.add_argument("--overrides", type=Path, default=ROOT / "coverage" / "overrides.json") + parser.add_argument("--check", action="store_true", help="Fail if checked-in outputs differ; do not write files.") + return parser.parse_args() + + +def load_numpy() -> Any: + try: + import numpy as np # type: ignore + except ImportError as error: + raise SystemExit(f"NumPy {PINNED_NUMPY_VERSION} is required: {error}") from error + if np.__version__ != PINNED_NUMPY_VERSION: + raise SystemExit(f"Expected NumPy {PINNED_NUMPY_VERSION}, found {np.__version__}.") + return np + + +def load_numsharp_inventory() -> dict[str, Any]: + project = ROOT / "tools" / "NumSharp.ApiInventory" / "NumSharp.ApiInventory.csproj" + command = ["dotnet", "run", "--project", str(project), "--configuration", "Release"] + completed = subprocess.run(command, cwd=ROOT, check=False, text=True, capture_output=True) + if completed.returncode: + sys.stderr.write(completed.stdout) + sys.stderr.write(completed.stderr) + raise SystemExit("Failed to reflect the NumSharp public API.") + try: + return json.loads(completed.stdout) + except json.JSONDecodeError as error: + raise SystemExit(f"NumSharp inventory emitted invalid JSON: {error}") from error + + +def load_overrides(path: Path) -> dict[str, Any]: + data = json.loads(path.read_text(encoding="utf-8")) + if data.get("schema_version") != 1: + raise SystemExit(f"Unsupported override schema in {path}.") + return data + + +def compact_text(value: str, limit: int = 420) -> str: + value = re.sub(r" at 0x[0-9a-fA-F]+", "", value) + value = re.sub(r"\s+", " ", value).strip() + return value if len(value) <= limit else value[: limit - 1].rstrip() + "…" + + +def numpy_signature(obj: Any, fallback_name: str) -> str: + try: + return compact_text(str(inspect.signature(obj))) + except (TypeError, ValueError): + pass + doc = inspect.getdoc(obj) or "" + first_line = doc.splitlines()[0].strip() if doc else "" + if first_line and (fallback_name in first_line or first_line.startswith("(")): + return compact_text(first_line) + nin = getattr(obj, "nin", None) + nout = getattr(obj, "nout", None) + if isinstance(nin, int): + return f"ufunc(nin={nin}, nout={nout})" + return "Signature unavailable from runtime introspection" + + +def numpy_kind(np: Any, obj: Any) -> str: + if inspect.ismodule(obj): + return "module" + if isinstance(obj, np.ufunc): + return "ufunc" + if inspect.isclass(obj): + return "class" + if callable(obj): + return "function" + return "constant" + + +def documentation_url(surface: str, name: str, kind: str) -> str: + prefix = { + "np": "numpy", + "ndarray": "numpy.ndarray", + "random": "numpy.random", + "linalg": "numpy.linalg", + "fft": "numpy.fft", + }[surface] + canonical_aliases = { + "numpy.abs": "numpy.absolute", + "numpy.bitwise_not": "numpy.invert", + "numpy.row_stack": "numpy.vstack", + } + api_id = f"{prefix}.{name}" + api_id = canonical_aliases.get(api_id, api_id) + + if surface == "random": + if kind not in CALLABLE_KINDS: + return "" + if name == "default_rng": + return "https://numpy.org/doc/stable/reference/random/generator.html#numpy.random.default_rng" + return f"https://numpy.org/doc/stable/reference/random/generated/{api_id}.html" + if surface == "np" and name == "test": + return "https://numpy.org/doc/stable/reference/testing.html" + if surface == "np" and kind not in CALLABLE_KINDS: + return "" + return f"https://numpy.org/doc/stable/reference/generated/{api_id}.html" + + +class SourceLocator: + """Locate public member declarations without requiring compiler-specific PDB paths.""" + + TYPE_PATTERNS = { + "np": re.compile(r"\bclass\s+np\b"), + "ndarray": re.compile(r"\bclass\s+NDArray(?:\s|<)"), + "random": re.compile(r"\bclass\s+NumPyRandom\b"), + } + + def __init__(self) -> None: + self.files: dict[str, list[tuple[Path, str]]] = {surface: [] for surface in self.TYPE_PATTERNS} + source_root = ROOT / "src" / "NumSharp.Core" + for path in source_root.rglob("*.cs"): + text = path.read_text(encoding="utf-8-sig") + for surface, pattern in self.TYPE_PATTERNS.items(): + if pattern.search(text): + self.files[surface].append((path, text)) + + def locate(self, surface: str, name: str, kind: str) -> list[str]: + escaped = re.escape(name) + if kind == "method": + declaration = re.compile(rf"\bpublic\b[^\n;{{}}]*\b{escaped}\s*(?:<[^\n>]+>)?\s*\(") + elif kind == "property" and name == "Item": + declaration = re.compile(r"\bpublic\b[^\n;{}]*\bthis\s*\[") + elif kind == "property": + declaration = re.compile(rf"\bpublic\b[^\n;{{}}]*\b{escaped}\b\s*(?:\{{|=>)") + else: + declaration = re.compile(rf"\bpublic\b[^\n;{{}}]*\b{escaped}\b\s*(?:=|;|,)") + candidates = [path for path, text in self.files.get(surface, []) if declaration.search(text)] + + normalized_name = re.sub(r"[^a-z0-9]", "", name.lower()) + candidates.sort(key=lambda path: ( + normalized_name not in re.sub(r"[^a-z0-9]", "", path.stem.lower()), + "Generics" in path.parts, + len(path.parts), + path.as_posix().lower(), + )) + return [candidates[0].relative_to(ROOT).as_posix()] if candidates else [] + + @staticmethod + def github_urls(paths: list[str]) -> list[str]: + return [NUMSHARP_SOURCE_BASE_URL + quote(path, safe="/") for path in paths] + + +def category_for(surface: str, name: str, kind: str) -> str: + if surface == "random": + return "Random" + if surface == "linalg": + return "Linear algebra" + if surface == "fft": + return "Fourier transforms" + if surface == "ndarray": + if kind == "property": + return "Array attributes" + if name in REDUCTIONS: + return "Reductions" + if name in SORTING: + return "Sorting & searching" + if name in MANIPULATION or name in {"astype", "byteswap", "copy", "fill", "flatten", "item", "setfield", "tolist", "tobytes", "tofile", "view"}: + return "Array methods" + return "Array methods" + if kind not in CALLABLE_KINDS: + return {"module": "Namespaces", "class": "Types", "constant": "Types & constants"}.get(kind, "Other") + if name in CATEGORY_OVERRIDES: + return CATEGORY_OVERRIDES[name] + if name in CREATION: + return "Array creation" + if name in MANIPULATION: + return "Shape manipulation" + if name in REDUCTIONS: + return "Reductions" + if name in LOGIC: + return "Logic & comparison" + if name in DTYPE: + return "Dtype & promotion" + if name in SELECTION: + return "Indexing & selection" + if name in SORTING: + return "Sorting & searching" + if name in IO: + return "Input & output" + if name in MATH: + return "Math" + return "Other" + + +def member_maps(inventory: dict[str, Any]) -> tuple[dict[str, dict[str, Any]], dict[str, list[dict[str, Any]]]]: + by_target: dict[str, dict[str, Any]] = {} + by_surface: dict[str, list[dict[str, Any]]] = {"np": [], "ndarray": [], "random": []} + source_locator = SourceLocator() + definitions = ( + ("np", "NumSharp.np", inventory["np"]), + ("ndarray", "NumSharp.NDArray", inventory["ndArray"]), + ("random", "NumSharp.NumPyRandom", inventory["random"]), + ) + for surface, prefix, type_data in definitions: + for collection in ("methods", "properties", "fields"): + for member in type_data[collection]: + source_paths = source_locator.locate(surface, member["name"], member["kind"]) + normalized = { + **member, + "surface": surface, + "target": f"{prefix}.{member['name']}", + "sourcePaths": source_paths, + "sourceUrls": source_locator.github_urls(source_paths), + } + by_target[normalized["target"]] = normalized + by_surface[surface].append(normalized) + by_target["NumSharp.NDArray"] = { + "name": "NDArray", "kind": "class", "signatures": ["NumSharp.NDArray"], "obsolete": False, + "surface": "ndarray", "target": "NumSharp.NDArray", + "sourcePaths": ["src/NumSharp.Core/Backends/NDArray.cs"], + "sourceUrls": [NUMSHARP_SOURCE_BASE_URL + "src/NumSharp.Core/Backends/NDArray.cs"], + } + return by_target, by_surface + + +def public_exports(np: Any) -> list[dict[str, Any]]: + exports: list[dict[str, Any]] = [] + + for name in sorted(set(np.__all__)): + if not hasattr(np, name): + continue + obj = getattr(np, name) + kind = numpy_kind(np, obj) + exports.append({ + "id": f"numpy.{name}", "origin": "numpy", "surface": "np", "name": name, "kind": kind, + "numpy_signature": numpy_signature(obj, name), "documentation_url": documentation_url("np", name, kind), + "in_default_scope": kind in CALLABLE_KINDS, + }) + + for name in sorted(item for item in dir(np.ndarray) if not item.startswith("_")): + raw = inspect.getattr_static(np.ndarray, name) + obj = getattr(np.ndarray, name) + kind = "method" if callable(obj) else "property" + exports.append({ + "id": f"numpy.ndarray.{name}", "origin": "numpy", "surface": "ndarray", "name": name, "kind": kind, + "numpy_signature": numpy_signature(obj if callable(obj) else raw, name), + "documentation_url": documentation_url("ndarray", name, kind), "in_default_scope": True, + }) + + for surface, module in (("random", np.random), ("linalg", np.linalg), ("fft", np.fft)): + for name in sorted(set(module.__all__)): + if not hasattr(module, name): + continue + obj = getattr(module, name) + kind = numpy_kind(np, obj) + exports.append({ + "id": f"numpy.{surface}.{name}", "origin": "numpy", "surface": surface, "name": name, "kind": kind, + "numpy_signature": numpy_signature(obj, name), "documentation_url": documentation_url(surface, name, kind), + "in_default_scope": kind in CALLABLE_KINDS, + }) + return exports + + +def direct_target(row: dict[str, Any], targets: dict[str, dict[str, Any]]) -> str | None: + surface = row["surface"] + name = row["name"] + kind = row["kind"] + if row["id"] == "numpy.ndarray": + return "NumSharp.NDArray" + prefix = {"np": "NumSharp.np", "ndarray": "NumSharp.NDArray", "random": "NumSharp.NumPyRandom"}.get(surface) + if prefix: + candidate = f"{prefix}.{name}" + member = targets.get(candidate) + if member and (kind not in CALLABLE_KINDS or member["kind"] == "method"): + return candidate + return None + + +def auto_alternative(row: dict[str, Any], targets: dict[str, dict[str, Any]]) -> tuple[str | None, str | None]: + if row["surface"] in {"ndarray", "linalg"} and row["kind"] in CALLABLE_KINDS: + target = f"NumSharp.np.{row['name']}" + if target in targets: + noun = "instance method" if row["surface"] == "ndarray" else "linalg namespace function" + return target, f"Available through the static NumSharp np API instead of the NumPy {noun}." + return None, None + + +def resolve_rows(np: Any, inventory: dict[str, Any], overrides: dict[str, Any]) -> tuple[list[dict[str, Any]], set[str]]: + targets, surfaces = member_maps(inventory) + aliases = overrides.get("aliases", {}) + support_overrides = overrides.get("support", {}) + seen_ids: set[str] = set() + consumed_targets: set[str] = set() + rows: list[dict[str, Any]] = [] + + for export in public_exports(np): + row_id = export["id"] + if row_id in seen_ids: + raise SystemExit(f"Duplicate coverage id: {row_id}") + seen_ids.add(row_id) + alias = aliases.get(row_id) + target = direct_target(export, targets) + availability = "exact" if target else "missing" + notes: list[str] = [] + if alias and not target: + target = alias["target"] + if target not in targets: + raise SystemExit(f"Alias {row_id} references missing NumSharp target {target}.") + availability = "alias" + if alias.get("notes"): + notes.append(alias["notes"]) + elif not target: + target, automatic_note = auto_alternative(export, targets) + if target: + availability = "alias" + notes.append(automatic_note or "Available on an alternate NumSharp surface.") + + support = "declared" if target else "missing" + support_override = support_overrides.get(row_id) + if support_override: + support = support_override["status"] + if support not in VALID_SUPPORT - {"missing", "extension"}: + raise SystemExit(f"Invalid support status for {row_id}: {support}") + if support_override.get("notes"): + notes.append(support_override["notes"]) + if target: + consumed_targets.add(target) + member = targets[target] + signatures = member["signatures"] + obsolete = member.get("obsolete", False) + source_paths = member.get("sourcePaths", []) + source_urls = member.get("sourceUrls", []) + else: + signatures = [] + obsolete = False + source_paths = [] + source_urls = [] + + display_status = "missing" if not target else support if support in {"partial", "unsupported"} else "available" + rows.append({ + **export, + "category": category_for(export["surface"], export["name"], export["kind"]), + "availability": availability, + "support": support, + "status": display_status, + "numsharp_target": target, + "numsharp_signatures": signatures, + "numsharp_obsolete": obsolete, + "numsharp_source_paths": source_paths, + "numsharp_source_urls": source_urls, + "notes": " ".join(dict.fromkeys(notes)), + }) + + unknown_aliases = set(aliases) - seen_ids + unknown_support = set(support_overrides) - seen_ids + if unknown_aliases or unknown_support: + unknown = ", ".join(sorted(unknown_aliases | unknown_support)) + raise SystemExit(f"Overrides reference NumPy exports that were not discovered: {unknown}") + + for surface, members in surfaces.items(): + for member in members: + name = member["name"] + target = member["target"] + if target in consumed_targets or name.startswith("_"): + continue + row_id = f"numsharp.{surface}.{name}" + if row_id in seen_ids: + row_id += f".{member['kind']}" + seen_ids.add(row_id) + rows.append({ + "id": row_id, + "origin": "numsharp", + "surface": surface, + "name": name, + "kind": member["kind"], + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": False, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": target, + "numsharp_signatures": member["signatures"], + "numsharp_obsolete": member.get("obsolete", False), + "numsharp_source_paths": member.get("sourcePaths", []), + "numsharp_source_urls": member.get("sourceUrls", []), + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface.", + }) + + rows.sort(key=lambda row: (row["origin"] != "numpy", row["surface"], row["name"].lower(), row["id"])) + missing_extension_sources = [ + row["id"] for row in rows + if row["origin"] == "numsharp" and not row["numsharp_source_urls"] + ] + if missing_extension_sources: + raise SystemExit("NumSharp-only APIs without a source link: " + ", ".join(missing_extension_sources)) + return rows, consumed_targets + + +def status_counts(rows: list[dict[str, Any]]) -> dict[str, int | float]: + statuses = Counter(row["status"] for row in rows) + availability = Counter(row["availability"] for row in rows) + total = len(rows) + available = statuses["available"] + addressed = available + statuses["partial"] + return { + "total": total, + "available": available, + "partial": statuses["partial"], + "unsupported": statuses["unsupported"], + "missing": statuses["missing"], + "exact": availability["exact"], + "alias": availability["alias"], + "coverage_percent": round(available * 100 / total, 1) if total else 0.0, + "addressed_percent": round(addressed * 100 / total, 1) if total else 0.0, + } + + +def build_summary(rows: list[dict[str, Any]]) -> dict[str, Any]: + default_rows = [row for row in rows if row["origin"] == "numpy" and row["in_default_scope"]] + numpy_rows = [row for row in rows if row["origin"] == "numpy"] + by_surface = { + surface: status_counts([row for row in default_rows if row["surface"] == surface]) + for surface in sorted({row["surface"] for row in default_rows}) + } + by_category = { + category: status_counts([row for row in default_rows if row["category"] == category]) + for category in sorted({row["category"] for row in default_rows}) + } + return { + "default_scope": status_counts(default_rows), + "by_surface": by_surface, + "by_category": by_category, + "all_numpy_exports": len(numpy_rows), + "numsharp_extensions": sum(row["origin"] == "numsharp" for row in rows), + "catalog_rows": len(rows), + } + + +def json_text(value: Any) -> str: + return json.dumps(value, indent=2, ensure_ascii=False, sort_keys=False) + "\n" + + +def csv_text(rows: list[dict[str, Any]]) -> str: + columns = [ + "id", "origin", "surface", "category", "name", "kind", "in_default_scope", "status", "availability", + "support", "numpy_signature", "numsharp_target", "numsharp_signatures", "numsharp_source_paths", + "numsharp_source_urls", "numsharp_obsolete", "notes", "documentation_url" + ] + stream = io.StringIO(newline="") + writer = csv.DictWriter(stream, fieldnames=columns, lineterminator="\n") + writer.writeheader() + for row in rows: + flat = {key: row.get(key, "") for key in columns} + flat["numsharp_signatures"] = " | ".join(row["numsharp_signatures"]) + flat["numsharp_source_paths"] = " | ".join(row["numsharp_source_paths"]) + flat["numsharp_source_urls"] = " | ".join(row["numsharp_source_urls"]) + writer.writerow(flat) + return stream.getvalue() + + +def markdown_text(summary: dict[str, Any], rows: list[dict[str, Any]], numpy_version: str, assembly_version: str) -> str: + headline = summary["default_scope"] + lines = [ + "# NumPy ↔ NumSharp API coverage", + "", + f"Compared with NumPy **{numpy_version}** using NumSharp assembly **{assembly_version}**.", + "", + f"Headline API availability: **{headline['coverage_percent']:.1f}%** " + f"({headline['available']} of {headline['total']} default-scope APIs). " + f"Including partial mappings, **{headline['addressed_percent']:.1f}%** are addressed.", + "", + "| Surface | Available | Partial | Unsupported | Missing | Total | Coverage |", + "|---|---:|---:|---:|---:|---:|---:|", + ] + labels = {"np": "np.*", "ndarray": "ndarray.*", "random": "np.random.*", "linalg": "np.linalg.*", "fft": "np.fft.*"} + for surface, counts in summary["by_surface"].items(): + lines.append( + f"| {labels.get(surface, surface)} | {counts['available']} | {counts['partial']} | " + f"{counts['unsupported']} | {counts['missing']} | {counts['total']} | {counts['coverage_percent']:.1f}% |" + ) + lines.extend([ + "", + "> Availability is based on the compiled public API. It is not a blanket behavioral-parity claim; dtype, layout, signature, and edge-case parity require differential tests.", + "", + "## Highest-priority gaps", + "", + "| API | Surface | Status | Category |", + "|---|---|---|---|", + ]) + gaps = [row for row in rows if row["origin"] == "numpy" and row["in_default_scope"] and row["status"] != "available"] + priority = {"unsupported": 0, "partial": 1, "missing": 2} + gaps.sort(key=lambda row: (priority.get(row["status"], 9), row["surface"], row["name"].lower())) + for row in gaps[:50]: + api = row["id"].replace("numpy.", "np.", 1).replace("np.ndarray.", "ndarray.", 1) + lines.append(f"| [`{api}`]({row['documentation_url']}) | {row['surface']} | {row['status']} | {row['category']} |") + lines.extend([ + "", + "## Counting rules", + "", + "The default scope is NumPy top-level callables, ndarray public methods/properties, and callables in numpy.random, numpy.linalg, and numpy.fft. Types, constants, modules, and NumSharp-only APIs remain searchable in the JSON artifact but do not affect the headline percentage.", + "", + ]) + return "\n".join(lines) + + +def render_outputs(np: Any, inventory: dict[str, Any], overrides: dict[str, Any]) -> dict[str, str]: + rows, _ = resolve_rows(np, inventory, overrides) + summary = build_summary(rows) + payload = { + "schema_version": 1, + "generator_version": GENERATOR_VERSION, + "numpy_version": np.__version__, + "numsharp_assembly_version": inventory["assemblyVersion"], + "methodology": { + "headline": "Available default-scope APIs divided by all default-scope NumPy APIs.", + "default_scope": "Top-level NumPy callables; ndarray public methods and properties; callable exports of numpy.random, numpy.linalg, and numpy.fft.", + "availability_note": "Compiled API availability is distinct from fully verified behavioral parity.", + }, + "summary": summary, + "rows": rows, + } + manifest = { + "schema_version": 1, + "generator": "coverage/generate_coverage.py", + "generator_version": GENERATOR_VERSION, + "numpy_version": np.__version__, + "numsharp_assembly_version": inventory["assemblyVersion"], + "artifact_files": list(OUTPUT_FILES), + "source_surfaces": ["numpy", "numpy.ndarray", "numpy.random", "numpy.linalg", "numpy.fft"], + "numsharp_source_base_url": NUMSHARP_SOURCE_BASE_URL, + "summary": summary, + } + return { + "coverage.json": json_text(payload), + "coverage.csv": csv_text(rows), + "summary.md": markdown_text(summary, rows, np.__version__, inventory["assemblyVersion"]), + "manifest.json": json_text(manifest), + } + + +def check_outputs(output: Path, rendered: dict[str, str]) -> None: + changed: list[str] = [] + for name, expected in rendered.items(): + path = output / name + actual = path.read_text(encoding="utf-8") if path.exists() else None + if actual != expected: + changed.append(str(path.relative_to(ROOT))) + if changed: + sys.stderr.write("Coverage artifact is stale or missing:\n") + sys.stderr.write("".join(f" - {path}\n" for path in changed)) + sys.stderr.write("Run: python coverage/generate_coverage.py\n") + raise SystemExit(1) + + +def write_outputs(output: Path, rendered: dict[str, str]) -> None: + output.mkdir(parents=True, exist_ok=True) + for name, content in rendered.items(): + (output / name).write_text(content, encoding="utf-8", newline="") + + +def main() -> None: + args = parse_args() + np = load_numpy() + inventory = load_numsharp_inventory() + overrides = load_overrides(args.overrides) + rendered = render_outputs(np, inventory, overrides) + if args.check: + check_outputs(args.output, rendered) + print(f"Coverage artifact is current ({args.output}).") + else: + write_outputs(args.output, rendered) + summary = json.loads(rendered["coverage.json"])["summary"]["default_scope"] + print( + f"Wrote {args.output}: {summary['available']}/{summary['total']} available " + f"({summary['coverage_percent']:.1f}%)." + ) + + +if __name__ == "__main__": + main() diff --git a/coverage/generated/coverage.csv b/coverage/generated/coverage.csv new file mode 100644 index 000000000..7fa66e973 --- /dev/null +++ b/coverage/generated/coverage.csv @@ -0,0 +1,795 @@ +id,origin,surface,category,name,kind,in_default_scope,status,availability,support,numpy_signature,numsharp_target,numsharp_signatures,numsharp_source_paths,numsharp_source_urls,numsharp_obsolete,notes,documentation_url +numpy.fft.fft,numpy,fft,Fourier transforms,fft,function,True,missing,missing,missing,"(a, n=None, axis=-1, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.fft.html +numpy.fft.fft2,numpy,fft,Fourier transforms,fft2,function,True,missing,missing,missing,"(a, s=None, axes=(-2, -1), norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.fft2.html +numpy.fft.fftfreq,numpy,fft,Fourier transforms,fftfreq,function,True,missing,missing,missing,"(n, d=1.0, device=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.fftfreq.html +numpy.fft.fftn,numpy,fft,Fourier transforms,fftn,function,True,missing,missing,missing,"(a, s=None, axes=None, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.fftn.html +numpy.fft.fftshift,numpy,fft,Fourier transforms,fftshift,function,True,missing,missing,missing,"(x, axes=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.fftshift.html +numpy.fft.hfft,numpy,fft,Fourier transforms,hfft,function,True,missing,missing,missing,"(a, n=None, axis=-1, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.hfft.html +numpy.fft.ifft,numpy,fft,Fourier transforms,ifft,function,True,missing,missing,missing,"(a, n=None, axis=-1, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft.html +numpy.fft.ifft2,numpy,fft,Fourier transforms,ifft2,function,True,missing,missing,missing,"(a, s=None, axes=(-2, -1), norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft2.html +numpy.fft.ifftn,numpy,fft,Fourier transforms,ifftn,function,True,missing,missing,missing,"(a, s=None, axes=None, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftn.html +numpy.fft.ifftshift,numpy,fft,Fourier transforms,ifftshift,function,True,missing,missing,missing,"(x, axes=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftshift.html +numpy.fft.ihfft,numpy,fft,Fourier transforms,ihfft,function,True,missing,missing,missing,"(a, n=None, axis=-1, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.ihfft.html +numpy.fft.irfft,numpy,fft,Fourier transforms,irfft,function,True,missing,missing,missing,"(a, n=None, axis=-1, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft.html +numpy.fft.irfft2,numpy,fft,Fourier transforms,irfft2,function,True,missing,missing,missing,"(a, s=None, axes=(-2, -1), norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft2.html +numpy.fft.irfftn,numpy,fft,Fourier transforms,irfftn,function,True,missing,missing,missing,"(a, s=None, axes=None, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.irfftn.html +numpy.fft.rfft,numpy,fft,Fourier transforms,rfft,function,True,missing,missing,missing,"(a, n=None, axis=-1, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft.html +numpy.fft.rfft2,numpy,fft,Fourier transforms,rfft2,function,True,missing,missing,missing,"(a, s=None, axes=(-2, -1), norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft2.html +numpy.fft.rfftfreq,numpy,fft,Fourier transforms,rfftfreq,function,True,missing,missing,missing,"(n, d=1.0, device=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.rfftfreq.html +numpy.fft.rfftn,numpy,fft,Fourier transforms,rfftn,function,True,missing,missing,missing,"(a, s=None, axes=None, norm=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fft.rfftn.html +numpy.linalg.cholesky,numpy,linalg,Linear algebra,cholesky,function,True,missing,missing,missing,"(a, /, *, upper=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.cholesky.html +numpy.linalg.cond,numpy,linalg,Linear algebra,cond,function,True,missing,missing,missing,"(x, p=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.cond.html +numpy.linalg.cross,numpy,linalg,Linear algebra,cross,function,True,missing,missing,missing,"(x1, x2, /, *, axis=-1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.cross.html +numpy.linalg.det,numpy,linalg,Linear algebra,det,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.det.html +numpy.linalg.diagonal,numpy,linalg,Linear algebra,diagonal,function,True,available,alias,declared,"(x, /, *, offset=0)",NumSharp.np.diagonal,"NumSharp.NDArray diagonal(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1)",src/NumSharp.Core/Indexing/np.diagonal.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.diagonal.cs,False,Available through the static NumSharp np API instead of the NumPy linalg namespace function.,https://numpy.org/doc/stable/reference/generated/numpy.linalg.diagonal.html +numpy.linalg.eig,numpy,linalg,Linear algebra,eig,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html +numpy.linalg.eigh,numpy,linalg,Linear algebra,eigh,function,True,missing,missing,missing,"(a, UPLO='L')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigh.html +numpy.linalg.eigvals,numpy,linalg,Linear algebra,eigvals,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigvals.html +numpy.linalg.eigvalsh,numpy,linalg,Linear algebra,eigvalsh,function,True,missing,missing,missing,"(a, UPLO='L')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigvalsh.html +numpy.linalg.inv,numpy,linalg,Linear algebra,inv,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.inv.html +numpy.linalg.LinAlgError,numpy,linalg,Linear algebra,LinAlgError,class,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.LinAlgError.html +numpy.linalg.lstsq,numpy,linalg,Linear algebra,lstsq,function,True,missing,missing,missing,"(a, b, rcond=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.lstsq.html +numpy.linalg.matmul,numpy,linalg,Linear algebra,matmul,function,True,available,alias,declared,"(x1, x2, /)",NumSharp.np.matmul,"NumSharp.NDArray matmul(NumSharp.NDArray x1, NumSharp.NDArray x2)",src/NumSharp.Core/LinearAlgebra/np.matmul.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.matmul.cs,False,Available through the static NumSharp np API instead of the NumPy linalg namespace function.,https://numpy.org/doc/stable/reference/generated/numpy.linalg.matmul.html +numpy.linalg.matrix_norm,numpy,linalg,Linear algebra,matrix_norm,function,True,missing,missing,missing,"(x, /, *, keepdims=False, ord='fro')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_norm.html +numpy.linalg.matrix_power,numpy,linalg,Linear algebra,matrix_power,function,True,available,alias,declared,"(a, n)",NumSharp.NDArray.matrix_power,NumSharp.NDArray matrix_power(int power),src/NumSharp.Core/LinearAlgebra/NDArray.matrix_power.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/NDArray.matrix_power.cs,False,Matrix power is available as an NDArray instance method rather than under an linalg namespace.,https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_power.html +numpy.linalg.matrix_rank,numpy,linalg,Linear algebra,matrix_rank,function,True,missing,missing,missing,"(A, tol=None, hermitian=False, *, rtol=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_rank.html +numpy.linalg.matrix_transpose,numpy,linalg,Linear algebra,matrix_transpose,function,True,available,alias,declared,"(x, /)",NumSharp.np.matrix_transpose,NumSharp.NDArray matrix_transpose(NumSharp.NDArray x),src/NumSharp.Core/Manipulation/np.matrix_transpose.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.matrix_transpose.cs,False,Available through the static NumSharp np API instead of the NumPy linalg namespace function.,https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_transpose.html +numpy.linalg.multi_dot,numpy,linalg,Linear algebra,multi_dot,function,True,missing,missing,missing,"(arrays, *, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.multi_dot.html +numpy.linalg.norm,numpy,linalg,Linear algebra,norm,function,True,missing,missing,missing,"(x, ord=None, axis=None, keepdims=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html +numpy.linalg.outer,numpy,linalg,Linear algebra,outer,function,True,available,alias,declared,"(x1, x2, /)",NumSharp.np.outer,"NumSharp.NDArray outer(NumSharp.NDArray a, NumSharp.NDArray b)",src/NumSharp.Core/LinearAlgebra/np.outer.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.outer.cs,False,Available through the static NumSharp np API instead of the NumPy linalg namespace function.,https://numpy.org/doc/stable/reference/generated/numpy.linalg.outer.html +numpy.linalg.pinv,numpy,linalg,Linear algebra,pinv,function,True,missing,missing,missing,"(a, rcond=None, hermitian=False, *, rtol=)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.pinv.html +numpy.linalg.qr,numpy,linalg,Linear algebra,qr,function,True,missing,missing,missing,"(a, mode='reduced')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.qr.html +numpy.linalg.slogdet,numpy,linalg,Linear algebra,slogdet,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.slogdet.html +numpy.linalg.solve,numpy,linalg,Linear algebra,solve,function,True,missing,missing,missing,"(a, b)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html +numpy.linalg.svd,numpy,linalg,Linear algebra,svd,function,True,missing,missing,missing,"(a, full_matrices=True, compute_uv=True, hermitian=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.svd.html +numpy.linalg.svdvals,numpy,linalg,Linear algebra,svdvals,function,True,missing,missing,missing,"(x, /)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.svdvals.html +numpy.linalg.tensordot,numpy,linalg,Linear algebra,tensordot,function,True,missing,missing,missing,"(x1, x2, /, *, axes=2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensordot.html +numpy.linalg.tensorinv,numpy,linalg,Linear algebra,tensorinv,function,True,missing,missing,missing,"(a, ind=2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensorinv.html +numpy.linalg.tensorsolve,numpy,linalg,Linear algebra,tensorsolve,function,True,missing,missing,missing,"(a, b, axes=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensorsolve.html +numpy.linalg.trace,numpy,linalg,Linear algebra,trace,function,True,available,alias,declared,"(x, /, *, offset=0, dtype=None)",NumSharp.np.trace,"NumSharp.NDArray trace(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1, System.Type dtype = null, NumSharp.NDArray out = null)",src/NumSharp.Core/Indexing/np.trace.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.trace.cs,False,Available through the static NumSharp np API instead of the NumPy linalg namespace function.,https://numpy.org/doc/stable/reference/generated/numpy.linalg.trace.html +numpy.linalg.vecdot,numpy,linalg,Linear algebra,vecdot,function,True,missing,missing,missing,"(x1, x2, /, *, axis=-1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.vecdot.html +numpy.linalg.vector_norm,numpy,linalg,Linear algebra,vector_norm,function,True,missing,missing,missing,"(x, /, *, axis=None, keepdims=False, ord=2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.linalg.vector_norm.html +numpy.ndarray.all,numpy,ndarray,Reductions,all,method,True,available,alias,declared,"(self, /, axis=None, out=None, keepdims=False, *, where=True)",NumSharp.np.all,"NumSharp.Generic.NDArray all(NumSharp.NDArray nd, bool keepdims) | NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int axis, bool keepdims = false) | NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int[] axis, bool keepdims = false) | NumSharp.NDArray all(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null) | NumSharp.NDArray all(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null) | bool all(NumSharp.NDArray a)",src/NumSharp.Core/Logic/np.all.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.all.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.all.html +numpy.ndarray.any,numpy,ndarray,Reductions,any,method,True,available,alias,declared,"(self, /, axis=None, out=None, keepdims=False, *, where=True)",NumSharp.np.any,"NumSharp.Generic.NDArray any(NumSharp.NDArray nd, bool keepdims) | NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int axis, bool keepdims = false) | NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int[] axis, bool keepdims = false) | NumSharp.NDArray any(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null) | NumSharp.NDArray any(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null) | bool any(NumSharp.NDArray a)",src/NumSharp.Core/Logic/np.any.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.any.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.any.html +numpy.ndarray.argmax,numpy,ndarray,Reductions,argmax,method,True,available,exact,declared,"(self, /, axis=None, out=None, *, keepdims=False)",NumSharp.NDArray.argmax,"NumSharp.NDArray argmax(int axis, bool keepdims = false) | long argmax()",src/NumSharp.Core/Statistics/NDArray.argmax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.argmax.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argmax.html +numpy.ndarray.argmin,numpy,ndarray,Reductions,argmin,method,True,available,exact,declared,"(self, /, axis=None, out=None, *, keepdims=False)",NumSharp.NDArray.argmin,"NumSharp.NDArray argmin(int axis, bool keepdims = false) | long argmin()",src/NumSharp.Core/Statistics/NDArray.argmin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.argmin.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argmin.html +numpy.ndarray.argpartition,numpy,ndarray,Sorting & searching,argpartition,method,True,missing,missing,missing,"(self, kth, /, axis=-1, kind='introselect', order=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argpartition.html +numpy.ndarray.argsort,numpy,ndarray,Sorting & searching,argsort,method,True,available,exact,declared,"(self, /, axis=-1, kind=None, order=None, *, stable=None)",NumSharp.NDArray.argsort,NumSharp.NDArray argsort(int axis = -1) | NumSharp.NDArray argsort(int? axis = -1),src/NumSharp.Core/Sorting_Searching_Counting/ndarray.argsort.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/ndarray.argsort.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argsort.html +numpy.ndarray.astype,numpy,ndarray,Array methods,astype,method,True,available,exact,declared,"(self, /, dtype, order='K', casting='unsafe', subok=True, copy=True)",NumSharp.NDArray.astype,"NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy = true) | NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy, char order, string casting = ""unsafe"") | NumSharp.NDArray astype(System.Type dtype, bool copy = true) | NumSharp.NDArray astype(System.Type dtype, bool copy, char order, string casting = ""unsafe"")",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.astype.html +numpy.ndarray.base,numpy,ndarray,Array attributes,base,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.base,NumSharp.NDArray base { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.base.html +numpy.ndarray.byteswap,numpy,ndarray,Array methods,byteswap,method,True,missing,missing,missing,"(self, /, inplace=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.byteswap.html +numpy.ndarray.choose,numpy,ndarray,Array methods,choose,method,True,missing,missing,missing,"(self, /, choices, out=None, mode='raise')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.choose.html +numpy.ndarray.clip,numpy,ndarray,Array methods,clip,method,True,available,alias,declared,"(self, /, min=None, max=None, out=None, **kwargs)",NumSharp.np.clip,"NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min = null, NumSharp.NDArray a_max = null, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, NumSharp.NDArray min = null, NumSharp.NDArray max = null) | NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min, NumSharp.NDArray a_max, System.Type dtype)",src/NumSharp.Core/Math/np.clip.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.clip.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.clip.html +numpy.ndarray.compress,numpy,ndarray,Array methods,compress,method,True,available,alias,declared,"(self, /, condition, axis=None, out=None)",NumSharp.np.compress,"NumSharp.NDArray compress(NumSharp.NDArray condition, NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null)",src/NumSharp.Core/Indexing/np.compress.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.compress.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.compress.html +numpy.ndarray.conj,numpy,ndarray,Array methods,conj,method,True,missing,missing,missing,"(self, /)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.conj.html +numpy.ndarray.conjugate,numpy,ndarray,Array methods,conjugate,method,True,missing,missing,missing,"(self, /)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.conjugate.html +numpy.ndarray.copy,numpy,ndarray,Array methods,copy,method,True,available,exact,declared,"(self, /, order='C')",NumSharp.NDArray.copy,NumSharp.NDArray copy(char order = 'C'),src/NumSharp.Core/Creation/NDArray.Copy.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NDArray.Copy.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.copy.html +numpy.ndarray.ctypes,numpy,ndarray,Array attributes,ctypes,property,True,missing,missing,missing,An object to simplify the interaction of the array with the ctypes,,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ctypes.html +numpy.ndarray.cumprod,numpy,ndarray,Reductions,cumprod,method,True,available,alias,declared,"(self, /, axis=None, dtype=None, out=None)",NumSharp.np.cumprod,"NumSharp.NDArray cumprod(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)",src/NumSharp.Core/APIs/np.cumprod.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumprod.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.cumprod.html +numpy.ndarray.cumsum,numpy,ndarray,Reductions,cumsum,method,True,available,exact,declared,"(self, /, axis=None, dtype=None, out=None)",NumSharp.NDArray.cumsum,"NumSharp.NDArray cumsum(int? axis = null, System.Type dtype = null)",src/NumSharp.Core/Math/NDArray.cumsum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.cumsum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.cumsum.html +numpy.ndarray.data,numpy,ndarray,Array attributes,data,property,True,partial,alias,partial,Python buffer object pointing to the start of the array's data.,NumSharp.NDArray.Data,NumSharp.Backends.Unmanaged.ArraySlice Data(),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp exposes typed unmanaged data through the generic Data() method rather than NumPy's buffer-view property. Data() returns a typed NumSharp ArraySlice and is not NumPy's Python buffer object.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.data.html +numpy.ndarray.device,numpy,ndarray,Array attributes,device,property,True,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.device.html +numpy.ndarray.diagonal,numpy,ndarray,Array methods,diagonal,method,True,available,alias,declared,"(self, /, offset=0, axis1=0, axis2=1)",NumSharp.np.diagonal,"NumSharp.NDArray diagonal(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1)",src/NumSharp.Core/Indexing/np.diagonal.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.diagonal.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.diagonal.html +numpy.ndarray.dot,numpy,ndarray,Array methods,dot,method,True,available,exact,declared,"(self, other, /, out=None)",NumSharp.NDArray.dot,NumSharp.NDArray dot(NumSharp.NDArray b),src/NumSharp.Core/LinearAlgebra/NDArray.dot.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/NDArray.dot.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dot.html +numpy.ndarray.dtype,numpy,ndarray,Array attributes,dtype,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.dtype,System.Type dtype { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dtype.html +numpy.ndarray.dump,numpy,ndarray,Array methods,dump,method,True,missing,missing,missing,"(self, /, file)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dump.html +numpy.ndarray.dumps,numpy,ndarray,Array methods,dumps,method,True,missing,missing,missing,"(self, /)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dumps.html +numpy.ndarray.fill,numpy,ndarray,Array methods,fill,method,True,missing,missing,missing,"(self, /, value)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.fill.html +numpy.ndarray.flags,numpy,ndarray,Array attributes,flags,property,True,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html +numpy.ndarray.flat,numpy,ndarray,Array attributes,flat,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.flat,NumSharp.NDArray flat { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flat.html +numpy.ndarray.flatten,numpy,ndarray,Array methods,flatten,method,True,available,exact,declared,"(self, /, order='C')",NumSharp.NDArray.flatten,NumSharp.NDArray flatten(char order = 'C'),src/NumSharp.Core/Manipulation/NDArray.flatten.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.flatten.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flatten.html +numpy.ndarray.getfield,numpy,ndarray,Array methods,getfield,method,True,missing,missing,missing,"(self, /, dtype, offset=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.getfield.html +numpy.ndarray.imag,numpy,ndarray,Array attributes,imag,property,True,missing,missing,missing,The imaginary part of the array.,,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.imag.html +numpy.ndarray.item,numpy,ndarray,Array methods,item,method,True,available,exact,declared,"(self, /, *args)",NumSharp.NDArray.item,"T item() | T item(long i, long j) | T item(long i, long j, long k) | T item(long index) | T item(params long[] indices) | object item() | object item(long i, long j) | object item(long i, long j, long k) | object item(long index) | object item(params long[] indices)",src/NumSharp.Core/Manipulation/NDArray.item.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.item.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.item.html +numpy.ndarray.itemsize,numpy,ndarray,Array attributes,itemsize,property,True,available,alias,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.dtypesize,int dtypesize { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,The element size is exposed as dtypesize in NumSharp.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.itemsize.html +numpy.ndarray.max,numpy,ndarray,Reductions,max,method,True,available,exact,declared,"(self, /, axis=None, out=None, **kwargs)",NumSharp.NDArray.max,"NumSharp.NDArray max(System.Type dtype = null) | NumSharp.NDArray max(int axis, bool keepdims = false, System.Type dtype = null) | T max()",src/NumSharp.Core/Statistics/NDArray.amax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amax.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.max.html +numpy.ndarray.mean,numpy,ndarray,Reductions,mean,method,True,available,exact,declared,"(self, /, axis=None, dtype=None, out=None, **kwargs)",NumSharp.NDArray.mean,"NumSharp.NDArray mean() | NumSharp.NDArray mean(int axis) | NumSharp.NDArray mean(int axis, NumSharp.NPTypeCode type, bool keepdims = false) | NumSharp.NDArray mean(int axis, System.Type type, bool keepdims = false) | NumSharp.NDArray mean(int axis, bool keepdims)",src/NumSharp.Core/Statistics/NDArray.mean.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.mean.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.mean.html +numpy.ndarray.min,numpy,ndarray,Reductions,min,method,True,available,exact,declared,"(self, /, axis=None, out=None, **kwargs)",NumSharp.NDArray.min,"NumSharp.NDArray min(System.Type dtype = null) | NumSharp.NDArray min(int axis, bool keepdims = false, System.Type dtype = null) | T min()",src/NumSharp.Core/Statistics/NDArray.amin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amin.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.min.html +numpy.ndarray.mT,numpy,ndarray,Array attributes,mT,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.mT,NumSharp.NDArray mT { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.mT.html +numpy.ndarray.nbytes,numpy,ndarray,Array attributes,nbytes,property,True,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.nbytes.html +numpy.ndarray.ndim,numpy,ndarray,Array attributes,ndim,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.ndim,int ndim { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ndim.html +numpy.ndarray.nonzero,numpy,ndarray,Sorting & searching,nonzero,method,True,available,alias,declared,"(self, /)",NumSharp.np.nonzero,NumSharp.Generic.NDArray[] nonzero(NumSharp.NDArray a),src/NumSharp.Core/Indexing/np.nonzero.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.nonzero.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.nonzero.html +numpy.ndarray.partition,numpy,ndarray,Sorting & searching,partition,method,True,missing,missing,missing,"(self, kth, /, axis=-1, kind='introselect', order=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.partition.html +numpy.ndarray.prod,numpy,ndarray,Reductions,prod,method,True,available,exact,declared,"(self, /, axis=None, dtype=None, out=None, **kwargs)",NumSharp.NDArray.prod,"NumSharp.NDArray prod(int? axis = null, System.Type dtype = null, bool keepdims = false)",src/NumSharp.Core/Math/NDArray.prod.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.prod.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.prod.html +numpy.ndarray.put,numpy,ndarray,Array methods,put,method,True,available,alias,declared,"(self, indices, values, /, mode='raise')",NumSharp.np.put,"void put(NumSharp.NDArray a, NumSharp.NDArray indices, NumSharp.NDArray values, string mode = ""raise"") | void put(NumSharp.NDArray a, long index, object value, string mode = ""raise"")",src/NumSharp.Core/Indexing/np.put.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.put.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.put.html +numpy.ndarray.ravel,numpy,ndarray,Array methods,ravel,method,True,available,exact,declared,"(self, /, order='C')",NumSharp.NDArray.ravel,NumSharp.NDArray ravel() | NumSharp.NDArray ravel(char order),src/NumSharp.Core/Manipulation/NDArray.ravel.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.ravel.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ravel.html +numpy.ndarray.real,numpy,ndarray,Array attributes,real,property,True,missing,missing,missing,The real part of the array.,,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.real.html +numpy.ndarray.repeat,numpy,ndarray,Array methods,repeat,method,True,available,alias,declared,"(self, repeats, /, axis=None)",NumSharp.np.repeat,"NumSharp.NDArray repeat(NumSharp.NDArray a, NumSharp.NDArray repeats, int? axis = null) | NumSharp.NDArray repeat(NumSharp.NDArray a, int repeats, int? axis = null) | NumSharp.NDArray repeat(NumSharp.NDArray a, long repeats, int? axis = null) | NumSharp.NDArray repeat(T a, int repeats) | NumSharp.NDArray repeat(T a, long repeats)",src/NumSharp.Core/Manipulation/np.repeat.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.repeat.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.repeat.html +numpy.ndarray.reshape,numpy,ndarray,Array methods,reshape,method,True,available,exact,declared,"(self, /, *shape, order='C', copy=None)",NumSharp.NDArray.reshape,"NumSharp.NDArray reshape(NumSharp.Shape newShape) | NumSharp.NDArray reshape(NumSharp.Shape newShape, char order) | NumSharp.NDArray reshape(int[] shape) | NumSharp.NDArray reshape(params long[] shape) | NumSharp.NDArray reshape(ref NumSharp.Shape newShape)",src/NumSharp.Core/Creation/NdArray.ReShape.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.ReShape.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.reshape.html +numpy.ndarray.resize,numpy,ndarray,Array methods,resize,method,True,available,exact,declared,"(self, /, *new_shape, refcheck=True)",NumSharp.NDArray.resize,"void resize(NumSharp.Shape new_shape, bool refcheck = true) | void resize(params long[] new_shape)",src/NumSharp.Core/Manipulation/NDArray.resize.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.resize.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.resize.html +numpy.ndarray.round,numpy,ndarray,Array methods,round,method,True,available,alias,declared,"(self, /, decimals=0, out=None)",NumSharp.np.round_,"NumSharp.NDArray round_(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray round_(NumSharp.NDArray x, System.Type dtype) | NumSharp.NDArray round_(NumSharp.NDArray x, int decimals = 0, NumSharp.NDArray out = null) | NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, NumSharp.NPTypeCode dtype) | NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, System.Type dtype)",src/NumSharp.Core/Math/np.round.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.round.cs,False,Use the static np.round_ API; NumSharp does not expose ndarray.round as an instance member.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.round.html +numpy.ndarray.searchsorted,numpy,ndarray,Sorting & searching,searchsorted,method,True,available,alias,declared,"(self, v, /, side='left', sorter=None)",NumSharp.np.searchsorted,"NumSharp.NDArray searchsorted(NumSharp.NDArray a, NumSharp.NDArray v, string side = ""left"", NumSharp.NDArray sorter = null) | long searchsorted(NumSharp.NDArray a, double v, string side = ""left"", NumSharp.NDArray sorter = null) | long searchsorted(NumSharp.NDArray a, int v, string side = ""left"", NumSharp.NDArray sorter = null)",src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.searchsorted.html +numpy.ndarray.setfield,numpy,ndarray,Array methods,setfield,method,True,missing,missing,missing,"(self, val, /, dtype, offset=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.setfield.html +numpy.ndarray.setflags,numpy,ndarray,Array methods,setflags,method,True,missing,missing,missing,"(self, /, *, write=None, align=None, uic=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.setflags.html +numpy.ndarray.shape,numpy,ndarray,Array attributes,shape,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.shape,long[] shape { get; set; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.shape.html +numpy.ndarray.size,numpy,ndarray,Array attributes,size,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.size,long size { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.size.html +numpy.ndarray.sort,numpy,ndarray,Sorting & searching,sort,method,True,available,exact,declared,"(self, /, axis=-1, kind=None, order=None, *, stable=None)",NumSharp.NDArray.sort,"void sort(int? axis = -1, string kind = null)",src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.sort.html +numpy.ndarray.squeeze,numpy,ndarray,Array methods,squeeze,method,True,available,alias,declared,"(self, /, axis=None)",NumSharp.np.squeeze,"NumSharp.NDArray squeeze(NumSharp.NDArray a) | NumSharp.NDArray squeeze(NumSharp.NDArray a, int axis) | NumSharp.Shape squeeze(NumSharp.Shape shape)",src/NumSharp.Core/Manipulation/np.squeeze.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.squeeze.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.squeeze.html +numpy.ndarray.std,numpy,ndarray,Reductions,std,method,True,available,exact,declared,"(self, /, axis=None, dtype=None, out=None, ddof=0, **kwargs)",NumSharp.NDArray.std,"NumSharp.NDArray std(bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray std(int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Statistics/NDArray.std.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.std.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.std.html +numpy.ndarray.strides,numpy,ndarray,Array attributes,strides,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.strides,long[] strides { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.strides.html +numpy.ndarray.sum,numpy,ndarray,Reductions,sum,method,True,available,exact,declared,"(self, /, axis=None, dtype=None, out=None, **kwargs)",NumSharp.NDArray.sum,"NumSharp.NDArray sum() | NumSharp.NDArray sum(int axis) | NumSharp.NDArray sum(int axis, bool keepdims, NumSharp.NPTypeCode? typeCode = null) | NumSharp.NDArray sum(int axis, bool keepdims, System.Type dtype)",src/NumSharp.Core/Math/NDArray.sum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.sum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.sum.html +numpy.ndarray.swapaxes,numpy,ndarray,Array methods,swapaxes,method,True,available,exact,declared,"(self, axis1, axis2, /)",NumSharp.NDArray.swapaxes,"NumSharp.NDArray swapaxes(int axis1, int axis2)",src/NumSharp.Core/Manipulation/NdArray.swapaxes.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NdArray.swapaxes.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.swapaxes.html +numpy.ndarray.T,numpy,ndarray,Array attributes,T,property,True,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.NDArray.T,NumSharp.NDArray T { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.T.html +numpy.ndarray.take,numpy,ndarray,Array methods,take,method,True,available,alias,declared,"(self, indices, /, axis=None, out=None, mode='raise')",NumSharp.np.take,"NumSharp.NDArray take(NumSharp.NDArray a, NumSharp.NDArray indices, int? axis = null, NumSharp.NDArray out = null, string mode = ""raise"") | NumSharp.NDArray take(NumSharp.NDArray a, long index, int? axis = null, NumSharp.NDArray out = null, string mode = ""raise"")",src/NumSharp.Core/Indexing/np.take.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.take.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.take.html +numpy.ndarray.to_device,numpy,ndarray,Array methods,to_device,method,True,missing,missing,missing,"(self, device, /, *, stream=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.to_device.html +numpy.ndarray.tobytes,numpy,ndarray,Array methods,tobytes,method,True,available,exact,declared,"(self, /, order='C')",NumSharp.NDArray.tobytes,byte[] tobytes(char order = 'C'),src/NumSharp.Core/Casting/NdArray.tobytes.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArray.tobytes.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tobytes.html +numpy.ndarray.tofile,numpy,ndarray,Array methods,tofile,method,True,available,exact,declared,"(self, fid, /, sep='', format='%s')",NumSharp.NDArray.tofile,"void tofile(System.IO.Stream stream, string sep = """", string format = ""%s"") | void tofile(string fid, string sep = """", string format = ""%s"")",src/NumSharp.Core/APIs/np.tofile.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.tofile.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tofile.html +numpy.ndarray.tolist,numpy,ndarray,Array methods,tolist,method,True,available,exact,declared,"(self, /)",NumSharp.NDArray.tolist,object tolist(),src/NumSharp.Core/Manipulation/NDArray.tolist.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.tolist.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tolist.html +numpy.ndarray.trace,numpy,ndarray,Array methods,trace,method,True,available,alias,declared,"(self, /, offset=0, axis1=0, axis2=1, dtype=None, out=None)",NumSharp.np.trace,"NumSharp.NDArray trace(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1, System.Type dtype = null, NumSharp.NDArray out = null)",src/NumSharp.Core/Indexing/np.trace.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.trace.cs,False,Available through the static NumSharp np API instead of the NumPy instance method.,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.trace.html +numpy.ndarray.transpose,numpy,ndarray,Array methods,transpose,method,True,available,exact,declared,"(self, /, *axes)",NumSharp.NDArray.transpose,NumSharp.NDArray transpose(int[] premute = null),src/NumSharp.Core/Manipulation/NdArray.Transpose.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NdArray.Transpose.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.transpose.html +numpy.ndarray.var,numpy,ndarray,Reductions,var,method,True,available,exact,declared,"(self, /, axis=None, dtype=None, out=None, ddof=0, **kwargs)",NumSharp.NDArray.var,"NumSharp.NDArray var(bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray var(int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Statistics/NDArray.var.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.var.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.var.html +numpy.ndarray.view,numpy,ndarray,Array methods,view,method,True,available,exact,declared,"(self, /, *args, **kwargs)",NumSharp.NDArray.view,NumSharp.Generic.NDArray view() | NumSharp.NDArray view(System.Type dtype = null),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndarray.view.html +numpy.__array_namespace_info__,numpy,np,Types,__array_namespace_info__,class,False,missing,missing,missing,(),,,,,False,, +numpy.__version__,numpy,np,Types & constants,__version__,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.abs,numpy,np,Math,abs,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.abs,"NumSharp.NDArray abs(NumSharp.NDArray a) | NumSharp.NDArray abs(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray abs(NumSharp.NDArray a, NumSharp.NPTypeCode? dtype) | NumSharp.NDArray abs(NumSharp.NDArray a, System.Type dtype)",src/NumSharp.Core/Math/np.absolute.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.absolute.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.absolute.html +numpy.absolute,numpy,np,Math,absolute,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.absolute,"NumSharp.NDArray absolute(NumSharp.NDArray a) | NumSharp.NDArray absolute(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray absolute(NumSharp.NDArray a, NumSharp.NPTypeCode? dtype) | NumSharp.NDArray absolute(NumSharp.NDArray a, System.Type dtype)",src/NumSharp.Core/Math/np.absolute.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.absolute.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.absolute.html +numpy.acos,numpy,np,Math,acos,ufunc,True,available,alias,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arccos,"NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arccos(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.cos.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs,False,NumSharp exposes the canonical NumPy name arccos.,https://numpy.org/doc/stable/reference/generated/numpy.acos.html +numpy.acosh,numpy,np,Math,acosh,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.acosh.html +numpy.add,numpy,np,Math,add,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.add,"NumSharp.NDArray add(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.add.html +numpy.all,numpy,np,Reductions,all,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, *, where=)",NumSharp.np.all,"NumSharp.Generic.NDArray all(NumSharp.NDArray nd, bool keepdims) | NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int axis, bool keepdims = false) | NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int[] axis, bool keepdims = false) | NumSharp.NDArray all(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null) | NumSharp.NDArray all(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null) | bool all(NumSharp.NDArray a)",src/NumSharp.Core/Logic/np.all.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.all.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.all.html +numpy.allclose,numpy,np,Logic & comparison,allclose,function,True,available,exact,declared,"(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)",NumSharp.np.allclose,"bool allclose(NumSharp.NDArray a, NumSharp.NDArray b, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)",src/NumSharp.Core/Logic/np.allclose.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.allclose.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.allclose.html +numpy.amax,numpy,np,Reductions,amax,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, initial=, where=)",NumSharp.np.amax,"NumSharp.NDArray amax(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null) | T amax(NumSharp.NDArray a)",src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.amax.html +numpy.amin,numpy,np,Reductions,amin,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, initial=, where=)",NumSharp.np.amin,"NumSharp.NDArray amin(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null) | T amin(NumSharp.NDArray a)",src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.amin.html +numpy.angle,numpy,np,Math,angle,function,True,missing,missing,missing,"(z, deg=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.angle.html +numpy.any,numpy,np,Reductions,any,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, *, where=)",NumSharp.np.any,"NumSharp.Generic.NDArray any(NumSharp.NDArray nd, bool keepdims) | NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int axis, bool keepdims = false) | NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int[] axis, bool keepdims = false) | NumSharp.NDArray any(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null) | NumSharp.NDArray any(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null) | bool any(NumSharp.NDArray a)",src/NumSharp.Core/Logic/np.any.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.any.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.any.html +numpy.append,numpy,np,Shape manipulation,append,function,True,available,exact,declared,"(arr, values, axis=None)",NumSharp.np.append,"NumSharp.NDArray append(NumSharp.NDArray arr, NumSharp.NDArray values, int? axis = null) | NumSharp.NDArray append(NumSharp.NDArray arr, object values, int? axis = null)",src/NumSharp.Core/Manipulation/np.append.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.append.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.append.html +numpy.apply_along_axis,numpy,np,Shape manipulation,apply_along_axis,function,True,missing,missing,missing,"(func1d, axis, arr, *args, **kwargs)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.apply_along_axis.html +numpy.apply_over_axes,numpy,np,Shape manipulation,apply_over_axes,function,True,missing,missing,missing,"(func, a, axes)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.apply_over_axes.html +numpy.arange,numpy,np,Array creation,arange,function,True,available,exact,declared,"(start_or_stop, /, stop=None, step=1, *, dtype=None, device=None, like=None)",NumSharp.np.arange,"NumSharp.NDArray arange(double start, double stop, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arange(double start, double stop, System.Type dtype) | NumSharp.NDArray arange(double start, double stop, double step = 1) | NumSharp.NDArray arange(double start, double stop, double step, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arange(double start, double stop, double step, System.Type dtype) | NumSharp.NDArray arange(double stop) | NumSharp.NDArray arange(double stop, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arange(double stop, System.Type dtype) | NumSharp.NDArray arange(float start, float stop, float step = 1) | NumSharp.NDArray arange(float stop) | NumSharp.NDArray arange(int start, int stop, int step = 1) | NumSharp.NDArray arange(int stop) | NumSharp.NDArray arange(long start, long stop, long step = 1) | NumSharp.NDArray arange(long stop)",src/NumSharp.Core/Creation/np.arange.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.arange.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.arange.html +numpy.arccos,numpy,np,Math,arccos,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arccos,"NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arccos(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.cos.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.arccos.html +numpy.arccosh,numpy,np,Math,arccosh,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.arccosh.html +numpy.arcsin,numpy,np,Math,arcsin,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arcsin,"NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arcsin(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.sin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html +numpy.arcsinh,numpy,np,Math,arcsinh,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.arcsinh.html +numpy.arctan,numpy,np,Math,arctan,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arctan,"NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arctan(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.tan.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.arctan.html +numpy.arctan2,numpy,np,Math,arctan2,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arctan2,"NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.tan.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html +numpy.arctanh,numpy,np,Math,arctanh,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.arctanh.html +numpy.argmax,numpy,np,Reductions,argmax,function,True,available,exact,declared,"(a, axis=None, out=None, *, keepdims=)",NumSharp.np.argmax,"NumSharp.NDArray argmax(NumSharp.NDArray a, int axis, bool keepdims = false) | long argmax(NumSharp.NDArray a)",src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.argmax.html +numpy.argmin,numpy,np,Reductions,argmin,function,True,available,exact,declared,"(a, axis=None, out=None, *, keepdims=)",NumSharp.np.argmin,"NumSharp.NDArray argmin(NumSharp.NDArray a, int axis, bool keepdims = false) | long argmin(NumSharp.NDArray a)",src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.argmin.html +numpy.argpartition,numpy,np,Sorting & searching,argpartition,function,True,missing,missing,missing,"(a, kth, axis=-1, kind='introselect', order=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.argpartition.html +numpy.argsort,numpy,np,Sorting & searching,argsort,function,True,available,exact,declared,"(a, axis=-1, kind=None, order=None, *, stable=None)",NumSharp.np.argsort,"NumSharp.NDArray argsort(NumSharp.NDArray nd, int axis = -1) | NumSharp.NDArray argsort(NumSharp.NDArray nd, int? axis = -1)",src/NumSharp.Core/Sorting_Searching_Counting/np.argsort.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.argsort.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.argsort.html +numpy.argwhere,numpy,np,Sorting & searching,argwhere,function,True,available,exact,declared,(a),NumSharp.np.argwhere,NumSharp.NDArray argwhere(NumSharp.NDArray a),src/NumSharp.Core/Indexing/np.argwhere.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.argwhere.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.argwhere.html +numpy.around,numpy,np,Math,around,function,True,available,exact,declared,"(a, decimals=0, out=None)",NumSharp.np.around,"NumSharp.NDArray around(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray around(NumSharp.NDArray x, System.Type dtype) | NumSharp.NDArray around(NumSharp.NDArray x, int decimals = 0, NumSharp.NDArray out = null) | NumSharp.NDArray around(NumSharp.NDArray x, int decimals, NumSharp.NPTypeCode dtype) | NumSharp.NDArray around(NumSharp.NDArray x, int decimals, System.Type dtype)",src/NumSharp.Core/Math/np.round.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.round.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.around.html +numpy.array,numpy,np,Array creation,array,function,True,available,exact,declared,"(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, ndmax=0, like=None)",NumSharp.np.array,"NumSharp.NDArray array(NumSharp.NDArray nd, bool copy = true) | NumSharp.NDArray array(System.Array array, System.Type dtype = null, int ndmin = 1, bool copy = true, char order = 'C') | NumSharp.NDArray array(System.Collections.Generic.IEnumerable data) | NumSharp.NDArray array(System.Collections.Generic.IEnumerable data, int size) | NumSharp.NDArray array(System.Collections.Generic.IEnumerable data, long size) | NumSharp.NDArray array(T scalar) | NumSharp.NDArray array(T[] data, NumSharp.NPTypeCode dtype) | NumSharp.NDArray array(T[] data, NumSharp.NPTypeCode dtype) | NumSharp.NDArray array(T[] data, System.Type dtype) | NumSharp.NDArray array(T[] data, System.Type dtype) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy = true) | NumSharp.NDArray array(T[] data, bool copy) | NumSharp.NDArray array(T[][] data) | NumSharp.NDArray array(T[][][] data) | NumSharp.NDArray array(T[][][][] data) | NumSharp.NDArray array(T[][][][][] data) | NumSharp.NDArray array(params T[] data) | NumSharp.NDArray array(string chars) | NumSharp.NDArray array(string[] strArray)",src/NumSharp.Core/Creation/np.array.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.array.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.array.html +numpy.array2string,numpy,np,Text & formatting,array2string,function,True,available,exact,declared,"(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', *, formatter=None, threshold=None, edgeitems=None, sign=None, floatmode=None, suffix='', legacy=None)",NumSharp.np.array2string,"string array2string(NumSharp.NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null, string separator = "" "", string prefix = """", int? threshold = null, int? edgeitems = null, char? sign = null, string floatmode = null, string suffix = """")",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.array2string.html +numpy.array_equal,numpy,np,Logic & comparison,array_equal,function,True,available,exact,declared,"(a1, a2, equal_nan=False)",NumSharp.np.array_equal,"bool array_equal(NumSharp.NDArray a, NumSharp.NDArray b)",src/NumSharp.Core/Logic/np.array_equal.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.array_equal.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.array_equal.html +numpy.array_equiv,numpy,np,Logic & comparison,array_equiv,function,True,missing,missing,missing,"(a1, a2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.array_equiv.html +numpy.array_repr,numpy,np,Text & formatting,array_repr,function,True,available,exact,declared,"(arr, max_line_width=None, precision=None, suppress_small=None)",NumSharp.np.array_repr,"string array_repr(NumSharp.NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null)",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.array_repr.html +numpy.array_split,numpy,np,Shape manipulation,array_split,function,True,available,exact,declared,"(ary, indices_or_sections, axis=0)",NumSharp.np.array_split,"NumSharp.NDArray[] array_split(NumSharp.NDArray ary, int indices_or_sections, int axis = 0) | NumSharp.NDArray[] array_split(NumSharp.NDArray ary, int[] indices, int axis = 0) | NumSharp.NDArray[] array_split(NumSharp.NDArray ary, long[] indices, int axis = 0)",src/NumSharp.Core/Manipulation/np.split.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.split.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.array_split.html +numpy.array_str,numpy,np,Text & formatting,array_str,function,True,available,exact,declared,"(a, max_line_width=None, precision=None, suppress_small=None)",NumSharp.np.array_str,"string array_str(NumSharp.NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null)",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.array_str.html +numpy.asanyarray,numpy,np,Array creation,asanyarray,function,True,available,exact,declared,"(a, dtype=None, order=None, *, device=None, copy=None, like=None)",NumSharp.np.asanyarray,"NumSharp.NDArray asanyarray(ref object a, System.Type dtype = null) | NumSharp.NDArray asanyarray(ref object a, System.Type dtype, char order)",src/NumSharp.Core/Creation/np.asanyarray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asanyarray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.asanyarray.html +numpy.asarray,numpy,np,Array creation,asarray,function,True,available,exact,declared,"(a, dtype=None, order=None, *, device=None, copy=None, like=None)",NumSharp.np.asarray,"NumSharp.NDArray asarray(NumSharp.NDArray a, NumSharp.DType dtype, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null) | NumSharp.NDArray asarray(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null) | NumSharp.NDArray asarray(NumSharp.NDArray a, System.Type dtype = null, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null) | NumSharp.NDArray asarray(NumSharp.NDArray a, string dtype, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null) | NumSharp.NDArray asarray(T data) | NumSharp.NDArray asarray(T[] data, int ndim = 1) | NumSharp.NDArray asarray(string data) | NumSharp.NDArray asarray(string[] data, int ndim = 1)",src/NumSharp.Core/Creation/np.asarray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asarray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.asarray.html +numpy.asarray_chkfinite,numpy,np,Array creation,asarray_chkfinite,function,True,available,exact,declared,"(a, dtype=None, order=None)",NumSharp.np.asarray_chkfinite,"NumSharp.NDArray asarray_chkfinite(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, char order = 'K') | NumSharp.NDArray asarray_chkfinite(NumSharp.NDArray a, System.Type dtype = null, char order = 'K') | NumSharp.NDArray asarray_chkfinite(NumSharp.NDArray a, string dtype, char order = 'K')",src/NumSharp.Core/Creation/np.asarray_chkfinite.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asarray_chkfinite.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.asarray_chkfinite.html +numpy.ascontiguousarray,numpy,np,Array creation,ascontiguousarray,function,True,available,exact,declared,"(a, dtype=None, *, like=None)",NumSharp.np.ascontiguousarray,"NumSharp.NDArray ascontiguousarray(NumSharp.NDArray a, System.Type dtype = null)",src/NumSharp.Core/Creation/np.ascontiguousarray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.ascontiguousarray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ascontiguousarray.html +numpy.asfortranarray,numpy,np,Array creation,asfortranarray,function,True,available,exact,declared,"(a, dtype=None, *, like=None)",NumSharp.np.asfortranarray,"NumSharp.NDArray asfortranarray(NumSharp.NDArray a, System.Type dtype = null)",src/NumSharp.Core/Creation/np.asfortranarray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asfortranarray.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.asfortranarray.html +numpy.asin,numpy,np,Math,asin,ufunc,True,available,alias,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arcsin,"NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arcsin(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.sin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs,False,NumSharp exposes the canonical NumPy name arcsin.,https://numpy.org/doc/stable/reference/generated/numpy.asin.html +numpy.asinh,numpy,np,Math,asinh,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.asinh.html +numpy.asmatrix,numpy,np,Array creation,asmatrix,function,True,available,exact,declared,"(data, dtype=None)",NumSharp.np.asmatrix,"NumSharp.NDArray asmatrix(NumSharp.NDArray data, NumSharp.NPTypeCode dtype) | NumSharp.NDArray asmatrix(NumSharp.NDArray data, System.Type dtype = null) | NumSharp.NDArray asmatrix(NumSharp.NDArray data, string dtype) | NumSharp.NDArray asmatrix(string data, NumSharp.NPTypeCode dtype) | NumSharp.NDArray asmatrix(string data, System.Type dtype = null)",src/NumSharp.Core/Creation/np.asmatrix.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asmatrix.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.asmatrix.html +numpy.astype,numpy,np,Dtype & promotion,astype,function,True,available,alias,declared,"(x, dtype, /, *, copy=True, device=None)",NumSharp.NDArray.astype,"NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy = true) | NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy, char order, string casting = ""unsafe"") | NumSharp.NDArray astype(System.Type dtype, bool copy = true) | NumSharp.NDArray astype(System.Type dtype, bool copy, char order, string casting = ""unsafe"")",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,The NumPy 2.x top-level helper is available as the NDArray instance method.,https://numpy.org/doc/stable/reference/generated/numpy.astype.html +numpy.atan,numpy,np,Math,atan,ufunc,True,available,alias,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arctan,"NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arctan(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.tan.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs,False,NumSharp exposes the canonical NumPy name arctan.,https://numpy.org/doc/stable/reference/generated/numpy.atan.html +numpy.atan2,numpy,np,Math,atan2,ufunc,True,available,alias,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.arctan2,"NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.tan.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs,False,NumSharp exposes the canonical NumPy name arctan2.,https://numpy.org/doc/stable/reference/generated/numpy.atan2.html +numpy.atanh,numpy,np,Math,atanh,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.atanh.html +numpy.atleast_1d,numpy,np,Shape manipulation,atleast_1d,function,True,available,exact,declared,(*arys),NumSharp.np.atleast_1d,NumSharp.NDArray atleast_1d(NumSharp.NDArray arr) | NumSharp.NDArray atleast_1d(object arys) | NumSharp.NDArray[] atleast_1d(params NumSharp.NDArray[] arys) | NumSharp.NDArray[] atleast_1d(params object[] arys),src/NumSharp.Core/Manipulation/np.atleastd.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.atleastd.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.atleast_1d.html +numpy.atleast_2d,numpy,np,Shape manipulation,atleast_2d,function,True,available,exact,declared,(*arys),NumSharp.np.atleast_2d,NumSharp.NDArray atleast_2d(NumSharp.NDArray arr) | NumSharp.NDArray atleast_2d(object arys) | NumSharp.NDArray[] atleast_2d(params NumSharp.NDArray[] arys) | NumSharp.NDArray[] atleast_2d(params object[] arys),src/NumSharp.Core/Manipulation/np.atleastd.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.atleastd.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html +numpy.atleast_3d,numpy,np,Shape manipulation,atleast_3d,function,True,available,exact,declared,(*arys),NumSharp.np.atleast_3d,NumSharp.NDArray atleast_3d(NumSharp.NDArray arr) | NumSharp.NDArray atleast_3d(object arys) | NumSharp.NDArray[] atleast_3d(params NumSharp.NDArray[] arys) | NumSharp.NDArray[] atleast_3d(params object[] arys),src/NumSharp.Core/Manipulation/np.atleastd.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.atleastd.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.atleast_3d.html +numpy.average,numpy,np,Reductions,average,function,True,available,exact,declared,"(a, axis=None, weights=None, returned=False, *, keepdims=)",NumSharp.np.average,"NumSharp.NDArray average(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray weights = null, bool keepdims = false) | NumSharp.NDArray average(NumSharp.NDArray a, int[] axis, NumSharp.NDArray weights = null, bool keepdims = false)",src/NumSharp.Core/Statistics/np.average.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.average.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.average.html +numpy.bartlett,numpy,np,Window functions,bartlett,function,True,missing,missing,missing,(M),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.bartlett.html +numpy.base_repr,numpy,np,Text & formatting,base_repr,function,True,missing,missing,missing,"(number, base=2, padding=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.base_repr.html +numpy.binary_repr,numpy,np,Text & formatting,binary_repr,function,True,missing,missing,missing,"(num, width=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.binary_repr.html +numpy.bincount,numpy,np,Statistics & histograms,bincount,function,True,missing,missing,missing,"(x, /, weights=None, minlength=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.bincount.html +numpy.bitwise_and,numpy,np,Math,bitwise_and,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.bitwise_and,"NumSharp.NDArray bitwise_and(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.bitwise.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.bitwise.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.bitwise_and.html +numpy.bitwise_count,numpy,np,Math,bitwise_count,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.bitwise_count.html +numpy.bitwise_invert,numpy,np,Math,bitwise_invert,ufunc,True,available,alias,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.invert,"NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NPTypeCode outType) | NumSharp.NDArray invert(NumSharp.NDArray x, System.Type outType)",src/NumSharp.Core/Math/np.invert.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.invert.cs,False,NumSharp exposes the ufunc alias invert.,https://numpy.org/doc/stable/reference/generated/numpy.bitwise_invert.html +numpy.bitwise_left_shift,numpy,np,Math,bitwise_left_shift,ufunc,True,available,alias,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.left_shift,"NumSharp.NDArray left_shift(NumSharp.NDArray x1, NumSharp.NDArray x2) | NumSharp.NDArray left_shift(NumSharp.NDArray x1, object x2)",src/NumSharp.Core/Math/np.left_shift.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.left_shift.cs,False,NumSharp exposes the ufunc alias left_shift.,https://numpy.org/doc/stable/reference/generated/numpy.bitwise_left_shift.html +numpy.bitwise_not,numpy,np,Math,bitwise_not,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.bitwise_not,"NumSharp.NDArray bitwise_not(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray bitwise_not(NumSharp.NDArray x, NumSharp.NPTypeCode outType) | NumSharp.NDArray bitwise_not(NumSharp.NDArray x, System.Type outType)",src/NumSharp.Core/Math/np.invert.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.invert.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.invert.html +numpy.bitwise_or,numpy,np,Math,bitwise_or,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.bitwise_or,"NumSharp.NDArray bitwise_or(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.bitwise.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.bitwise.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.bitwise_or.html +numpy.bitwise_right_shift,numpy,np,Math,bitwise_right_shift,ufunc,True,available,alias,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.right_shift,"NumSharp.NDArray right_shift(NumSharp.NDArray x1, NumSharp.NDArray x2) | NumSharp.NDArray right_shift(NumSharp.NDArray x1, object x2)",src/NumSharp.Core/Math/np.right_shift.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.right_shift.cs,False,NumSharp exposes the ufunc alias right_shift.,https://numpy.org/doc/stable/reference/generated/numpy.bitwise_right_shift.html +numpy.bitwise_xor,numpy,np,Math,bitwise_xor,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.bitwise_xor,"NumSharp.NDArray bitwise_xor(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.bitwise.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.bitwise.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.bitwise_xor.html +numpy.blackman,numpy,np,Window functions,blackman,function,True,missing,missing,missing,(M),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.blackman.html +numpy.block,numpy,np,Shape manipulation,block,function,True,available,exact,declared,(arrays),NumSharp.np.block,NumSharp.NDArray block(object arrays),src/NumSharp.Core/Creation/np.block.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.block.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.block.html +numpy.bmat,numpy,np,Linear algebra,bmat,function,True,missing,missing,missing,"(obj, ldict=None, gdict=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.bmat.html +numpy.bool,numpy,np,Types,bool,class,False,available,exact,declared,"(value=False, /)",NumSharp.np.bool,readonly System.Type bool,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.bool_,numpy,np,Types,bool_,class,False,available,exact,declared,"(value=False, /)",NumSharp.np.bool_,readonly System.Type bool_,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.broadcast,numpy,np,Types,broadcast,class,False,available,exact,declared,(*arrays),NumSharp.np.broadcast,"NumSharp.np+Broadcast broadcast(NumSharp.NDArray nd1, NumSharp.NDArray nd2) | NumSharp.np+Broadcast broadcast(params NumSharp.NDArray[] arrays)",src/NumSharp.Core/Creation/np.broadcast.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.broadcast.cs,False,, +numpy.broadcast_arrays,numpy,np,Shape manipulation,broadcast_arrays,function,True,available,exact,declared,"(*args, subok=False)",NumSharp.np.broadcast_arrays,"NumSharp.NDArray[] broadcast_arrays(params NumSharp.NDArray[] ndArrays) | System.ValueTuple broadcast_arrays(NumSharp.NDArray lhs, NumSharp.NDArray rhs)",src/NumSharp.Core/Creation/np.broadcast_arrays.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.broadcast_arrays.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html +numpy.broadcast_shapes,numpy,np,Shape manipulation,broadcast_shapes,function,True,missing,missing,missing,(*args),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.broadcast_shapes.html +numpy.broadcast_to,numpy,np,Shape manipulation,broadcast_to,function,True,available,exact,declared,"(array, shape, subok=False)",NumSharp.np.broadcast_to,"NumSharp.NDArray broadcast_to(NumSharp.Backends.UnmanagedStorage from, NumSharp.Backends.UnmanagedStorage against) | NumSharp.NDArray broadcast_to(NumSharp.Backends.UnmanagedStorage from, NumSharp.NDArray against) | NumSharp.NDArray broadcast_to(NumSharp.Backends.UnmanagedStorage from, NumSharp.Shape against) | NumSharp.NDArray broadcast_to(NumSharp.NDArray from, NumSharp.Backends.UnmanagedStorage against) | NumSharp.NDArray broadcast_to(NumSharp.NDArray from, NumSharp.NDArray against) | NumSharp.NDArray broadcast_to(NumSharp.NDArray from, NumSharp.Shape against) | NumSharp.Shape broadcast_to(NumSharp.Shape from, NumSharp.Backends.UnmanagedStorage against) | NumSharp.Shape broadcast_to(NumSharp.Shape from, NumSharp.NDArray against) | NumSharp.Shape broadcast_to(NumSharp.Shape from, NumSharp.Shape against)",src/NumSharp.Core/Creation/np.broadcast_to.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.broadcast_to.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html +numpy.busday_count,numpy,np,Date & time,busday_count,function,True,missing,missing,missing,"(begindates, enddates, weekmask='1111100', holidays=(), busdaycal=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.busday_count.html +numpy.busday_offset,numpy,np,Date & time,busday_offset,function,True,missing,missing,missing,"(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.busday_offset.html +numpy.busdaycalendar,numpy,np,Types,busdaycalendar,class,False,missing,missing,missing,"(weekmask='1111100', holidays=None)",,,,,False,, +numpy.byte,numpy,np,Types,byte,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.byte,readonly System.Type byte,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.bytes_,numpy,np,Types,bytes_,class,False,missing,missing,missing,"(value='', /, *args, **kwargs)",,,,,False,, +numpy.c_,numpy,np,Types & constants,c_,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.can_cast,numpy,np,Dtype & promotion,can_cast,function,True,available,exact,declared,"(from_, to, casting='safe')",NumSharp.np.can_cast,"bool can_cast(NumSharp.NDArray from, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(NumSharp.NPTypeCode from, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(System.Type from, System.Type to, string casting = ""safe"") | bool can_cast(bool value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(byte value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(decimal value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(double value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(float value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(int value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(long value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(object value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(short value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(string casting = ""safe"") | bool can_cast(uint value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(ulong value, NumSharp.NPTypeCode to, string casting = ""safe"") | bool can_cast(ushort value, NumSharp.NPTypeCode to, string casting = ""safe"")",src/NumSharp.Core/Logic/np.can_cast.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.can_cast.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.can_cast.html +numpy.cbrt,numpy,np,Math,cbrt,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.cbrt,"NumSharp.NDArray cbrt(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray cbrt(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray cbrt(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.cbrt.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cbrt.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.cbrt.html +numpy.cdouble,numpy,np,Types,cdouble,class,False,available,exact,declared,"(real=0, imag=0, /)",NumSharp.np.cdouble,readonly System.Type cdouble,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ceil,numpy,np,Math,ceil,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.ceil,"NumSharp.NDArray ceil(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray ceil(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray ceil(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.ceil.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.ceil.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ceil.html +numpy.char,numpy,np,Namespaces,char,module,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.char,readonly System.Type char,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.character,numpy,np,Types,character,class,False,missing,missing,missing,(),,,,,False,, +numpy.choose,numpy,np,Indexing & selection,choose,function,True,missing,missing,missing,"(a, choices, out=None, mode='raise')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.choose.html +numpy.clip,numpy,np,Math,clip,function,True,available,exact,declared,"(a, a_min=, a_max=, out=None, *, min=, max=, **kwargs)",NumSharp.np.clip,"NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min = null, NumSharp.NDArray a_max = null, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, NumSharp.NDArray min = null, NumSharp.NDArray max = null) | NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min, NumSharp.NDArray a_max, System.Type dtype)",src/NumSharp.Core/Math/np.clip.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.clip.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.clip.html +numpy.clongdouble,numpy,np,Types,clongdouble,class,False,available,exact,declared,"(real=0, imag=0, /)",NumSharp.np.clongdouble,readonly System.Type clongdouble,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.column_stack,numpy,np,Shape manipulation,column_stack,function,True,available,exact,declared,(tup),NumSharp.np.column_stack,NumSharp.NDArray column_stack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/np.column_stack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.column_stack.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.column_stack.html +numpy.common_type,numpy,np,Dtype & promotion,common_type,function,True,available,exact,declared,(*arrays),NumSharp.np.common_type,System.Type common_type(params NumSharp.NDArray[] arrays),src/NumSharp.Core/Logic/np.common_type.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.common_type.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.common_type.html +numpy.complex128,numpy,np,Types,complex128,class,False,available,exact,declared,"(real=0, imag=0, /)",NumSharp.np.complex128,readonly System.Type complex128,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.complex64,numpy,np,Types,complex64,class,False,unsupported,exact,unsupported,"(real=0, imag=0, /)",NumSharp.np.complex64,System.Type complex64 { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,"The public compatibility symbol exists, but NumSharp does not implement a Complex64 storage dtype.", +numpy.complexfloating,numpy,np,Types,complexfloating,class,False,missing,missing,missing,(),,,,,False,, +numpy.compress,numpy,np,Indexing & selection,compress,function,True,available,exact,declared,"(condition, a, axis=None, out=None)",NumSharp.np.compress,"NumSharp.NDArray compress(NumSharp.NDArray condition, NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null)",src/NumSharp.Core/Indexing/np.compress.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.compress.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.compress.html +numpy.concat,numpy,np,Shape manipulation,concat,function,True,available,exact,declared,"(arrays, /, axis=0, out=None, *, dtype=None, casting='same_kind')",NumSharp.np.concat,"NumSharp.NDArray concat(NumSharp.NDArray[] arrays, int? axis = 0, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, string casting = ""same_kind"") | NumSharp.NDArray concat(System.ValueTuple> arrays, int axis = 0) | NumSharp.NDArray concat(System.ValueTuple> arrays, int axis = 0) | NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0)",src/NumSharp.Core/Creation/np.concat.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.concat.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.concat.html +numpy.concatenate,numpy,np,Shape manipulation,concatenate,function,True,available,exact,declared,"(arrays, /, axis=0, out=None, *, dtype=None, casting='same_kind')",NumSharp.np.concatenate,"NumSharp.NDArray concatenate(NumSharp.NDArray[] arrays, int? axis = 0, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, string casting = ""same_kind"") | NumSharp.NDArray concatenate(System.ValueTuple> arrays, int axis = 0) | NumSharp.NDArray concatenate(System.ValueTuple> arrays, int axis = 0) | NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0) | NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0)",src/NumSharp.Core/Creation/np.concatenate.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.concatenate.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html +numpy.conj,numpy,np,Math,conj,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.conj.html +numpy.conjugate,numpy,np,Math,conjugate,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.conjugate.html +numpy.convolve,numpy,np,Math,convolve,function,True,available,exact,declared,"(a, v, mode='full')",NumSharp.np.convolve,"NumSharp.NDArray convolve(NumSharp.NDArray a, NumSharp.NDArray v, string mode = ""full"")",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.convolve.html +numpy.copy,numpy,np,Array creation,copy,function,True,available,exact,declared,"(a, order='K', subok=False)",NumSharp.np.copy,"NumSharp.NDArray copy(NumSharp.NDArray a, char order = 'K')",src/NumSharp.Core/Creation/np.copy.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.copy.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.copy.html +numpy.copysign,numpy,np,Math,copysign,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.copysign.html +numpy.copyto,numpy,np,Array metadata & memory,copyto,function,True,available,exact,declared,"(dst, src, casting='same_kind', where=True)",NumSharp.np.copyto,"void copyto(NumSharp.NDArray dst, NumSharp.NDArray src, string casting = ""same_kind"", NumSharp.NDArray where = null)",src/NumSharp.Core/Manipulation/np.copyto.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.copyto.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.copyto.html +numpy.core,numpy,np,Namespaces,core,module,False,missing,missing,missing,The `numpy.core` submodule exists solely for backward compatibility,,,,,False,, +numpy.corrcoef,numpy,np,Statistics & histograms,corrcoef,function,True,missing,missing,missing,"(x, y=None, rowvar=True, *, dtype=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.corrcoef.html +numpy.correlate,numpy,np,Statistics & histograms,correlate,function,True,missing,missing,missing,"(a, v, mode='valid')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.correlate.html +numpy.cos,numpy,np,Math,cos,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.cos,"NumSharp.NDArray cos(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray cos(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray cos(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.cos.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.cos.html +numpy.cosh,numpy,np,Math,cosh,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.cosh,"NumSharp.NDArray cosh(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray cosh(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray cosh(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.cos.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.cosh.html +numpy.count_nonzero,numpy,np,Reductions,count_nonzero,function,True,available,exact,declared,"(a, axis=None, *, keepdims=False)",NumSharp.np.count_nonzero,"NumSharp.NDArray count_nonzero(NumSharp.NDArray a, int axis, bool keepdims = false) | long count_nonzero(NumSharp.NDArray a)",src/NumSharp.Core/APIs/np.count_nonzero.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.count_nonzero.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.count_nonzero.html +numpy.cov,numpy,np,Statistics & histograms,cov,function,True,missing,missing,missing,"(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None, *, dtype=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.cov.html +numpy.cross,numpy,np,Math,cross,function,True,missing,missing,missing,"(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.cross.html +numpy.csingle,numpy,np,Types,csingle,class,False,available,exact,declared,"(real=0, imag=0, /)",NumSharp.np.csingle,System.Type csingle { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ctypeslib,numpy,np,Namespaces,ctypeslib,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.cumprod,numpy,np,Reductions,cumprod,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None)",NumSharp.np.cumprod,"NumSharp.NDArray cumprod(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)",src/NumSharp.Core/APIs/np.cumprod.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumprod.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.cumprod.html +numpy.cumsum,numpy,np,Reductions,cumsum,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None)",NumSharp.np.cumsum,"NumSharp.NDArray cumsum(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)",src/NumSharp.Core/APIs/np.cumsum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumsum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html +numpy.cumulative_prod,numpy,np,Reductions,cumulative_prod,function,True,available,alias,declared,"(x, /, *, axis=None, dtype=None, out=None, include_initial=False)",NumSharp.np.cumprod,"NumSharp.NDArray cumprod(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)",src/NumSharp.Core/APIs/np.cumprod.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumprod.cs,False,NumSharp exposes the established cumprod spelling.,https://numpy.org/doc/stable/reference/generated/numpy.cumulative_prod.html +numpy.cumulative_sum,numpy,np,Reductions,cumulative_sum,function,True,available,alias,declared,"(x, /, *, axis=None, dtype=None, out=None, include_initial=False)",NumSharp.np.cumsum,"NumSharp.NDArray cumsum(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)",src/NumSharp.Core/APIs/np.cumsum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumsum.cs,False,NumSharp exposes the established cumsum spelling.,https://numpy.org/doc/stable/reference/generated/numpy.cumulative_sum.html +numpy.datetime64,numpy,np,Types,datetime64,class,False,missing,missing,missing,"(value=None, /, *args)",,,,,False,, +numpy.datetime_as_string,numpy,np,Date & time,datetime_as_string,function,True,missing,missing,missing,"(arr, unit=None, timezone='naive', casting='same_kind')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.datetime_as_string.html +numpy.datetime_data,numpy,np,Date & time,datetime_data,function,True,missing,missing,missing,"(dtype, /)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.datetime_data.html +numpy.deg2rad,numpy,np,Math,deg2rad,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.deg2rad,"NumSharp.NDArray deg2rad(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray deg2rad(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray deg2rad(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.deg2rad.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.deg2rad.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.deg2rad.html +numpy.degrees,numpy,np,Math,degrees,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.degrees,"NumSharp.NDArray degrees(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray degrees(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray degrees(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.rad2deg.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.rad2deg.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.degrees.html +numpy.delete,numpy,np,Shape manipulation,delete,function,True,available,exact,declared,"(arr, obj, axis=None)",NumSharp.np.delete,"NumSharp.NDArray delete(NumSharp.NDArray arr, NumSharp.NDArray obj, int? axis = null) | NumSharp.NDArray delete(NumSharp.NDArray arr, NumSharp.Slice obj, int? axis = null) | NumSharp.NDArray delete(NumSharp.NDArray arr, bool[] obj, int? axis = null) | NumSharp.NDArray delete(NumSharp.NDArray arr, int obj, int? axis = null) | NumSharp.NDArray delete(NumSharp.NDArray arr, int[] obj, int? axis = null) | NumSharp.NDArray delete(NumSharp.NDArray arr, long obj, int? axis = null) | NumSharp.NDArray delete(NumSharp.NDArray arr, long[] obj, int? axis = null)",src/NumSharp.Core/Manipulation/np.delete.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.delete.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.delete.html +numpy.diag,numpy,np,Linear algebra,diag,function,True,missing,missing,missing,"(v, k=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.diag.html +numpy.diag_indices,numpy,np,Indexing & selection,diag_indices,function,True,missing,missing,missing,"(n, ndim=2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.diag_indices.html +numpy.diag_indices_from,numpy,np,Indexing & selection,diag_indices_from,function,True,missing,missing,missing,(arr),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.diag_indices_from.html +numpy.diagflat,numpy,np,Linear algebra,diagflat,function,True,missing,missing,missing,"(v, k=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.diagflat.html +numpy.diagonal,numpy,np,Linear algebra,diagonal,function,True,available,exact,declared,"(a, offset=0, axis1=0, axis2=1)",NumSharp.np.diagonal,"NumSharp.NDArray diagonal(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1)",src/NumSharp.Core/Indexing/np.diagonal.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.diagonal.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.diagonal.html +numpy.diff,numpy,np,Math,diff,function,True,available,exact,declared,"(a, n=1, axis=-1, prepend=, append=)",NumSharp.np.diff,"NumSharp.NDArray diff(NumSharp.NDArray a, int n = 1, int axis = -1, object prepend = null, object append = null)",src/NumSharp.Core/Math/np.diff.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.diff.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.diff.html +numpy.digitize,numpy,np,Statistics & histograms,digitize,function,True,missing,missing,missing,"(x, bins, right=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.digitize.html +numpy.divide,numpy,np,Math,divide,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.divide,"NumSharp.NDArray divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.divide.html +numpy.divmod,numpy,np,Math,divmod,ufunc,True,missing,missing,missing,"(x1, x2, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.divmod.html +numpy.dot,numpy,np,Math,dot,function,True,available,exact,declared,"(a, b, out=None)",NumSharp.np.dot,"NumSharp.NDArray dot(NumSharp.NDArray a, NumSharp.NDArray b)",src/NumSharp.Core/LinearAlgebra/np.dot.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.dot.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.dot.html +numpy.double,numpy,np,Types,double,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.double,readonly System.Type double,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.dsplit,numpy,np,Shape manipulation,dsplit,function,True,available,exact,declared,"(ary, indices_or_sections)",NumSharp.np.dsplit,"NumSharp.NDArray[] dsplit(NumSharp.NDArray ary, int indices_or_sections) | NumSharp.NDArray[] dsplit(NumSharp.NDArray ary, int[] indices)",src/NumSharp.Core/Manipulation/np.dsplit.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.dsplit.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.dsplit.html +numpy.dstack,numpy,np,Shape manipulation,dstack,function,True,available,exact,declared,(tup),NumSharp.np.dstack,NumSharp.NDArray dstack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/np.dstack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.dstack.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.dstack.html +numpy.dtype,numpy,np,Types,dtype,class,False,available,exact,declared,"(dtype, align=False, copy=False, **kwargs)",NumSharp.np.dtype,NumSharp.DType dtype(string dtype),src/NumSharp.Core/Creation/np.dtype.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.dtype.cs,False,, +numpy.dtypes,numpy,np,Namespaces,dtypes,module,False,missing,missing,missing,This module is home to specific dtypes related functionality and their classes.,,,,,False,, +numpy.e,numpy,np,Types & constants,e,constant,False,available,exact,declared,"Convert a string or number to a floating-point number, if possible.",NumSharp.np.e,double e { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ediff1d,numpy,np,Math,ediff1d,function,True,available,exact,declared,"(ary, to_end=None, to_begin=None)",NumSharp.np.ediff1d,"NumSharp.NDArray ediff1d(NumSharp.NDArray ary, object to_end = null, object to_begin = null)",src/NumSharp.Core/Math/np.ediff1d.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.ediff1d.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ediff1d.html +numpy.einsum,numpy,np,Linear algebra,einsum,function,True,missing,missing,missing,"(*operands, out=None, optimize=False, **kwargs)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.einsum.html +numpy.einsum_path,numpy,np,Linear algebra,einsum_path,function,True,missing,missing,missing,"(*operands, optimize='greedy', einsum_call=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.einsum_path.html +numpy.emath,numpy,np,Namespaces,emath,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.empty,numpy,np,Array creation,empty,function,True,available,exact,declared,"(shape, dtype=None, order='C', *, device=None, like=None)",NumSharp.np.empty,"NumSharp.NDArray empty(NumSharp.Shape shape) | NumSharp.NDArray empty(NumSharp.Shape shape, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray empty(NumSharp.Shape shape, System.Type dtype) | NumSharp.NDArray empty(NumSharp.Shape shape, char order, System.Type dtype = null) | NumSharp.NDArray empty(int shape) | NumSharp.NDArray empty(int[] shape) | NumSharp.NDArray empty(int[] shape) | NumSharp.NDArray empty(long[] shape) | NumSharp.NDArray empty(long[] shape)",src/NumSharp.Core/Creation/np.empty.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.empty.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.empty.html +numpy.empty_like,numpy,np,Array creation,empty_like,function,True,available,exact,declared,"(prototype, /, dtype=None, order='K', subok=True, shape=None, *, device=None)",NumSharp.np.empty_like,"NumSharp.NDArray empty_like(NumSharp.NDArray prototype, NumSharp.NPTypeCode typeCode, NumSharp.Shape shape = null) | NumSharp.NDArray empty_like(NumSharp.NDArray prototype, NumSharp.NPTypeCode typeCode, NumSharp.Shape shape, char order) | NumSharp.NDArray empty_like(NumSharp.NDArray prototype, System.Type dtype = null, NumSharp.Shape shape = null) | NumSharp.NDArray empty_like(NumSharp.NDArray prototype, System.Type dtype, NumSharp.Shape shape, char order)",src/NumSharp.Core/Creation/np.empty_like.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.empty_like.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.empty_like.html +numpy.equal,numpy,np,Logic & comparison,equal,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.equal,"NumSharp.Generic.NDArray equal(NumSharp.NDArray x1, object x2) | NumSharp.Generic.NDArray equal(object x1, NumSharp.NDArray x2) | NumSharp.NDArray equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.comparison.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.equal.html +numpy.errstate,numpy,np,Types,errstate,class,False,missing,missing,missing,"(*, call=, all=None, divide=None, over=None, under=None, invalid=None)",,,,,False,, +numpy.euler_gamma,numpy,np,Types & constants,euler_gamma,constant,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.euler_gamma,double euler_gamma { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.exceptions,numpy,np,Namespaces,exceptions,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.exp,numpy,np,Math,exp,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.exp,"NumSharp.NDArray exp(NumSharp.NDArray a) | NumSharp.NDArray exp(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray exp(NumSharp.NDArray a, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray exp(NumSharp.NDArray a, System.Type dtype)",src/NumSharp.Core/Statistics/np.exp.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.exp.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.exp.html +numpy.exp2,numpy,np,Math,exp2,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.exp2,"NumSharp.NDArray exp2(NumSharp.NDArray a) | NumSharp.NDArray exp2(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray exp2(NumSharp.NDArray a, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray exp2(NumSharp.NDArray a, System.Type dtype)",src/NumSharp.Core/Statistics/np.exp.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.exp.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.exp2.html +numpy.expand_dims,numpy,np,Shape manipulation,expand_dims,function,True,available,exact,declared,"(a, axis)",NumSharp.np.expand_dims,"NumSharp.NDArray expand_dims(NumSharp.NDArray a, System.Collections.Generic.IEnumerable axis) | NumSharp.NDArray expand_dims(NumSharp.NDArray a, int axis) | NumSharp.NDArray expand_dims(NumSharp.NDArray a, int[] axis)",src/NumSharp.Core/Manipulation/np.expand_dims.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.expand_dims.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.expand_dims.html +numpy.expm1,numpy,np,Math,expm1,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.expm1,"NumSharp.NDArray expm1(NumSharp.NDArray a) | NumSharp.NDArray expm1(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray expm1(NumSharp.NDArray a, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray expm1(NumSharp.NDArray a, System.Type dtype)",src/NumSharp.Core/Statistics/np.exp.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.exp.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.expm1.html +numpy.extract,numpy,np,Indexing & selection,extract,function,True,available,exact,declared,"(condition, arr)",NumSharp.np.extract,"NumSharp.NDArray extract(NumSharp.NDArray condition, NumSharp.NDArray arr)",src/NumSharp.Core/Indexing/np.extract.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.extract.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.extract.html +numpy.eye,numpy,np,Array creation,eye,function,True,available,exact,declared,"(N, M=None, k=0, dtype=, order='C', *, device=None, like=None)",NumSharp.np.eye,"NumSharp.NDArray eye(int N, int? M = null, int k = 0, System.Type dtype = null, char order = 'C')",src/NumSharp.Core/Creation/np.eye.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.eye.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.eye.html +numpy.f2py,numpy,np,Namespaces,f2py,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.fabs,numpy,np,Math,fabs,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fabs.html +numpy.False_,numpy,np,Types & constants,False_,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.fft,numpy,np,Namespaces,fft,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.fill_diagonal,numpy,np,Linear algebra,fill_diagonal,function,True,missing,missing,missing,"(a, val, wrap=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fill_diagonal.html +numpy.finfo,numpy,np,Types,finfo,class,False,available,exact,declared,(dtype),NumSharp.np.finfo,NumSharp.finfo finfo() | NumSharp.finfo finfo(NumSharp.NDArray arr) | NumSharp.finfo finfo(NumSharp.NPTypeCode typeCode) | NumSharp.finfo finfo(System.Type type) | NumSharp.finfo finfo(string dtypeName),src/NumSharp.Core/APIs/np.finfo.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.finfo.cs,False,, +numpy.fix,numpy,np,Math,fix,function,True,missing,missing,missing,"(x, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fix.html +numpy.flatiter,numpy,np,Types,flatiter,class,False,missing,missing,missing,(),,,,,False,, +numpy.flatnonzero,numpy,np,Sorting & searching,flatnonzero,function,True,available,exact,declared,(a),NumSharp.np.flatnonzero,NumSharp.Generic.NDArray flatnonzero(NumSharp.NDArray a),src/NumSharp.Core/Indexing/np.flatnonzero.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.flatnonzero.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.flatnonzero.html +numpy.flexible,numpy,np,Types,flexible,class,False,missing,missing,missing,(),,,,,False,, +numpy.flip,numpy,np,Shape manipulation,flip,function,True,available,exact,declared,"(m, axis=None)",NumSharp.np.flip,"NumSharp.NDArray flip(NumSharp.NDArray m, int? axis = null) | NumSharp.NDArray flip(NumSharp.NDArray m, int[] axis)",src/NumSharp.Core/Manipulation/np.flip.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.flip.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.flip.html +numpy.fliplr,numpy,np,Shape manipulation,fliplr,function,True,available,exact,declared,(m),NumSharp.np.fliplr,NumSharp.NDArray fliplr(NumSharp.NDArray m),src/NumSharp.Core/Manipulation/np.flip.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.flip.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.fliplr.html +numpy.flipud,numpy,np,Shape manipulation,flipud,function,True,available,exact,declared,(m),NumSharp.np.flipud,NumSharp.NDArray flipud(NumSharp.NDArray m),src/NumSharp.Core/Manipulation/np.flip.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.flip.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.flipud.html +numpy.float16,numpy,np,Types,float16,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.float16,readonly System.Type float16,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.float32,numpy,np,Types,float32,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.float32,readonly System.Type float32,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.float64,numpy,np,Types,float64,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.float64,readonly System.Type float64,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.float_power,numpy,np,Math,float_power,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.float_power.html +numpy.floating,numpy,np,Types,floating,class,False,missing,missing,missing,(),,,,,False,, +numpy.floor,numpy,np,Math,floor,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.floor,"NumSharp.NDArray floor(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray floor(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray floor(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.floor.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.floor.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.floor.html +numpy.floor_divide,numpy,np,Math,floor_divide,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.floor_divide,"NumSharp.NDArray floor_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray floor_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray floor_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype) | NumSharp.NDArray floor_divide(NumSharp.NDArray x1, object x2) | NumSharp.NDArray floor_divide(NumSharp.NDArray x1, object x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray floor_divide(NumSharp.NDArray x1, object x2, System.Type dtype)",src/NumSharp.Core/Math/np.floor_divide.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.floor_divide.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.floor_divide.html +numpy.fmax,numpy,np,Logic & comparison,fmax,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.fmax,"NumSharp.NDArray fmax(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out) | NumSharp.NDArray fmax(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray fmax(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)",src/NumSharp.Core/Math/np.maximum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.maximum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.fmax.html +numpy.fmin,numpy,np,Logic & comparison,fmin,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.fmin,"NumSharp.NDArray fmin(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out) | NumSharp.NDArray fmin(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray fmin(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)",src/NumSharp.Core/Math/np.minimum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.minimum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.fmin.html +numpy.fmod,numpy,np,Math,fmod,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fmod.html +numpy.format_float_positional,numpy,np,Text & formatting,format_float_positional,function,True,available,exact,declared,"(x, precision=None, unique=True, fractional=True, trim='k', sign=False, pad_left=None, pad_right=None, min_digits=None)",NumSharp.np.format_float_positional,"string format_float_positional(double x, int? precision = null, bool unique = true, bool fractional = true, char trim = 'k', bool sign = false, int? pad_left = null, int? pad_right = null, int? min_digits = null)",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.format_float_positional.html +numpy.format_float_scientific,numpy,np,Text & formatting,format_float_scientific,function,True,available,exact,declared,"(x, precision=None, unique=True, trim='k', sign=False, pad_left=None, exp_digits=None, min_digits=None)",NumSharp.np.format_float_scientific,"string format_float_scientific(double x, int? precision = null, bool unique = true, char trim = 'k', bool sign = false, int? pad_left = null, int? exp_digits = null, int? min_digits = null)",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.format_float_scientific.html +numpy.frexp,numpy,np,Math,frexp,ufunc,True,missing,missing,missing,"(x, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.frexp.html +numpy.from_dlpack,numpy,np,Array creation,from_dlpack,function,True,missing,missing,missing,"(x, /, *, device=None, copy=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.from_dlpack.html +numpy.frombuffer,numpy,np,Array creation,frombuffer,function,True,available,exact,declared,"(buffer, dtype=None, count=-1, offset=0, *, like=None)",NumSharp.np.frombuffer,"NumSharp.NDArray frombuffer(System.ArraySegment segment, NumSharp.NPTypeCode dtype, long count = -1) | NumSharp.NDArray frombuffer(System.ArraySegment segment, System.Type dtype = null, long count = -1) | NumSharp.NDArray frombuffer(System.IntPtr address, long byteLength, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0, System.Action dispose = null) | NumSharp.NDArray frombuffer(System.IntPtr address, long byteLength, System.Type dtype = null, long count = -1, long offset = 0, System.Action dispose = null) | NumSharp.NDArray frombuffer(System.Memory memory, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(System.Memory memory, System.Type dtype = null, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(System.ReadOnlySpan buffer, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(System.ReadOnlySpan buffer, System.Type dtype = null, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(System.Void* address, long byteLength, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0, System.Action dispose = null) | NumSharp.NDArray frombuffer(System.Void* address, long byteLength, System.Type dtype = null, long count = -1, long offset = 0, System.Action dispose = null) | NumSharp.NDArray frombuffer(TSource[] array, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(TSource[] array, System.Type dtype = null, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(byte[] buffer, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(byte[] buffer, System.Type dtype = null, long count = -1, long offset = 0) | NumSharp.NDArray frombuffer(byte[] buffer, string dtype, long count = -1, long offset = 0)",src/NumSharp.Core/Creation/np.frombuffer.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.frombuffer.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.frombuffer.html +numpy.fromfile,numpy,np,Array creation,fromfile,function,True,available,exact,declared,"(file, dtype=None, count=-1, sep='', offset=0, *, like=None)",NumSharp.np.fromfile,"NumSharp.NDArray fromfile(System.IO.Stream stream, NumSharp.NPTypeCode dtype, int count = -1, string sep = """", long offset = 0) | NumSharp.NDArray fromfile(System.IO.Stream stream, System.Type dtype = null, int count = -1, string sep = """", long offset = 0) | NumSharp.NDArray fromfile(string file, NumSharp.NPTypeCode dtype, int count = -1, string sep = """", long offset = 0) | NumSharp.NDArray fromfile(string file, System.Type dtype = null, int count = -1, string sep = """", long offset = 0)",src/NumSharp.Core/APIs/np.fromfile.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.fromfile.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.fromfile.html +numpy.fromfunction,numpy,np,Array creation,fromfunction,function,True,missing,missing,missing,"(function, shape, *, dtype=, like=None, **kwargs)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fromfunction.html +numpy.fromiter,numpy,np,Array creation,fromiter,function,True,missing,missing,missing,"(iter, dtype, count=-1, *, like=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fromiter.html +numpy.frompyfunc,numpy,np,Math,frompyfunc,function,True,missing,missing,missing,"(func, /, nin, nout, **kwargs)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.frompyfunc.html +numpy.fromregex,numpy,np,Array creation,fromregex,function,True,missing,missing,missing,"(file, regexp, dtype, encoding=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fromregex.html +numpy.fromstring,numpy,np,Array creation,fromstring,function,True,missing,missing,missing,"fromstring(string, dtype=float, count=-1, *, sep, like=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.fromstring.html +numpy.full,numpy,np,Array creation,full,function,True,available,exact,declared,"(shape, fill_value, dtype=None, order='C', *, device=None, like=None)",NumSharp.np.full,"NumSharp.NDArray full(NumSharp.Shape shape, object fill_value, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray full(NumSharp.Shape shape, object fill_value, System.Type dtype = null) | NumSharp.NDArray full(int[] shape, object fill_value) | NumSharp.NDArray full(int[] shape, object fill_value) | NumSharp.NDArray full(long[] shape, object fill_value) | NumSharp.NDArray full(long[] shape, object fill_value)",src/NumSharp.Core/Creation/np.full.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.full.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.full.html +numpy.full_like,numpy,np,Array creation,full_like,function,True,available,exact,declared,"(a, fill_value, dtype=None, order='K', subok=True, shape=None, *, device=None)",NumSharp.np.full_like,"NumSharp.NDArray full_like(NumSharp.NDArray a, object fill_value, System.Type dtype = null) | NumSharp.NDArray full_like(NumSharp.NDArray a, object fill_value, System.Type dtype, char order)",src/NumSharp.Core/Creation/np.full_like.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.full_like.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.full_like.html +numpy.gcd,numpy,np,Math,gcd,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.gcd.html +numpy.generic,numpy,np,Types,generic,class,False,missing,missing,missing,(),,,,,False,, +numpy.genfromtxt,numpy,np,Array creation,genfromtxt,function,True,missing,missing,missing,"(fname, dtype=, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars="" !#$%&'()*+,-./:;<=>?@[\\]^{|}~"", replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding=None, *, ndmin=0, l…",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.genfromtxt.html +numpy.geomspace,numpy,np,Array creation,geomspace,function,True,missing,missing,missing,"(start, stop, num=50, endpoint=True, dtype=None, axis=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.geomspace.html +numpy.get_include,numpy,np,Runtime & diagnostics,get_include,function,True,missing,missing,missing,(),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.get_include.html +numpy.get_printoptions,numpy,np,Text & formatting,get_printoptions,function,True,available,exact,declared,(),NumSharp.np.get_printoptions,"System.Collections.Generic.IReadOnlyDictionary get_printoptions()",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.get_printoptions.html +numpy.getbufsize,numpy,np,Floating-point handling,getbufsize,function,True,missing,missing,missing,(),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.getbufsize.html +numpy.geterr,numpy,np,Floating-point handling,geterr,function,True,missing,missing,missing,(),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.geterr.html +numpy.geterrcall,numpy,np,Floating-point handling,geterrcall,function,True,missing,missing,missing,(),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.geterrcall.html +numpy.gradient,numpy,np,Math,gradient,function,True,missing,missing,missing,"(f, *varargs, axis=None, edge_order=1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.gradient.html +numpy.greater,numpy,np,Logic & comparison,greater,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.greater,"NumSharp.Generic.NDArray greater(NumSharp.NDArray x1, object x2) | NumSharp.Generic.NDArray greater(object x1, NumSharp.NDArray x2) | NumSharp.NDArray greater(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.comparison.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.greater.html +numpy.greater_equal,numpy,np,Logic & comparison,greater_equal,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.greater_equal,"NumSharp.Generic.NDArray greater_equal(NumSharp.NDArray x1, object x2) | NumSharp.Generic.NDArray greater_equal(object x1, NumSharp.NDArray x2) | NumSharp.NDArray greater_equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.comparison.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.greater_equal.html +numpy.half,numpy,np,Types,half,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.half,readonly System.Type half,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.hamming,numpy,np,Window functions,hamming,function,True,missing,missing,missing,(M),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.hamming.html +numpy.hanning,numpy,np,Window functions,hanning,function,True,missing,missing,missing,(M),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.hanning.html +numpy.heaviside,numpy,np,Math,heaviside,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.heaviside.html +numpy.histogram,numpy,np,Statistics & histograms,histogram,function,True,missing,missing,missing,"(a, bins=10, range=None, density=None, weights=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.histogram.html +numpy.histogram2d,numpy,np,Statistics & histograms,histogram2d,function,True,missing,missing,missing,"(x, y, bins=10, range=None, density=None, weights=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.histogram2d.html +numpy.histogram_bin_edges,numpy,np,Statistics & histograms,histogram_bin_edges,function,True,missing,missing,missing,"(a, bins=10, range=None, weights=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.histogram_bin_edges.html +numpy.histogramdd,numpy,np,Statistics & histograms,histogramdd,function,True,missing,missing,missing,"(sample, bins=10, range=None, density=None, weights=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.histogramdd.html +numpy.hsplit,numpy,np,Shape manipulation,hsplit,function,True,available,exact,declared,"(ary, indices_or_sections)",NumSharp.np.hsplit,"NumSharp.NDArray[] hsplit(NumSharp.NDArray ary, int indices_or_sections) | NumSharp.NDArray[] hsplit(NumSharp.NDArray ary, int[] indices)",src/NumSharp.Core/Manipulation/np.hsplit.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.hsplit.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.hsplit.html +numpy.hstack,numpy,np,Shape manipulation,hstack,function,True,available,exact,declared,"(tup, *, dtype=None, casting='same_kind')",NumSharp.np.hstack,NumSharp.NDArray hstack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/np.hstack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.hstack.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.hstack.html +numpy.hypot,numpy,np,Math,hypot,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.hypot.html +numpy.i0,numpy,np,Math,i0,function,True,missing,missing,missing,(x),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.i0.html +numpy.identity,numpy,np,Array creation,identity,function,True,available,exact,declared,"(n, dtype=None, *, like=None)",NumSharp.np.identity,"NumSharp.NDArray identity(int n, System.Type dtype = null)",src/NumSharp.Core/Creation/np.eye.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.eye.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.identity.html +numpy.iinfo,numpy,np,Types,iinfo,class,False,available,exact,declared,(int_type),NumSharp.np.iinfo,NumSharp.iinfo iinfo() | NumSharp.iinfo iinfo(NumSharp.NDArray arr) | NumSharp.iinfo iinfo(NumSharp.NPTypeCode typeCode) | NumSharp.iinfo iinfo(System.Type type) | NumSharp.iinfo iinfo(string dtypeName),src/NumSharp.Core/APIs/np.iinfo.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.iinfo.cs,False,, +numpy.imag,numpy,np,Math,imag,function,True,missing,missing,missing,(val),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.imag.html +numpy.index_exp,numpy,np,Types & constants,index_exp,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.indices,numpy,np,Indexing & selection,indices,function,True,available,exact,declared,"(dimensions, dtype=, sparse=False)",NumSharp.np.indices,"NumSharp.NDArray indices(int[] dimensions, NumSharp.NPTypeCode dtype = NumSharp.NPTypeCode.Int64)",src/NumSharp.Core/Indexing/np.indices.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.indices.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.indices.html +numpy.inexact,numpy,np,Types,inexact,class,False,missing,missing,missing,(),,,,,False,, +numpy.inf,numpy,np,Types & constants,inf,constant,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.inf,double inf { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.info,numpy,np,Runtime & diagnostics,info,function,True,missing,missing,missing,"(object=None, maxwidth=76, output=None, toplevel='numpy')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.info.html +numpy.inner,numpy,np,Math,inner,function,True,missing,missing,missing,"(a, b, /)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.inner.html +numpy.insert,numpy,np,Shape manipulation,insert,function,True,available,exact,declared,"(arr, obj, values, axis=None)",NumSharp.np.insert,"NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.NDArray obj, NumSharp.NDArray values, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.NDArray obj, object value, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.Slice obj, NumSharp.NDArray values, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.Slice obj, object value, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, int obj, NumSharp.NDArray values, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, int obj, object value, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, int[] obj, NumSharp.NDArray values, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, int[] obj, object value, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, long obj, NumSharp.NDArray values, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, long obj, object value, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, long[] obj, NumSharp.NDArray values, int? axis = null) | NumSharp.NDArray insert(NumSharp.NDArray arr, long[] obj, object value, int? axis = null)",src/NumSharp.Core/Manipulation/np.insert.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.insert.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.insert.html +numpy.int16,numpy,np,Types,int16,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.int16,readonly System.Type int16,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.int32,numpy,np,Types,int32,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.int32,readonly System.Type int32,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.int64,numpy,np,Types,int64,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.int64,readonly System.Type int64,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.int8,numpy,np,Types,int8,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.int8,readonly System.Type int8,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.int_,numpy,np,Types,int_,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.int_,readonly System.Type int_,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.intc,numpy,np,Types,intc,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.intc,readonly System.Type intc,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.integer,numpy,np,Types,integer,class,False,missing,missing,missing,(),,,,,False,, +numpy.interp,numpy,np,Math,interp,function,True,missing,missing,missing,"(x, xp, fp, left=None, right=None, period=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.interp.html +numpy.intersect1d,numpy,np,Set operations,intersect1d,function,True,missing,missing,missing,"(ar1, ar2, assume_unique=False, return_indices=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.intersect1d.html +numpy.intp,numpy,np,Types,intp,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.intp,readonly System.Type intp,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.invert,numpy,np,Math,invert,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.invert,"NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NPTypeCode outType) | NumSharp.NDArray invert(NumSharp.NDArray x, System.Type outType)",src/NumSharp.Core/Math/np.invert.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.invert.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.invert.html +numpy.is_busday,numpy,np,Date & time,is_busday,function,True,missing,missing,missing,"(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.is_busday.html +numpy.isclose,numpy,np,Logic & comparison,isclose,function,True,available,exact,declared,"(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)",NumSharp.np.isclose,"NumSharp.Generic.NDArray isclose(NumSharp.NDArray a, NumSharp.NDArray b, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)",src/NumSharp.Core/Logic/np.is.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isclose.html +numpy.iscomplex,numpy,np,Logic & comparison,iscomplex,function,True,available,exact,declared,(x),NumSharp.np.iscomplex,NumSharp.NDArray iscomplex(NumSharp.NDArray a),src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.iscomplex.html +numpy.iscomplexobj,numpy,np,Logic & comparison,iscomplexobj,function,True,available,exact,declared,(x),NumSharp.np.iscomplexobj,bool iscomplexobj(NumSharp.NDArray a),src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.iscomplexobj.html +numpy.isdtype,numpy,np,Dtype & promotion,isdtype,function,True,available,exact,declared,"(dtype, kind)",NumSharp.np.isdtype,"bool isdtype(NumSharp.NDArray arr, string kind) | bool isdtype(NumSharp.NDArray arr, string[] kinds) | bool isdtype(NumSharp.NPTypeCode dtype, string kind) | bool isdtype(NumSharp.NPTypeCode dtype, string[] kinds) | bool isdtype(System.Type type, string kind) | bool isdtype(System.Type type, string[] kinds)",src/NumSharp.Core/Logic/np.type_checks.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isdtype.html +numpy.isfinite,numpy,np,Logic & comparison,isfinite,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.isfinite,"NumSharp.NDArray isfinite(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.is.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isfinite.html +numpy.isfortran,numpy,np,Logic & comparison,isfortran,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.isfortran.html +numpy.isin,numpy,np,Set operations,isin,function,True,missing,missing,missing,"(element, test_elements, assume_unique=False, invert=False, *, kind=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.isin.html +numpy.isinf,numpy,np,Logic & comparison,isinf,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.isinf,"NumSharp.NDArray isinf(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.is.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isinf.html +numpy.isnan,numpy,np,Logic & comparison,isnan,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.isnan,"NumSharp.NDArray isnan(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.is.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isnan.html +numpy.isnat,numpy,np,Date & time,isnat,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.isnat.html +numpy.isneginf,numpy,np,Logic & comparison,isneginf,function,True,missing,missing,missing,"(x, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.isneginf.html +numpy.isposinf,numpy,np,Logic & comparison,isposinf,function,True,missing,missing,missing,"(x, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.isposinf.html +numpy.isreal,numpy,np,Logic & comparison,isreal,function,True,available,exact,declared,(x),NumSharp.np.isreal,NumSharp.NDArray isreal(NumSharp.NDArray a),src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isreal.html +numpy.isrealobj,numpy,np,Logic & comparison,isrealobj,function,True,available,exact,declared,(x),NumSharp.np.isrealobj,bool isrealobj(NumSharp.NDArray a),src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isrealobj.html +numpy.isscalar,numpy,np,Logic & comparison,isscalar,function,True,available,exact,declared,(element),NumSharp.np.isscalar,bool isscalar(object obj),src/NumSharp.Core/Logic/np.is.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.isscalar.html +numpy.issubdtype,numpy,np,Dtype & promotion,issubdtype,function,True,available,exact,declared,"(arg1, arg2)",NumSharp.np.issubdtype,"bool issubdtype(NumSharp.NDArray arr, string arg2) | bool issubdtype(NumSharp.NPTypeCode arg1, NumSharp.NPTypeCode arg2) | bool issubdtype(NumSharp.NPTypeCode arg1, string arg2) | bool issubdtype(System.Type arg1, System.Type arg2) | bool issubdtype(System.Type arg1, string arg2)",src/NumSharp.Core/Logic/np.issubdtype.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.issubdtype.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.issubdtype.html +numpy.iterable,numpy,np,Array metadata & memory,iterable,function,True,missing,missing,missing,(y),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.iterable.html +numpy.ix_,numpy,np,Indexing & selection,ix_,function,True,missing,missing,missing,(*args),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ix_.html +numpy.kaiser,numpy,np,Window functions,kaiser,function,True,missing,missing,missing,"(M, beta)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.kaiser.html +numpy.kron,numpy,np,Math,kron,function,True,missing,missing,missing,"(a, b)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.kron.html +numpy.lcm,numpy,np,Math,lcm,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.lcm.html +numpy.ldexp,numpy,np,Math,ldexp,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ldexp.html +numpy.left_shift,numpy,np,Math,left_shift,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.left_shift,"NumSharp.NDArray left_shift(NumSharp.NDArray x1, NumSharp.NDArray x2) | NumSharp.NDArray left_shift(NumSharp.NDArray x1, object x2)",src/NumSharp.Core/Math/np.left_shift.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.left_shift.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.left_shift.html +numpy.less,numpy,np,Logic & comparison,less,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.less,"NumSharp.Generic.NDArray less(NumSharp.NDArray x1, object x2) | NumSharp.Generic.NDArray less(object x1, NumSharp.NDArray x2) | NumSharp.NDArray less(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.comparison.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.less.html +numpy.less_equal,numpy,np,Logic & comparison,less_equal,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.less_equal,"NumSharp.Generic.NDArray less_equal(NumSharp.NDArray x1, object x2) | NumSharp.Generic.NDArray less_equal(object x1, NumSharp.NDArray x2) | NumSharp.NDArray less_equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.comparison.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.less_equal.html +numpy.lexsort,numpy,np,Sorting & searching,lexsort,function,True,missing,missing,missing,"(keys, axis=-1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.lexsort.html +numpy.lib,numpy,np,Namespaces,lib,module,False,missing,missing,missing,``numpy.lib`` is mostly a space for implementing functions that don't,,,,,False,, +numpy.linalg,numpy,np,Namespaces,linalg,module,False,missing,missing,missing,``numpy.linalg``,,,,,False,, +numpy.linspace,numpy,np,Array creation,linspace,function,True,available,exact,declared,"(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, *, device=None)",NumSharp.np.linspace,"NumSharp.NDArray linspace(double start, double stop, int num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double) | NumSharp.NDArray linspace(double start, double stop, int num, bool endpoint, System.Type dtype) | NumSharp.NDArray linspace(double start, double stop, long num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double) | NumSharp.NDArray linspace(double start, double stop, long num, bool endpoint, System.Type dtype) | NumSharp.NDArray linspace(float start, float stop, int num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double) | NumSharp.NDArray linspace(float start, float stop, int num, bool endpoint, System.Type dtype) | NumSharp.NDArray linspace(float start, float stop, long num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double) | NumSharp.NDArray linspace(float start, float stop, long num, bool endpoint, System.Type dtype)",src/NumSharp.Core/Creation/np.linspace.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.linspace.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.linspace.html +numpy.little_endian,numpy,np,Types & constants,little_endian,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.load,numpy,np,Input & output,load,function,True,available,exact,declared,"(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII', *, max_header_size=10000)",NumSharp.np.load,"object load(System.IO.Stream file, string mmap_mode = null, bool allow_pickle = false, bool fix_imports = true, string encoding = ""ASCII"", long max_header_size = 10000) | object load(byte[] bytes, string mmap_mode = null, bool allow_pickle = false, bool fix_imports = true, string encoding = ""ASCII"", long max_header_size = 10000) | object load(string file, string mmap_mode = null, bool allow_pickle = false, bool fix_imports = true, string encoding = ""ASCII"", long max_header_size = 10000)",src/NumSharp.Core/APIs/np.load.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.load.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.load.html +numpy.loadtxt,numpy,np,Array creation,loadtxt,function,True,missing,missing,missing,"(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=None, max_rows=None, *, quotechar=None, like=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.loadtxt.html +numpy.log,numpy,np,Math,log,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.log,"NumSharp.NDArray log(NumSharp.NDArray x) | NumSharp.NDArray log(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray log(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray log(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.log.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.log.html +numpy.log10,numpy,np,Math,log10,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.log10,"NumSharp.NDArray log10(NumSharp.NDArray x) | NumSharp.NDArray log10(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray log10(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray log10(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.log.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.log10.html +numpy.log1p,numpy,np,Math,log1p,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.log1p,"NumSharp.NDArray log1p(NumSharp.NDArray x) | NumSharp.NDArray log1p(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray log1p(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray log1p(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.log.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.log1p.html +numpy.log2,numpy,np,Math,log2,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.log2,"NumSharp.NDArray log2(NumSharp.NDArray x) | NumSharp.NDArray log2(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray log2(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray log2(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.log.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.log2.html +numpy.logaddexp,numpy,np,Math,logaddexp,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.logaddexp.html +numpy.logaddexp2,numpy,np,Math,logaddexp2,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.logaddexp2.html +numpy.logical_and,numpy,np,Logic & comparison,logical_and,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.logical_and,"NumSharp.Generic.NDArray logical_and(NumSharp.NDArray x1, NumSharp.NDArray x2)",src/NumSharp.Core/Logic/np.logical.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.logical_and.html +numpy.logical_not,numpy,np,Logic & comparison,logical_not,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.logical_not,NumSharp.Generic.NDArray logical_not(NumSharp.NDArray x),src/NumSharp.Core/Logic/np.logical.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.logical_not.html +numpy.logical_or,numpy,np,Logic & comparison,logical_or,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.logical_or,"NumSharp.Generic.NDArray logical_or(NumSharp.NDArray x1, NumSharp.NDArray x2)",src/NumSharp.Core/Logic/np.logical.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.logical_or.html +numpy.logical_xor,numpy,np,Logic & comparison,logical_xor,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.logical_xor,"NumSharp.Generic.NDArray logical_xor(NumSharp.NDArray x1, NumSharp.NDArray x2)",src/NumSharp.Core/Logic/np.logical.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.logical_xor.html +numpy.logspace,numpy,np,Array creation,logspace,function,True,missing,missing,missing,"(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.logspace.html +numpy.long,numpy,np,Types,long,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.long,readonly System.Type long,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.longdouble,numpy,np,Types,longdouble,class,False,missing,missing,missing,"(value=0, /)",,,,,False,, +numpy.longlong,numpy,np,Types,longlong,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.longlong,readonly System.Type longlong,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ma,numpy,np,Namespaces,ma,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.mask_indices,numpy,np,Indexing & selection,mask_indices,function,True,missing,missing,missing,"(n, mask_func, k=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.mask_indices.html +numpy.matmul,numpy,np,Math,matmul,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.matmul,"NumSharp.NDArray matmul(NumSharp.NDArray x1, NumSharp.NDArray x2)",src/NumSharp.Core/LinearAlgebra/np.matmul.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.matmul.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.matmul.html +numpy.matrix,numpy,np,Types,matrix,class,False,missing,missing,missing,"(data, dtype=None, copy=True)",,,,,False,, +numpy.matrix_transpose,numpy,np,Shape manipulation,matrix_transpose,function,True,available,exact,declared,"(x, /)",NumSharp.np.matrix_transpose,NumSharp.NDArray matrix_transpose(NumSharp.NDArray x),src/NumSharp.Core/Manipulation/np.matrix_transpose.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.matrix_transpose.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.matrix_transpose.html +numpy.matvec,numpy,np,Linear algebra,matvec,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.matvec.html +numpy.max,numpy,np,Reductions,max,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, initial=, where=)",NumSharp.np.max,"NumSharp.NDArray max(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null)",src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.max.html +numpy.maximum,numpy,np,Logic & comparison,maximum,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.maximum,"NumSharp.NDArray maximum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out) | NumSharp.NDArray maximum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray maximum(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)",src/NumSharp.Core/Math/np.maximum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.maximum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.maximum.html +numpy.may_share_memory,numpy,np,Array metadata & memory,may_share_memory,function,True,missing,missing,missing,"(a, b, /, max_work=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.may_share_memory.html +numpy.mean,numpy,np,Reductions,mean,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, keepdims=, *, where=)",NumSharp.np.mean,"NumSharp.NDArray mean(NumSharp.NDArray a) | NumSharp.NDArray mean(NumSharp.NDArray a, bool keepdims) | NumSharp.NDArray mean(NumSharp.NDArray a, int axis) | NumSharp.NDArray mean(NumSharp.NDArray a, int axis, NumSharp.NPTypeCode type, bool keepdims = false) | NumSharp.NDArray mean(NumSharp.NDArray a, int axis, System.Type dtype, bool keepdims = false) | NumSharp.NDArray mean(NumSharp.NDArray a, int axis, bool keepdims)",src/NumSharp.Core/Statistics/np.mean.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.mean.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.mean.html +numpy.median,numpy,np,Reductions,median,function,True,available,exact,declared,"(a, axis=None, out=None, overwrite_input=False, keepdims=False)",NumSharp.np.median,"NumSharp.NDArray median(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false) | NumSharp.NDArray median(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false)",src/NumSharp.Core/Statistics/np.median.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.median.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.median.html +numpy.memmap,numpy,np,Types,memmap,class,False,missing,missing,missing,"(filename, dtype=, mode='r+', offset=0, shape=None, order='C')",,,,,False,, +numpy.meshgrid,numpy,np,Array creation,meshgrid,function,True,available,exact,declared,"(*xi, copy=True, sparse=False, indexing='xy')",NumSharp.np.meshgrid,"System.ValueTuple meshgrid(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.Kwargs kwargs = null)",src/NumSharp.Core/Creation/np.meshgrid.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.meshgrid.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.meshgrid.html +numpy.mgrid,numpy,np,Types & constants,mgrid,constant,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.mgrid,"System.ValueTuple mgrid(NumSharp.NDArray lhs, NumSharp.NDArray rhs)",src/NumSharp.Core/Creation/np.mgrid.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.mgrid.cs,False,, +numpy.min,numpy,np,Reductions,min,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, initial=, where=)",NumSharp.np.min,"NumSharp.NDArray min(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null)",src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.min.html +numpy.min_scalar_type,numpy,np,Dtype & promotion,min_scalar_type,function,True,available,exact,declared,"(a, /)",NumSharp.np.min_scalar_type,NumSharp.NPTypeCode min_scalar_type(object value),src/NumSharp.Core/Logic/np.min_scalar_type.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.min_scalar_type.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.min_scalar_type.html +numpy.minimum,numpy,np,Logic & comparison,minimum,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.minimum,"NumSharp.NDArray minimum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out) | NumSharp.NDArray minimum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray minimum(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)",src/NumSharp.Core/Math/np.minimum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.minimum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.minimum.html +numpy.mintypecode,numpy,np,Dtype & promotion,mintypecode,function,True,available,exact,declared,"(typechars, typeset='GDFgdf', default='d')",NumSharp.np.mintypecode,"char mintypecode(char[] typechars, string typeset = ""GDFgdf"", char default = 'd') | char mintypecode(string typechars, string typeset = ""GDFgdf"", char default = 'd')",src/NumSharp.Core/Creation/np.dtype.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.dtype.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.mintypecode.html +numpy.mod,numpy,np,Math,mod,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.mod,"NumSharp.NDArray mod(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray mod(NumSharp.NDArray x1, float x2)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.mod.html +numpy.modf,numpy,np,Math,modf,ufunc,True,available,exact,declared,"(x, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.modf,"System.ValueTuple modf(NumSharp.NDArray x, NumSharp.NPTypeCode? dtype = null) | System.ValueTuple modf(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.modf.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.modf.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.modf.html +numpy.moveaxis,numpy,np,Shape manipulation,moveaxis,function,True,available,exact,declared,"(a, source, destination)",NumSharp.np.moveaxis,"NumSharp.NDArray moveaxis(NumSharp.NDArray a, int source, int destination) | NumSharp.NDArray moveaxis(NumSharp.NDArray a, int source, int[] destination) | NumSharp.NDArray moveaxis(NumSharp.NDArray a, int[] source, int destination) | NumSharp.NDArray moveaxis(NumSharp.NDArray a, int[] source, int[] destination)",src/NumSharp.Core/Manipulation/np.moveaxis.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.moveaxis.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.moveaxis.html +numpy.multiply,numpy,np,Math,multiply,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.multiply,"NumSharp.NDArray multiply(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.multiply.html +numpy.nan,numpy,np,Types & constants,nan,constant,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.nan,double nan { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.nan_to_num,numpy,np,Floating-point handling,nan_to_num,function,True,missing,missing,missing,"(x, copy=True, nan=0.0, posinf=None, neginf=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.nan_to_num.html +numpy.nanargmax,numpy,np,Reductions,nanargmax,function,True,missing,missing,missing,"(a, axis=None, out=None, *, keepdims=)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanargmax.html +numpy.nanargmin,numpy,np,Reductions,nanargmin,function,True,missing,missing,missing,"(a, axis=None, out=None, *, keepdims=)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanargmin.html +numpy.nancumprod,numpy,np,Reductions,nancumprod,function,True,missing,missing,missing,"(a, axis=None, dtype=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.nancumprod.html +numpy.nancumsum,numpy,np,Reductions,nancumsum,function,True,missing,missing,missing,"(a, axis=None, dtype=None, out=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.nancumsum.html +numpy.nanmax,numpy,np,Reductions,nanmax,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, initial=, where=)",NumSharp.np.nanmax,"NumSharp.NDArray nanmax(NumSharp.NDArray a, int? axis = null, bool keepdims = false)",src/NumSharp.Core/Sorting_Searching_Counting/np.nanmax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.nanmax.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanmax.html +numpy.nanmean,numpy,np,Reductions,nanmean,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, keepdims=, *, where=)",NumSharp.np.nanmean,"NumSharp.NDArray nanmean(NumSharp.NDArray a, int? axis = null, bool keepdims = false)",src/NumSharp.Core/Statistics/np.nanmean.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanmean.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanmean.html +numpy.nanmedian,numpy,np,Reductions,nanmedian,function,True,available,exact,declared,"(a, axis=None, out=None, overwrite_input=False, keepdims=)",NumSharp.np.nanmedian,"NumSharp.NDArray nanmedian(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false) | NumSharp.NDArray nanmedian(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false)",src/NumSharp.Core/Statistics/np.nanmedian.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanmedian.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanmedian.html +numpy.nanmin,numpy,np,Reductions,nanmin,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=, initial=, where=)",NumSharp.np.nanmin,"NumSharp.NDArray nanmin(NumSharp.NDArray a, int? axis = null, bool keepdims = false)",src/NumSharp.Core/Sorting_Searching_Counting/np.nanmin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.nanmin.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanmin.html +numpy.nanpercentile,numpy,np,Reductions,nanpercentile,function,True,available,exact,declared,"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=, *, weights=None)",NumSharp.np.nanpercentile,"NumSharp.NDArray nanpercentile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false)",src/NumSharp.Core/Statistics/np.nanpercentile.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanpercentile.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanpercentile.html +numpy.nanprod,numpy,np,Reductions,nanprod,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)",NumSharp.np.nanprod,"NumSharp.NDArray nanprod(NumSharp.NDArray a, int? axis = null, bool keepdims = false)",src/NumSharp.Core/Math/np.nanprod.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.nanprod.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanprod.html +numpy.nanquantile,numpy,np,Reductions,nanquantile,function,True,available,exact,declared,"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=, *, weights=None)",NumSharp.np.nanquantile,"NumSharp.NDArray nanquantile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanquantile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanquantile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanquantile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray nanquantile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false)",src/NumSharp.Core/Statistics/np.nanquantile.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanquantile.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanquantile.html +numpy.nanstd,numpy,np,Reductions,nanstd,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)",NumSharp.np.nanstd,"NumSharp.NDArray nanstd(NumSharp.NDArray a, int? axis = null, bool keepdims = false, int ddof = 0)",src/NumSharp.Core/Statistics/np.nanstd.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanstd.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanstd.html +numpy.nansum,numpy,np,Reductions,nansum,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)",NumSharp.np.nansum,"NumSharp.NDArray nansum(NumSharp.NDArray a, int? axis = null, bool keepdims = false)",src/NumSharp.Core/Math/np.nansum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.nansum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nansum.html +numpy.nanvar,numpy,np,Reductions,nanvar,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)",NumSharp.np.nanvar,"NumSharp.NDArray nanvar(NumSharp.NDArray a, int? axis = null, bool keepdims = false, int ddof = 0)",src/NumSharp.Core/Statistics/np.nanvar.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanvar.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nanvar.html +numpy.ndarray,numpy,np,Types,ndarray,class,False,available,exact,declared,"(shape, dtype=None, buffer=None, offset=0, strides=None, order=None)",NumSharp.NDArray,NumSharp.NDArray,src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,, +numpy.ndenumerate,numpy,np,Types,ndenumerate,class,False,missing,missing,missing,(arr),,,,,False,, +numpy.ndim,numpy,np,Shape manipulation,ndim,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.ndim.html +numpy.ndindex,numpy,np,Types,ndindex,class,False,missing,missing,missing,(*shape),,,,,False,, +numpy.nditer,numpy,np,Types,nditer,class,False,missing,missing,missing,"(op, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', op_axes=None, itershape=None, buffersize=0)",,,,,False,, +numpy.negative,numpy,np,Math,negative,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.negative,"NumSharp.NDArray negative(NumSharp.NDArray nd, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.negative.html +numpy.nested_iters,numpy,np,Array metadata & memory,nested_iters,function,True,missing,missing,missing,"(op, axes, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', buffersize=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.nested_iters.html +numpy.newaxis,numpy,np,Types & constants,newaxis,constant,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.newaxis,readonly NumSharp.Slice newaxis,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.nextafter,numpy,np,Math,nextafter,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.nextafter.html +numpy.nonzero,numpy,np,Sorting & searching,nonzero,function,True,available,exact,declared,(a),NumSharp.np.nonzero,NumSharp.Generic.NDArray[] nonzero(NumSharp.NDArray a),src/NumSharp.Core/Indexing/np.nonzero.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.nonzero.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.nonzero.html +numpy.not_equal,numpy,np,Logic & comparison,not_equal,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.not_equal,"NumSharp.Generic.NDArray not_equal(NumSharp.NDArray x1, object x2) | NumSharp.Generic.NDArray not_equal(object x1, NumSharp.NDArray x2) | NumSharp.NDArray not_equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Logic/np.comparison.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.not_equal.html +numpy.number,numpy,np,Types,number,class,False,missing,missing,missing,(),,,,,False,, +numpy.object_,numpy,np,Types,object_,class,False,missing,missing,missing,"(value=None, /)",,,,,False,, +numpy.ogrid,numpy,np,Types & constants,ogrid,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.ones,numpy,np,Array creation,ones,function,True,available,exact,declared,"(shape, dtype=None, order='C', *, device=None, like=None)",NumSharp.np.ones,"NumSharp.NDArray ones(NumSharp.Shape shape) | NumSharp.NDArray ones(NumSharp.Shape shape, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray ones(NumSharp.Shape shape, System.Type dtype) | NumSharp.NDArray ones(int shape) | NumSharp.NDArray ones(int[] shape) | NumSharp.NDArray ones(int[] shape) | NumSharp.NDArray ones(int[] shape, System.Type dtype) | NumSharp.NDArray ones(long[] shape)",src/NumSharp.Core/Creation/np.ones.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.ones.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ones.html +numpy.ones_like,numpy,np,Array creation,ones_like,function,True,available,exact,declared,"(a, dtype=None, order='K', subok=True, shape=None, *, device=None)",NumSharp.np.ones_like,"NumSharp.NDArray ones_like(NumSharp.NDArray a, System.Type dtype = null) | NumSharp.NDArray ones_like(NumSharp.NDArray a, System.Type dtype, char order)",src/NumSharp.Core/Creation/np.ones_like.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.ones_like.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ones_like.html +numpy.outer,numpy,np,Math,outer,function,True,available,exact,declared,"(a, b, out=None)",NumSharp.np.outer,"NumSharp.NDArray outer(NumSharp.NDArray a, NumSharp.NDArray b)",src/NumSharp.Core/LinearAlgebra/np.outer.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.outer.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.outer.html +numpy.packbits,numpy,np,Math,packbits,function,True,missing,missing,missing,"(a, /, axis=None, bitorder='big')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.packbits.html +numpy.pad,numpy,np,Shape manipulation,pad,function,True,available,exact,declared,"(array, pad_width, mode='constant', **kwargs)",NumSharp.np.pad,"NumSharp.NDArray pad(NumSharp.NDArray array, System.Collections.Generic.IDictionary pad_width, NumSharp.np+PadFunc mode, object kwargs = null) | NumSharp.NDArray pad(NumSharp.NDArray array, System.Collections.Generic.IDictionary pad_width, string mode = ""constant"", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = ""even"") | NumSharp.NDArray pad(NumSharp.NDArray array, System.ValueTuple pad_width, NumSharp.np+PadFunc mode, object kwargs = null) | NumSharp.NDArray pad(NumSharp.NDArray array, System.ValueTuple pad_width, string mode = ""constant"", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = ""even"") | NumSharp.NDArray pad(NumSharp.NDArray array, int pad_width, NumSharp.np+PadFunc mode, object kwargs = null) | NumSharp.NDArray pad(NumSharp.NDArray array, int pad_width, string mode = ""constant"", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = ""even"") | NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, NumSharp.np+PadFunc mode, object kwargs = null) | NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, NumSharp.np+PadFunc mode, object kwargs = null) | NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, string mode = ""constant"", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = ""even"") | NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, string mode = ""constant"", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = ""even"")",src/NumSharp.Core/Manipulation/np.pad.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.pad.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.pad.html +numpy.partition,numpy,np,Sorting & searching,partition,function,True,missing,missing,missing,"(a, kth, axis=-1, kind='introselect', order=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.partition.html +numpy.percentile,numpy,np,Reductions,percentile,function,True,available,exact,declared,"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None)",NumSharp.np.percentile,"NumSharp.NDArray percentile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray percentile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray percentile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray percentile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray percentile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false)",src/NumSharp.Core/Statistics/np.percentile.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.percentile.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.percentile.html +numpy.permute_dims,numpy,np,Shape manipulation,permute_dims,function,True,available,exact,declared,"(a, axes=None)",NumSharp.np.permute_dims,"NumSharp.NDArray permute_dims(NumSharp.NDArray a, int[] axes = null)",src/NumSharp.Core/Manipulation/np.permute_dims.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.permute_dims.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.permute_dims.html +numpy.pi,numpy,np,Types & constants,pi,constant,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.pi,double pi { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.piecewise,numpy,np,Math,piecewise,function,True,missing,missing,missing,"(x, condlist, funclist, *args, **kw)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.piecewise.html +numpy.place,numpy,np,Indexing & selection,place,function,True,available,exact,declared,"(arr, mask, vals)",NumSharp.np.place,"void place(NumSharp.NDArray arr, NumSharp.NDArray mask, NumSharp.NDArray vals)",src/NumSharp.Core/Indexing/np.place.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.place.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.place.html +numpy.poly,numpy,np,Polynomials,poly,function,True,missing,missing,missing,(seq_of_zeros),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.poly.html +numpy.poly1d,numpy,np,Types,poly1d,class,False,missing,missing,missing,"(c_or_r, r=False, variable=None)",,,,,False,, +numpy.polyadd,numpy,np,Polynomials,polyadd,function,True,missing,missing,missing,"(a1, a2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polyadd.html +numpy.polyder,numpy,np,Polynomials,polyder,function,True,missing,missing,missing,"(p, m=1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polyder.html +numpy.polydiv,numpy,np,Polynomials,polydiv,function,True,missing,missing,missing,"(u, v)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polydiv.html +numpy.polyfit,numpy,np,Polynomials,polyfit,function,True,missing,missing,missing,"(x, y, deg, rcond=None, full=False, w=None, cov=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polyfit.html +numpy.polyint,numpy,np,Polynomials,polyint,function,True,missing,missing,missing,"(p, m=1, k=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polyint.html +numpy.polymul,numpy,np,Polynomials,polymul,function,True,missing,missing,missing,"(a1, a2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polymul.html +numpy.polynomial,numpy,np,Namespaces,polynomial,module,False,missing,missing,missing,A sub-package for efficiently dealing with polynomials.,,,,,False,, +numpy.polysub,numpy,np,Polynomials,polysub,function,True,missing,missing,missing,"(a1, a2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polysub.html +numpy.polyval,numpy,np,Polynomials,polyval,function,True,missing,missing,missing,"(p, x)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.polyval.html +numpy.positive,numpy,np,Math,positive,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.positive,"NumSharp.NDArray positive(NumSharp.NDArray nd, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.positive.html +numpy.pow,numpy,np,Math,pow,ufunc,True,available,alias,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.power,"NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2) | NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype) | NumSharp.NDArray power(NumSharp.NDArray x1, object x2) | NumSharp.NDArray power(NumSharp.NDArray x1, object x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray power(NumSharp.NDArray x1, object x2, System.Type dtype) | NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2) | NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, System.Type dtype)",src/NumSharp.Core/Math/np.power.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.power.cs,False,NumSharp exposes the ufunc name power.,https://numpy.org/doc/stable/reference/generated/numpy.pow.html +numpy.power,numpy,np,Math,power,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.power,"NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2) | NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype) | NumSharp.NDArray power(NumSharp.NDArray x1, object x2) | NumSharp.NDArray power(NumSharp.NDArray x1, object x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray power(NumSharp.NDArray x1, object x2, System.Type dtype) | NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2) | NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, System.Type dtype)",src/NumSharp.Core/Math/np.power.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.power.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.power.html +numpy.printoptions,numpy,np,Text & formatting,printoptions,function,True,available,exact,declared,"(*args, **kwargs)",NumSharp.np.printoptions,"System.IDisposable printoptions(int? precision = null, int? threshold = null, int? edgeitems = null, int? linewidth = null, bool? suppress = null, string nanstr = null, string infstr = null, char? sign = null, string floatmode = null)",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.printoptions.html +numpy.prod,numpy,np,Reductions,prod,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)",NumSharp.np.prod,"NumSharp.NDArray prod(NumSharp.NDArray a, int? axis = null, System.Type dtype = null, bool keepdims = false)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.prod.html +numpy.promote_types,numpy,np,Dtype & promotion,promote_types,function,True,available,exact,declared,"(type1, type2, /)",NumSharp.np.promote_types,"NumSharp.NPTypeCode promote_types() | NumSharp.NPTypeCode promote_types(NumSharp.NPTypeCode type1, NumSharp.NPTypeCode type2) | NumSharp.NPTypeCode promote_types(System.Type type1, System.Type type2)",src/NumSharp.Core/Logic/np.promote_types.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.promote_types.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.promote_types.html +numpy.ptp,numpy,np,Reductions,ptp,function,True,available,exact,declared,"(a, axis=None, out=None, keepdims=)",NumSharp.np.ptp,"NumSharp.NDArray ptp(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false) | NumSharp.NDArray ptp(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out = null, bool keepdims = false)",src/NumSharp.Core/Statistics/np.ptp.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.ptp.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ptp.html +numpy.put,numpy,np,Indexing & selection,put,function,True,available,exact,declared,"(a, ind, v, mode='raise')",NumSharp.np.put,"void put(NumSharp.NDArray a, NumSharp.NDArray indices, NumSharp.NDArray values, string mode = ""raise"") | void put(NumSharp.NDArray a, long index, object value, string mode = ""raise"")",src/NumSharp.Core/Indexing/np.put.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.put.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.put.html +numpy.put_along_axis,numpy,np,Indexing & selection,put_along_axis,function,True,missing,missing,missing,"(arr, indices, values, axis)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.put_along_axis.html +numpy.putmask,numpy,np,Indexing & selection,putmask,function,True,missing,missing,missing,"(a, /, mask, values)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.putmask.html +numpy.quantile,numpy,np,Reductions,quantile,function,True,available,exact,declared,"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None)",NumSharp.np.quantile,"NumSharp.NDArray quantile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray quantile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray quantile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray quantile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false) | NumSharp.NDArray quantile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = ""linear"", bool keepdims = false)",src/NumSharp.Core/Statistics/np.quantile.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.quantile.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.quantile.html +numpy.r_,numpy,np,Types & constants,r_,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.rad2deg,numpy,np,Math,rad2deg,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.rad2deg,"NumSharp.NDArray rad2deg(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray rad2deg(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray rad2deg(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.rad2deg.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.rad2deg.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.rad2deg.html +numpy.radians,numpy,np,Math,radians,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.radians,"NumSharp.NDArray radians(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray radians(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray radians(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.deg2rad.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.deg2rad.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.radians.html +numpy.random,numpy,np,Namespaces,random,module,False,available,exact,declared,Signature unavailable from runtime introspection,NumSharp.np.random,NumSharp.NumPyRandom random { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ravel,numpy,np,Shape manipulation,ravel,function,True,available,exact,declared,"(a, order='C')",NumSharp.np.ravel,"NumSharp.NDArray ravel(NumSharp.NDArray a) | NumSharp.NDArray ravel(NumSharp.NDArray a, char order)",src/NumSharp.Core/Manipulation/np.ravel.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.ravel.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ravel.html +numpy.ravel_multi_index,numpy,np,Indexing & selection,ravel_multi_index,function,True,available,exact,declared,"(multi_index, dims, mode='raise', order='C')",NumSharp.np.ravel_multi_index,"NumSharp.Generic.NDArray ravel_multi_index(NumSharp.NDArray[] multi_index, int[] dims, string mode = ""raise"", char order = 'C') | NumSharp.Generic.NDArray ravel_multi_index(NumSharp.NDArray[] multi_index, int[] dims, string[] modes, char order = 'C') | long ravel_multi_index(long[] coords, int[] dims, string mode = ""raise"", char order = 'C')",src/NumSharp.Core/Indexing/np.ravel_multi_index.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.ravel_multi_index.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.ravel_multi_index.html +numpy.real,numpy,np,Math,real,function,True,missing,missing,missing,(val),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.real.html +numpy.real_if_close,numpy,np,Math,real_if_close,function,True,missing,missing,missing,"(a, tol=100)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.real_if_close.html +numpy.rec,numpy,np,Namespaces,rec,module,False,missing,missing,missing,This module contains a set of functions for record arrays.,,,,,False,, +numpy.recarray,numpy,np,Types,recarray,class,False,missing,missing,missing,"(shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C')",,,,,False,, +numpy.reciprocal,numpy,np,Math,reciprocal,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.reciprocal,"NumSharp.NDArray reciprocal(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray reciprocal(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray reciprocal(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.reciprocal.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.reciprocal.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.reciprocal.html +numpy.record,numpy,np,Types,record,class,False,missing,missing,missing,"(length_or_data, /, dtype=None)",,,,,False,, +numpy.remainder,numpy,np,Math,remainder,ufunc,True,available,alias,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.mod,"NumSharp.NDArray mod(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray mod(NumSharp.NDArray x1, float x2)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,NumSharp exposes the equivalent ufunc name mod.,https://numpy.org/doc/stable/reference/generated/numpy.remainder.html +numpy.repeat,numpy,np,Shape manipulation,repeat,function,True,available,exact,declared,"(a, repeats, axis=None)",NumSharp.np.repeat,"NumSharp.NDArray repeat(NumSharp.NDArray a, NumSharp.NDArray repeats, int? axis = null) | NumSharp.NDArray repeat(NumSharp.NDArray a, int repeats, int? axis = null) | NumSharp.NDArray repeat(NumSharp.NDArray a, long repeats, int? axis = null) | NumSharp.NDArray repeat(T a, int repeats) | NumSharp.NDArray repeat(T a, long repeats)",src/NumSharp.Core/Manipulation/np.repeat.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.repeat.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.repeat.html +numpy.require,numpy,np,Array creation,require,function,True,available,exact,declared,"(a, dtype=None, requirements=None, *, like=None)",NumSharp.np.require,"NumSharp.NDArray require(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, string requirements) | NumSharp.NDArray require(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, string[] requirements = null) | NumSharp.NDArray require(NumSharp.NDArray a, System.Type dtype = null, string[] requirements = null, NumSharp.NDArray like = null) | NumSharp.NDArray require(NumSharp.NDArray a, System.Type dtype, string requirements) | NumSharp.NDArray require(NumSharp.NDArray a, string dtype, string requirements) | NumSharp.NDArray require(NumSharp.NDArray a, string dtype, string[] requirements = null)",src/NumSharp.Core/Creation/np.require.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.require.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.require.html +numpy.reshape,numpy,np,Shape manipulation,reshape,function,True,available,exact,declared,"(a, /, shape, order='C', *, copy=None)",NumSharp.np.reshape,"NumSharp.NDArray reshape(NumSharp.NDArray nd, NumSharp.Shape shape) | NumSharp.NDArray reshape(NumSharp.NDArray nd, int[] shape) | NumSharp.NDArray reshape(NumSharp.NDArray nd, long[] shape) | NumSharp.NDArray reshape(NumSharp.NDArray nd, ref NumSharp.Shape shape)",src/NumSharp.Core/Manipulation/np.reshape.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.reshape.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.reshape.html +numpy.resize,numpy,np,Shape manipulation,resize,function,True,available,exact,declared,"(a, new_shape)",NumSharp.np.resize,"NumSharp.NDArray resize(NumSharp.NDArray a, NumSharp.Shape new_shape)",src/NumSharp.Core/Manipulation/np.resize.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.resize.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.resize.html +numpy.result_type,numpy,np,Dtype & promotion,result_type,function,True,available,exact,declared,(*arrays_and_dtypes),NumSharp.np.result_type,"NumSharp.NPTypeCode result_type(NumSharp.NDArray arr1, NumSharp.NDArray arr2) | NumSharp.NPTypeCode result_type(NumSharp.NPTypeCode type1, NumSharp.NPTypeCode type2) | NumSharp.NPTypeCode result_type(System.Type type1, System.Type type2) | NumSharp.NPTypeCode result_type(params NumSharp.NDArray[] arrays) | NumSharp.NPTypeCode result_type(params NumSharp.NPTypeCode[] types) | NumSharp.NPTypeCode result_type(params object[] arrays_and_dtypes)",src/NumSharp.Core/Logic/np.result_type.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.result_type.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.result_type.html +numpy.right_shift,numpy,np,Math,right_shift,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.right_shift,"NumSharp.NDArray right_shift(NumSharp.NDArray x1, NumSharp.NDArray x2) | NumSharp.NDArray right_shift(NumSharp.NDArray x1, object x2)",src/NumSharp.Core/Math/np.right_shift.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.right_shift.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.right_shift.html +numpy.rint,numpy,np,Math,rint,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.rint,"NumSharp.NDArray rint(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray rint(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray rint(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.rint.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.rint.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.rint.html +numpy.roll,numpy,np,Shape manipulation,roll,function,True,available,exact,declared,"(a, shift, axis=None)",NumSharp.np.roll,"NumSharp.NDArray roll(NumSharp.NDArray a, int shift, int? axis = null) | NumSharp.NDArray roll(NumSharp.NDArray a, long shift, int? axis = null)",src/NumSharp.Core/Manipulation/np.roll.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.roll.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.roll.html +numpy.rollaxis,numpy,np,Shape manipulation,rollaxis,function,True,available,exact,declared,"(a, axis, start=0)",NumSharp.np.rollaxis,"NumSharp.NDArray rollaxis(NumSharp.NDArray a, int axis, int start = 0)",src/NumSharp.Core/Manipulation/np.rollaxis.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.rollaxis.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.rollaxis.html +numpy.roots,numpy,np,Polynomials,roots,function,True,missing,missing,missing,(p),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.roots.html +numpy.rot90,numpy,np,Shape manipulation,rot90,function,True,available,exact,declared,"(m, k=1, axes=(0, 1))",NumSharp.np.rot90,"NumSharp.NDArray rot90(NumSharp.NDArray m, int k = 1, int[] axes = null)",src/NumSharp.Core/Manipulation/np.rot90.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.rot90.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.rot90.html +numpy.round,numpy,np,Math,round,function,True,available,alias,declared,"(a, decimals=0, out=None)",NumSharp.np.round_,"NumSharp.NDArray round_(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray round_(NumSharp.NDArray x, System.Type dtype) | NumSharp.NDArray round_(NumSharp.NDArray x, int decimals = 0, NumSharp.NDArray out = null) | NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, NumSharp.NPTypeCode dtype) | NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, System.Type dtype)",src/NumSharp.Core/Math/np.round.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.round.cs,False,C# uses round_ to avoid a naming collision while preserving NumPy round semantics.,https://numpy.org/doc/stable/reference/generated/numpy.round.html +numpy.row_stack,numpy,np,Shape manipulation,row_stack,function,True,available,alias,declared,"(tup, *, dtype=None, casting='same_kind')",NumSharp.np.vstack,NumSharp.NDArray vstack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/np.vstack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.vstack.cs,False,NumPy documents row_stack as an alias of vstack.,https://numpy.org/doc/stable/reference/generated/numpy.vstack.html +numpy.s_,numpy,np,Types & constants,s_,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.save,numpy,np,Input & output,save,function,True,available,exact,declared,"(file, arr, allow_pickle=True)",NumSharp.np.save,"byte[] save(NumSharp.NDArray arr, bool allow_pickle = true) | void save(System.IO.Stream file, NumSharp.NDArray arr, bool allow_pickle = true) | void save(string file, NumSharp.NDArray arr, bool allow_pickle = true) | void save(string file, System.Array arr, bool allow_pickle = true)",src/NumSharp.Core/APIs/np.save.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.save.html +numpy.savetxt,numpy,np,Input & output,savetxt,function,True,missing,missing,missing,"(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.savetxt.html +numpy.savez,numpy,np,Input & output,savez,function,True,available,exact,declared,"(file, *args, allow_pickle=True, **kwds)",NumSharp.np.savez,"byte[] savez(System.Collections.Generic.IDictionary kwds) | byte[] savez(params NumSharp.NDArray[] args) | void savez(System.IO.Stream file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true) | void savez(System.IO.Stream file, System.Collections.Generic.IDictionary kwds) | void savez(System.IO.Stream file, params NumSharp.NDArray[] args) | void savez(string file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true) | void savez(string file, System.Collections.Generic.IDictionary kwds) | void savez(string file, params NumSharp.NDArray[] args)",src/NumSharp.Core/APIs/np.save.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.savez.html +numpy.savez_compressed,numpy,np,Input & output,savez_compressed,function,True,available,exact,declared,"(file, *args, allow_pickle=True, **kwds)",NumSharp.np.savez_compressed,"byte[] savez_compressed(System.Collections.Generic.IDictionary kwds) | byte[] savez_compressed(params NumSharp.NDArray[] args) | void savez_compressed(System.IO.Stream file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true) | void savez_compressed(System.IO.Stream file, System.Collections.Generic.IDictionary kwds) | void savez_compressed(System.IO.Stream file, params NumSharp.NDArray[] args) | void savez_compressed(string file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true) | void savez_compressed(string file, System.Collections.Generic.IDictionary kwds) | void savez_compressed(string file, params NumSharp.NDArray[] args)",src/NumSharp.Core/APIs/np.save.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.savez_compressed.html +numpy.ScalarType,numpy,np,Types & constants,ScalarType,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.sctypeDict,numpy,np,Types & constants,sctypeDict,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.searchsorted,numpy,np,Sorting & searching,searchsorted,function,True,available,exact,declared,"(a, v, side='left', sorter=None)",NumSharp.np.searchsorted,"NumSharp.NDArray searchsorted(NumSharp.NDArray a, NumSharp.NDArray v, string side = ""left"", NumSharp.NDArray sorter = null) | long searchsorted(NumSharp.NDArray a, double v, string side = ""left"", NumSharp.NDArray sorter = null) | long searchsorted(NumSharp.NDArray a, int v, string side = ""left"", NumSharp.NDArray sorter = null)",src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html +numpy.select,numpy,np,Indexing & selection,select,function,True,missing,missing,missing,"(condlist, choicelist, default=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.select.html +numpy.set_printoptions,numpy,np,Text & formatting,set_printoptions,function,True,available,exact,declared,"(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None, override_repr=None)",NumSharp.np.set_printoptions,"void set_printoptions(int? precision = null, int? threshold = null, int? edgeitems = null, int? linewidth = null, bool? suppress = null, string nanstr = null, string infstr = null, char? sign = null, string floatmode = null)",src/NumSharp.Core/APIs/np.array2string.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.set_printoptions.html +numpy.setbufsize,numpy,np,Floating-point handling,setbufsize,function,True,missing,missing,missing,(size),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.setbufsize.html +numpy.setdiff1d,numpy,np,Set operations,setdiff1d,function,True,missing,missing,missing,"(ar1, ar2, assume_unique=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.setdiff1d.html +numpy.seterr,numpy,np,Floating-point handling,seterr,function,True,missing,missing,missing,"(all=None, divide=None, over=None, under=None, invalid=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.seterr.html +numpy.seterrcall,numpy,np,Floating-point handling,seterrcall,function,True,missing,missing,missing,(func),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.seterrcall.html +numpy.setxor1d,numpy,np,Set operations,setxor1d,function,True,missing,missing,missing,"(ar1, ar2, assume_unique=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.setxor1d.html +numpy.shape,numpy,np,Shape manipulation,shape,function,True,partial,alias,partial,(a),NumSharp.NDArray.Shape,NumSharp.Shape Shape { get; set; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,"NumSharp exposes shape as an NDArray Shape property rather than the top-level NumPy tuple-returning helper. NDArray.Shape is a NumSharp Shape value, not the tuple returned by numpy.shape.",https://numpy.org/doc/stable/reference/generated/numpy.shape.html +numpy.shares_memory,numpy,np,Array metadata & memory,shares_memory,function,True,missing,missing,missing,"(a, b, /, max_work=-1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.shares_memory.html +numpy.short,numpy,np,Types,short,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.short,readonly System.Type short,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.show_config,numpy,np,Runtime & diagnostics,show_config,function,True,missing,missing,missing,(mode='stdout'),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.show_config.html +numpy.show_runtime,numpy,np,Runtime & diagnostics,show_runtime,function,True,missing,missing,missing,(),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.show_runtime.html +numpy.sign,numpy,np,Math,sign,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.sign,"NumSharp.NDArray sign(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray sign(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray sign(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.sign.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sign.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.sign.html +numpy.signbit,numpy,np,Math,signbit,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.signbit.html +numpy.signedinteger,numpy,np,Types,signedinteger,class,False,missing,missing,missing,(),,,,,False,, +numpy.sin,numpy,np,Math,sin,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.sin,"NumSharp.NDArray sin(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray sin(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray sin(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.sin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.sin.html +numpy.sinc,numpy,np,Math,sinc,function,True,missing,missing,missing,(x),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.sinc.html +numpy.single,numpy,np,Types,single,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.single,readonly System.Type single,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.sinh,numpy,np,Math,sinh,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.sinh,"NumSharp.NDArray sinh(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray sinh(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray sinh(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.sin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.sinh.html +numpy.size,numpy,np,Shape manipulation,size,function,True,available,exact,declared,"(a, axis=None)",NumSharp.np.size,"long size(NumSharp.NDArray a, int? axis = null)",src/NumSharp.Core/APIs/np.size.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.size.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.size.html +numpy.sort,numpy,np,Sorting & searching,sort,function,True,available,exact,declared,"(a, axis=-1, kind=None, order=None, *, stable=None)",NumSharp.np.sort,"NumSharp.NDArray sort(NumSharp.NDArray a, int? axis = -1, string kind = null)",src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.sort.html +numpy.sort_complex,numpy,np,Sorting & searching,sort_complex,function,True,missing,missing,missing,(a),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.sort_complex.html +numpy.spacing,numpy,np,Math,spacing,ufunc,True,missing,missing,missing,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.spacing.html +numpy.split,numpy,np,Shape manipulation,split,function,True,available,exact,declared,"(ary, indices_or_sections, axis=0)",NumSharp.np.split,"NumSharp.NDArray[] split(NumSharp.NDArray ary, int indices_or_sections, int axis = 0) | NumSharp.NDArray[] split(NumSharp.NDArray ary, int[] indices, int axis = 0) | NumSharp.NDArray[] split(NumSharp.NDArray ary, long[] indices, int axis = 0)",src/NumSharp.Core/Manipulation/np.split.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.split.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.split.html +numpy.sqrt,numpy,np,Math,sqrt,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.sqrt,"NumSharp.NDArray sqrt(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray sqrt(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray sqrt(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.sqrt.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sqrt.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html +numpy.square,numpy,np,Math,square,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.square,"NumSharp.NDArray square(NumSharp.NDArray x) | NumSharp.NDArray square(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.power.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.power.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.square.html +numpy.squeeze,numpy,np,Shape manipulation,squeeze,function,True,available,exact,declared,"(a, axis=None)",NumSharp.np.squeeze,"NumSharp.NDArray squeeze(NumSharp.NDArray a) | NumSharp.NDArray squeeze(NumSharp.NDArray a, int axis) | NumSharp.Shape squeeze(NumSharp.Shape shape)",src/NumSharp.Core/Manipulation/np.squeeze.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.squeeze.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.squeeze.html +numpy.stack,numpy,np,Shape manipulation,stack,function,True,available,exact,declared,"(arrays, axis=0, out=None, *, dtype=None, casting='same_kind')",NumSharp.np.stack,"NumSharp.NDArray stack(NumSharp.NDArray[] arrays, int axis = 0)",src/NumSharp.Core/Creation/np.stack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.stack.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.stack.html +numpy.std,numpy,np,Reductions,std,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)",NumSharp.np.std,"NumSharp.NDArray std(NumSharp.NDArray a, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray std(NumSharp.NDArray a, int axis, NumSharp.NPTypeCode type, bool keepdims = false, int? ddof = null) | NumSharp.NDArray std(NumSharp.NDArray a, int axis, System.Type dtype, bool keepdims = false, int? ddof = null) | NumSharp.NDArray std(NumSharp.NDArray a, int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Statistics/np.std.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.std.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.std.html +numpy.str_,numpy,np,Types,str_,class,False,missing,missing,missing,"(value='', /, *args, **kwargs)",,,,,False,, +numpy.strings,numpy,np,Namespaces,strings,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.subtract,numpy,np,Math,subtract,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.subtract,"NumSharp.NDArray subtract(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.subtract.html +numpy.sum,numpy,np,Reductions,sum,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)",NumSharp.np.sum,"NumSharp.NDArray sum(NumSharp.NDArray a) | NumSharp.NDArray sum(NumSharp.NDArray a, NumSharp.NPTypeCode? typeCode) | NumSharp.NDArray sum(NumSharp.NDArray a, System.Type dtype) | NumSharp.NDArray sum(NumSharp.NDArray a, bool keepdims) | NumSharp.NDArray sum(NumSharp.NDArray a, int axis) | NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, NumSharp.NPTypeCode? typeCode) | NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, System.Type dtype) | NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, bool keepdims) | NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, bool keepdims, NumSharp.NPTypeCode? typeCode) | NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, bool keepdims, System.Type dtype)",src/NumSharp.Core/Math/np.sum.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sum.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.sum.html +numpy.swapaxes,numpy,np,Shape manipulation,swapaxes,function,True,available,exact,declared,"(a, axis1, axis2)",NumSharp.np.swapaxes,"NumSharp.NDArray swapaxes(NumSharp.NDArray a, int axis1, int axis2)",src/NumSharp.Core/Manipulation/np.swapaxes.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.swapaxes.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.swapaxes.html +numpy.take,numpy,np,Indexing & selection,take,function,True,available,exact,declared,"(a, indices, axis=None, out=None, mode='raise')",NumSharp.np.take,"NumSharp.NDArray take(NumSharp.NDArray a, NumSharp.NDArray indices, int? axis = null, NumSharp.NDArray out = null, string mode = ""raise"") | NumSharp.NDArray take(NumSharp.NDArray a, long index, int? axis = null, NumSharp.NDArray out = null, string mode = ""raise"")",src/NumSharp.Core/Indexing/np.take.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.take.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.take.html +numpy.take_along_axis,numpy,np,Indexing & selection,take_along_axis,function,True,missing,missing,missing,"(arr, indices, axis=-1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.take_along_axis.html +numpy.tan,numpy,np,Math,tan,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.tan,"NumSharp.NDArray tan(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray tan(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray tan(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.tan.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.tan.html +numpy.tanh,numpy,np,Math,tanh,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.tanh,"NumSharp.NDArray tanh(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray tanh(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray tanh(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.tan.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.tanh.html +numpy.tensordot,numpy,np,Linear algebra,tensordot,function,True,missing,missing,missing,"(a, b, axes=2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.tensordot.html +numpy.test,numpy,np,Runtime & diagnostics,test,function,True,missing,missing,missing,"(label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, durations=-1, tests=None)",,,,,False,,https://numpy.org/doc/stable/reference/testing.html +numpy.testing,numpy,np,Namespaces,testing,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.tile,numpy,np,Shape manipulation,tile,function,True,available,exact,declared,"(A, reps)",NumSharp.np.tile,"NumSharp.NDArray tile(NumSharp.NDArray A, long[] reps) | NumSharp.NDArray tile(NumSharp.NDArray A, params int[] reps)",src/NumSharp.Core/Manipulation/np.tile.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.tile.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.tile.html +numpy.timedelta64,numpy,np,Types,timedelta64,class,False,missing,missing,missing,"(value=0, /, *args)",,,,,False,, +numpy.trace,numpy,np,Math,trace,function,True,available,exact,declared,"(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)",NumSharp.np.trace,"NumSharp.NDArray trace(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1, System.Type dtype = null, NumSharp.NDArray out = null)",src/NumSharp.Core/Indexing/np.trace.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.trace.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.trace.html +numpy.transpose,numpy,np,Shape manipulation,transpose,function,True,available,exact,declared,"(a, axes=None)",NumSharp.np.transpose,"NumSharp.NDArray transpose(NumSharp.NDArray a, int[] premute = null)",src/NumSharp.Core/Manipulation/np.transpose.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.transpose.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.transpose.html +numpy.trapezoid,numpy,np,Math,trapezoid,function,True,missing,missing,missing,"(y, x=None, dx=1.0, axis=-1)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.trapezoid.html +numpy.tri,numpy,np,Array creation,tri,function,True,missing,missing,missing,"(N, M=None, k=0, dtype=, *, like=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.tri.html +numpy.tril,numpy,np,Array creation,tril,function,True,missing,missing,missing,"(m, k=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.tril.html +numpy.tril_indices,numpy,np,Indexing & selection,tril_indices,function,True,missing,missing,missing,"(n, k=0, m=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.tril_indices.html +numpy.tril_indices_from,numpy,np,Indexing & selection,tril_indices_from,function,True,missing,missing,missing,"(arr, k=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.tril_indices_from.html +numpy.trim_zeros,numpy,np,Shape manipulation,trim_zeros,function,True,available,exact,declared,"(filt, trim='fb', axis=None)",NumSharp.np.trim_zeros,"NumSharp.NDArray trim_zeros(NumSharp.NDArray filt, string trim = ""fb"", int? axis = null) | NumSharp.NDArray trim_zeros(NumSharp.NDArray filt, string trim, int[] axis)",src/NumSharp.Core/Manipulation/np.trim_zeros.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.trim_zeros.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.trim_zeros.html +numpy.triu,numpy,np,Array creation,triu,function,True,missing,missing,missing,"(m, k=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.triu.html +numpy.triu_indices,numpy,np,Indexing & selection,triu_indices,function,True,missing,missing,missing,"(n, k=0, m=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.triu_indices.html +numpy.triu_indices_from,numpy,np,Indexing & selection,triu_indices_from,function,True,missing,missing,missing,"(arr, k=0)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.triu_indices_from.html +numpy.True_,numpy,np,Types & constants,True_,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.true_divide,numpy,np,Math,true_divide,ufunc,True,available,exact,declared,"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.true_divide,"NumSharp.NDArray true_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Math/np.math.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.true_divide.html +numpy.trunc,numpy,np,Math,trunc,ufunc,True,available,exact,declared,"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",NumSharp.np.trunc,"NumSharp.NDArray trunc(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray trunc(NumSharp.NDArray x, NumSharp.NPTypeCode dtype) | NumSharp.NDArray trunc(NumSharp.NDArray x, System.Type dtype)",src/NumSharp.Core/Math/np.trunc.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.trunc.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.trunc.html +numpy.typecodes,numpy,np,Types & constants,typecodes,constant,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.typename,numpy,np,Text & formatting,typename,function,True,missing,missing,missing,(char),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.typename.html +numpy.typing,numpy,np,Namespaces,typing,module,False,missing,missing,missing,Signature unavailable from runtime introspection,,,,,False,, +numpy.ubyte,numpy,np,Types,ubyte,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.ubyte,readonly System.Type ubyte,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ufunc,numpy,np,Types,ufunc,class,False,missing,missing,missing,(),,,,,False,, +numpy.uint,numpy,np,Types,uint,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.uint,readonly System.Type uint,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.uint16,numpy,np,Types,uint16,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.uint16,readonly System.Type uint16,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.uint32,numpy,np,Types,uint32,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.uint32,readonly System.Type uint32,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.uint64,numpy,np,Types,uint64,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.uint64,readonly System.Type uint64,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.uint8,numpy,np,Types,uint8,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.uint8,readonly System.Type uint8,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.uintc,numpy,np,Types,uintc,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.uintc,readonly System.Type uintc,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.uintp,numpy,np,Types,uintp,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.uintp,readonly System.Type uintp,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ulong,numpy,np,Types,ulong,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.ulong,readonly System.Type ulong,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.ulonglong,numpy,np,Types,ulonglong,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.ulonglong,readonly System.Type ulonglong,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.union1d,numpy,np,Set operations,union1d,function,True,missing,missing,missing,"(ar1, ar2)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.union1d.html +numpy.unique,numpy,np,Set operations,unique,function,True,available,exact,declared,"(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True, sorted=True)",NumSharp.np.unique,"NumSharp.NDArray unique(NumSharp.NDArray ar) | NumSharp.NDArray[] unique(NumSharp.NDArray ar, bool return_index, bool return_inverse = false, bool return_counts = false, int? axis = null, bool equal_nan = true)",src/NumSharp.Core/Manipulation/np.unique.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.unique.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.unique.html +numpy.unique_all,numpy,np,Set operations,unique_all,function,True,missing,missing,missing,(x),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.unique_all.html +numpy.unique_counts,numpy,np,Set operations,unique_counts,function,True,missing,missing,missing,(x),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.unique_counts.html +numpy.unique_inverse,numpy,np,Set operations,unique_inverse,function,True,missing,missing,missing,(x),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.unique_inverse.html +numpy.unique_values,numpy,np,Set operations,unique_values,function,True,missing,missing,missing,(x),,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.unique_values.html +numpy.unpackbits,numpy,np,Math,unpackbits,function,True,missing,missing,missing,"(a, /, axis=None, count=None, bitorder='big')",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.unpackbits.html +numpy.unravel_index,numpy,np,Indexing & selection,unravel_index,function,True,available,exact,declared,"(indices, shape, order='C')",NumSharp.np.unravel_index,"NumSharp.Generic.NDArray[] unravel_index(NumSharp.NDArray indices, int[] shape, char order = 'C') | long[] unravel_index(long index, int[] shape, char order = 'C')",src/NumSharp.Core/Indexing/np.unravel_index.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.unravel_index.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html +numpy.unsignedinteger,numpy,np,Types,unsignedinteger,class,False,missing,missing,missing,(),,,,,False,, +numpy.unstack,numpy,np,Shape manipulation,unstack,function,True,available,exact,declared,"(x, /, *, axis=0)",NumSharp.np.unstack,"NumSharp.NDArray[] unstack(NumSharp.NDArray x, int axis = 0)",src/NumSharp.Core/Creation/np.unstack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.unstack.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.unstack.html +numpy.unwrap,numpy,np,Math,unwrap,function,True,missing,missing,missing,"(p, discont=None, axis=-1, *, period=6.283185307179586)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.unwrap.html +numpy.ushort,numpy,np,Types,ushort,class,False,available,exact,declared,"(value=0, /)",NumSharp.np.ushort,readonly System.Type ushort,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,, +numpy.vander,numpy,np,Array creation,vander,function,True,missing,missing,missing,"(x, N=None, increasing=False)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.vander.html +numpy.var,numpy,np,Reductions,var,function,True,available,exact,declared,"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)",NumSharp.np.var,"NumSharp.NDArray var(NumSharp.NDArray a, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null) | NumSharp.NDArray var(NumSharp.NDArray a, int axis, NumSharp.NPTypeCode type, bool keepdims = false, int? ddof = null) | NumSharp.NDArray var(NumSharp.NDArray a, int axis, System.Type dtype, bool keepdims = false, int? ddof = null) | NumSharp.NDArray var(NumSharp.NDArray a, int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)",src/NumSharp.Core/Statistics/np.var.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.var.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.var.html +numpy.vdot,numpy,np,Linear algebra,vdot,function,True,missing,missing,missing,"(a, b, /)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.vdot.html +numpy.vecdot,numpy,np,Linear algebra,vecdot,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.vecdot.html +numpy.vecmat,numpy,np,Linear algebra,vecmat,ufunc,True,missing,missing,missing,"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)",,,,,False,,https://numpy.org/doc/stable/reference/generated/numpy.vecmat.html +numpy.vectorize,numpy,np,Types,vectorize,class,False,missing,missing,missing,"(pyfunc=, otypes=None, doc=None, excluded=None, cache=False, signature=None)",,,,,False,, +numpy.void,numpy,np,Types,void,class,False,missing,missing,missing,"(length_or_data, /, dtype=None)",,,,,False,, +numpy.vsplit,numpy,np,Shape manipulation,vsplit,function,True,available,exact,declared,"(ary, indices_or_sections)",NumSharp.np.vsplit,"NumSharp.NDArray[] vsplit(NumSharp.NDArray ary, int indices_or_sections) | NumSharp.NDArray[] vsplit(NumSharp.NDArray ary, int[] indices)",src/NumSharp.Core/Manipulation/np.vsplit.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.vsplit.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.vsplit.html +numpy.vstack,numpy,np,Shape manipulation,vstack,function,True,available,exact,declared,"(tup, *, dtype=None, casting='same_kind')",NumSharp.np.vstack,NumSharp.NDArray vstack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/np.vstack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.vstack.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.vstack.html +numpy.where,numpy,np,Indexing & selection,where,function,True,available,exact,declared,"(condition, x=None, y=None, /)",NumSharp.np.where,"NumSharp.Generic.NDArray[] where(NumSharp.NDArray condition) | NumSharp.NDArray where(NumSharp.NDArray condition, NumSharp.NDArray x, NumSharp.NDArray y) | NumSharp.NDArray where(NumSharp.NDArray condition, NumSharp.NDArray x, object y) | NumSharp.NDArray where(NumSharp.NDArray condition, object x, NumSharp.NDArray y) | NumSharp.NDArray where(NumSharp.NDArray condition, object x, object y)",src/NumSharp.Core/APIs/np.where.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.where.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.where.html +numpy.zeros,numpy,np,Array creation,zeros,function,True,available,exact,declared,"(shape, dtype=None, order='C', *, device=None, like=None)",NumSharp.np.zeros,"NumSharp.NDArray zeros(NumSharp.Shape shape) | NumSharp.NDArray zeros(NumSharp.Shape shape, NumSharp.NPTypeCode typeCode) | NumSharp.NDArray zeros(NumSharp.Shape shape, System.Type dtype) | NumSharp.NDArray zeros(int shape) | NumSharp.NDArray zeros(int[] shape) | NumSharp.NDArray zeros(int[] shape) | NumSharp.NDArray zeros(long[] shape) | NumSharp.NDArray zeros(long[] shape)",src/NumSharp.Core/Creation/np.zeros.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.zeros.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.zeros.html +numpy.zeros_like,numpy,np,Array creation,zeros_like,function,True,available,exact,declared,"(a, dtype=None, order='K', subok=True, shape=None, *, device=None)",NumSharp.np.zeros_like,"NumSharp.NDArray zeros_like(NumSharp.NDArray a, System.Type dtype = null) | NumSharp.NDArray zeros_like(NumSharp.NDArray a, System.Type dtype, char order)",src/NumSharp.Core/Creation/np.zeros_like.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.zeros_like.cs,False,,https://numpy.org/doc/stable/reference/generated/numpy.zeros_like.html +numpy.random.beta,numpy,random,Random,beta,function,True,available,exact,declared,"(a, b, size=None)",NumSharp.NumPyRandom.beta,"NumSharp.NDArray beta(double a, double b) | NumSharp.NDArray beta(double a, double b, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.beta.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.beta.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.beta.html +numpy.random.binomial,numpy,random,Random,binomial,function,True,available,exact,declared,"(n, p, size=None)",NumSharp.NumPyRandom.binomial,"NumSharp.NDArray binomial(int n, double p) | NumSharp.NDArray binomial(int n, double p, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.binomial.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.binomial.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.binomial.html +numpy.random.BitGenerator,numpy,random,Random,BitGenerator,class,False,missing,missing,missing,(seed=None),,,,,False,, +numpy.random.bytes,numpy,random,Random,bytes,function,True,missing,missing,missing,(length),,,,,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.bytes.html +numpy.random.chisquare,numpy,random,Random,chisquare,function,True,available,exact,declared,"(df, size=None)",NumSharp.NumPyRandom.chisquare,"NumSharp.NDArray chisquare(double df) | NumSharp.NDArray chisquare(double df, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.chisquare.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.chisquare.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.chisquare.html +numpy.random.choice,numpy,random,Random,choice,function,True,available,exact,declared,"(a, size=None, replace=True, p=None)",NumSharp.NumPyRandom.choice,"NumSharp.NDArray choice(NumSharp.NDArray a, NumSharp.Shape size = null, bool replace = true, double[] p = null) | NumSharp.NDArray choice(int a, NumSharp.Shape size = null, bool replace = true, double[] p = null) | NumSharp.NDArray choice(long a, NumSharp.Shape size = null, bool replace = true, double[] p = null)",src/NumSharp.Core/RandomSampling/np.random.choice.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.choice.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.choice.html +numpy.random.default_rng,numpy,random,Random,default_rng,function,True,missing,missing,missing,(seed=None),,,,,False,,https://numpy.org/doc/stable/reference/random/generator.html#numpy.random.default_rng +numpy.random.dirichlet,numpy,random,Random,dirichlet,function,True,available,exact,declared,"(alpha, size=None)",NumSharp.NumPyRandom.dirichlet,"NumSharp.NDArray dirichlet(NumSharp.NDArray alpha, NumSharp.Shape? size = null) | NumSharp.NDArray dirichlet(double[] alpha, NumSharp.Shape? size = null) | NumSharp.NDArray dirichlet(double[] alpha, int size) | NumSharp.NDArray dirichlet(double[] alpha, int[] size) | NumSharp.NDArray dirichlet(double[] alpha, long[] size)",src/NumSharp.Core/RandomSampling/np.random.dirichlet.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.dirichlet.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.dirichlet.html +numpy.random.exponential,numpy,random,Random,exponential,function,True,available,exact,declared,"(scale=1.0, size=None)",NumSharp.NumPyRandom.exponential,"NumSharp.NDArray exponential(double scale = 1) | NumSharp.NDArray exponential(double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.exponential.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.exponential.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.exponential.html +numpy.random.f,numpy,random,Random,f,function,True,available,exact,declared,"(dfnum, dfden, size=None)",NumSharp.NumPyRandom.f,"NumSharp.NDArray f(double dfnum, double dfden) | NumSharp.NDArray f(double dfnum, double dfden, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.f.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.f.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.f.html +numpy.random.gamma,numpy,random,Random,gamma,function,True,available,exact,declared,"(shape, scale=1.0, size=None)",NumSharp.NumPyRandom.gamma,"NumSharp.NDArray gamma(double shape, double scale = 1) | NumSharp.NDArray gamma(double shape, double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.gamma.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.gamma.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.gamma.html +numpy.random.Generator,numpy,random,Random,Generator,class,False,missing,missing,missing,(bit_generator),,,,,False,, +numpy.random.geometric,numpy,random,Random,geometric,function,True,available,exact,declared,"(p, size=None)",NumSharp.NumPyRandom.geometric,"NumSharp.NDArray geometric(double p) | NumSharp.NDArray geometric(double p, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.geometric.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.geometric.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.geometric.html +numpy.random.get_state,numpy,random,Random,get_state,function,True,available,exact,declared,(legacy=True),NumSharp.NumPyRandom.get_state,NumSharp.NativeRandomState get_state(),src/NumSharp.Core/RandomSampling/np.random.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.get_state.html +numpy.random.gumbel,numpy,random,Random,gumbel,function,True,available,exact,declared,"(loc=0.0, scale=1.0, size=None)",NumSharp.NumPyRandom.gumbel,"NumSharp.NDArray gumbel(double loc = 0, double scale = 1) | NumSharp.NDArray gumbel(double loc, double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.gumbel.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.gumbel.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.gumbel.html +numpy.random.hypergeometric,numpy,random,Random,hypergeometric,function,True,available,exact,declared,"(ngood, nbad, nsample, size=None)",NumSharp.NumPyRandom.hypergeometric,"NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample) | NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, NumSharp.Shape? size = null) | NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, int size) | NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, int[] size) | NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, long[] size)",src/NumSharp.Core/RandomSampling/np.random.hypergeometric.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.hypergeometric.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.hypergeometric.html +numpy.random.laplace,numpy,random,Random,laplace,function,True,available,exact,declared,"(loc=0.0, scale=1.0, size=None)",NumSharp.NumPyRandom.laplace,"NumSharp.NDArray laplace(double loc = 0, double scale = 1) | NumSharp.NDArray laplace(double loc, double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.laplace.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.laplace.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.laplace.html +numpy.random.logistic,numpy,random,Random,logistic,function,True,available,exact,declared,"(loc=0.0, scale=1.0, size=None)",NumSharp.NumPyRandom.logistic,"NumSharp.NDArray logistic(double loc = 0, double scale = 1) | NumSharp.NDArray logistic(double loc, double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.logistic.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.logistic.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.logistic.html +numpy.random.lognormal,numpy,random,Random,lognormal,function,True,available,exact,declared,"(mean=0.0, sigma=1.0, size=None)",NumSharp.NumPyRandom.lognormal,"NumSharp.NDArray lognormal(double mean = 0, double sigma = 1) | NumSharp.NDArray lognormal(double mean, double sigma, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.lognormal.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.lognormal.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.lognormal.html +numpy.random.logseries,numpy,random,Random,logseries,function,True,available,exact,declared,"(p, size=None)",NumSharp.NumPyRandom.logseries,"NumSharp.NDArray logseries(double p, NumSharp.Shape size) | NumSharp.NDArray logseries(double p, NumSharp.Shape? size = null) | NumSharp.NDArray logseries(double p, int size) | NumSharp.NDArray logseries(double p, int[] size) | NumSharp.NDArray logseries(double p, long[] size)",src/NumSharp.Core/RandomSampling/np.random.logseries.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.logseries.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.logseries.html +numpy.random.MT19937,numpy,random,Random,MT19937,class,False,missing,missing,missing,(seed=None),,,,,False,, +numpy.random.multinomial,numpy,random,Random,multinomial,function,True,available,exact,declared,"(n, pvals, size=None)",NumSharp.NumPyRandom.multinomial,"NumSharp.NDArray multinomial(int n, double[] pvals, NumSharp.Shape? size = null) | NumSharp.NDArray multinomial(int n, double[] pvals, int size) | NumSharp.NDArray multinomial(int n, double[] pvals, int[] size)",src/NumSharp.Core/RandomSampling/np.random.multinomial.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.multinomial.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.multinomial.html +numpy.random.multivariate_normal,numpy,random,Random,multivariate_normal,function,True,available,exact,declared,"(mean, cov, size=None, check_valid='warn', tol=1e-08)",NumSharp.NumPyRandom.multivariate_normal,"NumSharp.NDArray multivariate_normal(NumSharp.NDArray mean, NumSharp.NDArray cov, NumSharp.Shape? size = null, string check_valid = ""warn"", double tol = 1E-08) | NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, NumSharp.Shape? size = null, string check_valid = ""warn"", double tol = 1E-08) | NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, int size, string check_valid = ""warn"", double tol = 1E-08) | NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, int[] size) | NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, long[] size)",src/NumSharp.Core/RandomSampling/np.random.multivariate_normal.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.multivariate_normal.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.multivariate_normal.html +numpy.random.negative_binomial,numpy,random,Random,negative_binomial,function,True,available,exact,declared,"(n, p, size=None)",NumSharp.NumPyRandom.negative_binomial,"NumSharp.NDArray negative_binomial(double n, double p) | NumSharp.NDArray negative_binomial(double n, double p, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.negative_binomial.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.negative_binomial.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.negative_binomial.html +numpy.random.noncentral_chisquare,numpy,random,Random,noncentral_chisquare,function,True,available,exact,declared,"(df, nonc, size=None)",NumSharp.NumPyRandom.noncentral_chisquare,"NumSharp.NDArray noncentral_chisquare(double df, double nonc) | NumSharp.NDArray noncentral_chisquare(double df, double nonc, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.noncentral_chisquare.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.noncentral_chisquare.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.noncentral_chisquare.html +numpy.random.noncentral_f,numpy,random,Random,noncentral_f,function,True,available,exact,declared,"(dfnum, dfden, nonc, size=None)",NumSharp.NumPyRandom.noncentral_f,"NumSharp.NDArray noncentral_f(double dfnum, double dfden, double nonc) | NumSharp.NDArray noncentral_f(double dfnum, double dfden, double nonc, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.noncentral_f.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.noncentral_f.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.noncentral_f.html +numpy.random.normal,numpy,random,Random,normal,function,True,available,exact,declared,"(loc=0.0, scale=1.0, size=None)",NumSharp.NumPyRandom.normal,"NumSharp.NDArray normal(double loc = 0, double scale = 1) | NumSharp.NDArray normal(double loc, double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.randn.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randn.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.normal.html +numpy.random.pareto,numpy,random,Random,pareto,function,True,available,exact,declared,"(a, size=None)",NumSharp.NumPyRandom.pareto,"NumSharp.NDArray pareto(double a) | NumSharp.NDArray pareto(double a, NumSharp.Shape size) | NumSharp.NDArray pareto(double a, int size) | NumSharp.NDArray pareto(double a, int[] size) | NumSharp.NDArray pareto(double a, long[] size)",src/NumSharp.Core/RandomSampling/np.random.pareto.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.pareto.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.pareto.html +numpy.random.PCG64,numpy,random,Random,PCG64,class,False,missing,missing,missing,(seed=None),,,,,False,, +numpy.random.PCG64DXSM,numpy,random,Random,PCG64DXSM,class,False,missing,missing,missing,(seed=None),,,,,False,, +numpy.random.permutation,numpy,random,Random,permutation,function,True,available,exact,declared,(x),NumSharp.NumPyRandom.permutation,NumSharp.NDArray permutation(NumSharp.NDArray x) | NumSharp.NDArray permutation(int x),src/NumSharp.Core/RandomSampling/np.random.permutation.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.permutation.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.permutation.html +numpy.random.Philox,numpy,random,Random,Philox,class,False,missing,missing,missing,"(seed=None, counter=None, key=None)",,,,,False,, +numpy.random.poisson,numpy,random,Random,poisson,function,True,available,exact,declared,"(lam=1.0, size=None)",NumSharp.NumPyRandom.poisson,"NumSharp.NDArray poisson(double lam = 1) | NumSharp.NDArray poisson(double lam, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.poisson.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.poisson.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.poisson.html +numpy.random.power,numpy,random,Random,power,function,True,available,exact,declared,"(a, size=None)",NumSharp.NumPyRandom.power,"NumSharp.NDArray power(double a) | NumSharp.NDArray power(double a, NumSharp.Shape size) | NumSharp.NDArray power(double a, int size) | NumSharp.NDArray power(double a, int[] size) | NumSharp.NDArray power(double a, long[] size)",src/NumSharp.Core/RandomSampling/np.random.power.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.power.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.power.html +numpy.random.rand,numpy,random,Random,rand,function,True,available,exact,declared,(*args),NumSharp.NumPyRandom.rand,NumSharp.NDArray rand(NumSharp.Shape shape) | NumSharp.NDArray rand(params long[] shape),src/NumSharp.Core/RandomSampling/np.random.rand.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html +numpy.random.randint,numpy,random,Random,randint,function,True,available,exact,declared,"(low, high=None, size=None, dtype=)",NumSharp.NumPyRandom.randint,"NumSharp.NDArray randint(long low, long high = -1, NumSharp.Shape size = null, System.Type dtype = null)",src/NumSharp.Core/RandomSampling/np.random.randint.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randint.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.randint.html +numpy.random.randn,numpy,random,Random,randn,function,True,available,exact,declared,(*args),NumSharp.NumPyRandom.randn,NumSharp.NDArray randn(params long[] shape) | T randn(),src/NumSharp.Core/RandomSampling/np.random.randn.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randn.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.randn.html +numpy.random.random,numpy,random,Random,random,function,True,available,exact,declared,(size=None),NumSharp.NumPyRandom.random,NumSharp.NDArray random(params long[] size),src/NumSharp.Core/RandomSampling/np.random.rand.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.random.html +numpy.random.random_integers,numpy,random,Random,random_integers,function,True,partial,alias,partial,"(low, high=None, size=None)",NumSharp.NumPyRandom.randint,"NumSharp.NDArray randint(long low, long high = -1, NumSharp.Shape size = null, System.Type dtype = null)",src/NumSharp.Core/RandomSampling/np.random.randint.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randint.cs,False,"Use randint and adjust the upper bound; deprecated random_integers includes the high endpoint. The available randint alternative has an exclusive upper bound, while random_integers historically used an inclusive upper bound.",https://numpy.org/doc/stable/reference/random/generated/numpy.random.random_integers.html +numpy.random.random_sample,numpy,random,Random,random_sample,function,True,available,exact,declared,(size=None),NumSharp.NumPyRandom.random_sample,NumSharp.NDArray random_sample(params long[] size),src/NumSharp.Core/RandomSampling/np.random.rand.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.random_sample.html +numpy.random.RandomState,numpy,random,Random,RandomState,class,False,available,exact,declared,(seed=None),NumSharp.NumPyRandom.RandomState,NumSharp.NumPyRandom RandomState() | NumSharp.NumPyRandom RandomState(NumSharp.NativeRandomState state) | NumSharp.NumPyRandom RandomState(int seed),src/NumSharp.Core/RandomSampling/np.random.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs,False,, +numpy.random.ranf,numpy,random,Random,ranf,function,True,available,alias,declared,"(*args, **kwargs)",NumSharp.NumPyRandom.random_sample,NumSharp.NDArray random_sample(params long[] size),src/NumSharp.Core/RandomSampling/np.random.rand.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs,False,NumPy documents ranf as an alias of random_sample.,https://numpy.org/doc/stable/reference/random/generated/numpy.random.ranf.html +numpy.random.rayleigh,numpy,random,Random,rayleigh,function,True,available,exact,declared,"(scale=1.0, size=None)",NumSharp.NumPyRandom.rayleigh,"NumSharp.NDArray rayleigh(double scale = 1) | NumSharp.NDArray rayleigh(double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.rayleigh.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rayleigh.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.rayleigh.html +numpy.random.sample,numpy,random,Random,sample,function,True,available,alias,declared,"(*args, **kwargs)",NumSharp.NumPyRandom.random_sample,NumSharp.NDArray random_sample(params long[] size),src/NumSharp.Core/RandomSampling/np.random.rand.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs,False,NumPy documents sample as an alias of random_sample.,https://numpy.org/doc/stable/reference/random/generated/numpy.random.sample.html +numpy.random.seed,numpy,random,Random,seed,function,True,available,exact,declared,(seed=None),NumSharp.NumPyRandom.seed,void seed(int seed) | void seed(long seed) | void seed(uint seed) | void seed(uint[] seed) | void seed(ulong seed),src/NumSharp.Core/RandomSampling/np.random.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.seed.html +numpy.random.SeedSequence,numpy,random,Random,SeedSequence,class,False,missing,missing,missing,"(entropy=None, *, spawn_key=(), pool_size=4, n_children_spawned=0)",,,,,False,, +numpy.random.set_state,numpy,random,Random,set_state,function,True,available,exact,declared,(state),NumSharp.NumPyRandom.set_state,void set_state(NumSharp.NativeRandomState state),src/NumSharp.Core/RandomSampling/np.random.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.set_state.html +numpy.random.SFC64,numpy,random,Random,SFC64,class,False,missing,missing,missing,(seed=None),,,,,False,, +numpy.random.shuffle,numpy,random,Random,shuffle,function,True,available,exact,declared,(x),NumSharp.NumPyRandom.shuffle,void shuffle(NumSharp.NDArray x),src/NumSharp.Core/RandomSampling/np.random.shuffle.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.shuffle.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.shuffle.html +numpy.random.standard_cauchy,numpy,random,Random,standard_cauchy,function,True,available,exact,declared,(size=None),NumSharp.NumPyRandom.standard_cauchy,NumSharp.NDArray standard_cauchy() | NumSharp.NDArray standard_cauchy(NumSharp.Shape size),src/NumSharp.Core/RandomSampling/np.random.standard_cauchy.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_cauchy.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_cauchy.html +numpy.random.standard_exponential,numpy,random,Random,standard_exponential,function,True,available,exact,declared,(size=None),NumSharp.NumPyRandom.standard_exponential,NumSharp.NDArray standard_exponential() | NumSharp.NDArray standard_exponential(NumSharp.Shape size),src/NumSharp.Core/RandomSampling/np.random.standard_exponential.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_exponential.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_exponential.html +numpy.random.standard_gamma,numpy,random,Random,standard_gamma,function,True,available,exact,declared,"(shape, size=None)",NumSharp.NumPyRandom.standard_gamma,"NumSharp.NDArray standard_gamma(double shape) | NumSharp.NDArray standard_gamma(double shape, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.standard_gamma.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_gamma.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_gamma.html +numpy.random.standard_normal,numpy,random,Random,standard_normal,function,True,available,exact,declared,(size=None),NumSharp.NumPyRandom.standard_normal,NumSharp.NDArray standard_normal() | NumSharp.NDArray standard_normal(NumSharp.Shape size),src/NumSharp.Core/RandomSampling/np.random.randn.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randn.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_normal.html +numpy.random.standard_t,numpy,random,Random,standard_t,function,True,available,exact,declared,"(df, size=None)",NumSharp.NumPyRandom.standard_t,"NumSharp.NDArray standard_t(double df) | NumSharp.NDArray standard_t(double df, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.standard_t.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_t.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_t.html +numpy.random.triangular,numpy,random,Random,triangular,function,True,available,exact,declared,"(left, mode, right, size=None)",NumSharp.NumPyRandom.triangular,"NumSharp.NDArray triangular(double left, double mode, double right) | NumSharp.NDArray triangular(double left, double mode, double right, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.triangular.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.triangular.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.triangular.html +numpy.random.uniform,numpy,random,Random,uniform,function,True,available,exact,declared,"(low=0.0, high=1.0, size=None)",NumSharp.NumPyRandom.uniform,"NumSharp.NDArray uniform(NumSharp.NDArray low, NumSharp.NDArray high, System.Type dtype = null) | NumSharp.NDArray uniform(double low = 0, double high = 1) | NumSharp.NDArray uniform(double low, double high, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.uniform.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.uniform.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.uniform.html +numpy.random.vonmises,numpy,random,Random,vonmises,function,True,available,exact,declared,"(mu, kappa, size=None)",NumSharp.NumPyRandom.vonmises,"NumSharp.NDArray vonmises(double mu, double kappa) | NumSharp.NDArray vonmises(double mu, double kappa, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.vonmises.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.vonmises.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.vonmises.html +numpy.random.wald,numpy,random,Random,wald,function,True,available,exact,declared,"(mean, scale, size=None)",NumSharp.NumPyRandom.wald,"NumSharp.NDArray wald(double mean, double scale) | NumSharp.NDArray wald(double mean, double scale, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.wald.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.wald.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.wald.html +numpy.random.weibull,numpy,random,Random,weibull,function,True,available,exact,declared,"(a, size=None)",NumSharp.NumPyRandom.weibull,"NumSharp.NDArray weibull(double a) | NumSharp.NDArray weibull(double a, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.weibull.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.weibull.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.weibull.html +numpy.random.zipf,numpy,random,Random,zipf,function,True,available,exact,declared,"(a, size=None)",NumSharp.NumPyRandom.zipf,"NumSharp.NDArray zipf(double a) | NumSharp.NDArray zipf(double a, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.zipf.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.zipf.cs,False,,https://numpy.org/doc/stable/reference/random/generated/numpy.random.zipf.html +numsharp.ndarray.amax,numsharp,ndarray,NumSharp-only APIs,amax,method,False,extension,extension,extension,,NumSharp.NDArray.amax,"NumSharp.NDArray amax(System.Type dtype = null) | NumSharp.NDArray amax(int axis, bool keepdims = false, System.Type dtype = null) | T amax()",src/NumSharp.Core/Statistics/NDArray.amax.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amax.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.amin,numsharp,ndarray,NumSharp-only APIs,amin,method,False,extension,extension,extension,,NumSharp.NDArray.amin,"NumSharp.NDArray amin(System.Type dtype = null) | NumSharp.NDArray amin(int axis, bool keepdims = false, System.Type dtype = null) | T amin()",src/NumSharp.Core/Statistics/NDArray.amin.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amin.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.array_equal,numsharp,ndarray,NumSharp-only APIs,array_equal,method,False,extension,extension,extension,,NumSharp.NDArray.array_equal,bool array_equal(NumSharp.NDArray rhs),src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.AsGeneric,numsharp,ndarray,NumSharp-only APIs,AsGeneric,method,False,extension,extension,extension,,NumSharp.NDArray.AsGeneric,NumSharp.Generic.NDArray AsGeneric(),src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.AsOrMakeGeneric,numsharp,ndarray,NumSharp-only APIs,AsOrMakeGeneric,method,False,extension,extension,extension,,NumSharp.NDArray.AsOrMakeGeneric,NumSharp.Generic.NDArray AsOrMakeGeneric(),src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.Clone,numsharp,ndarray,NumSharp-only APIs,Clone,method,False,extension,extension,extension,,NumSharp.NDArray.Clone,NumSharp.NDArray Clone(),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.CloneData,numsharp,ndarray,NumSharp-only APIs,CloneData,method,False,extension,extension,extension,,NumSharp.NDArray.CloneData,NumSharp.Backends.Unmanaged.ArraySlice CloneData() | NumSharp.Backends.Unmanaged.IArraySlice CloneData(),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.Contains,numsharp,ndarray,NumSharp-only APIs,Contains,method,False,extension,extension,extension,,NumSharp.NDArray.Contains,bool Contains(object value),src/NumSharp.Core/Backends/NDArray.Container.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.convolve,numsharp,ndarray,NumSharp-only APIs,convolve,method,False,extension,extension,extension,,NumSharp.NDArray.convolve,"NumSharp.NDArray convolve(NumSharp.NDArray v, string mode = ""full"")",src/NumSharp.Core/Math/NdArray.Convolve.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NdArray.Convolve.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.CopyTo,numsharp,ndarray,NumSharp-only APIs,CopyTo,method,False,extension,extension,extension,,NumSharp.NDArray.CopyTo,void CopyTo(NumSharp.Backends.Unmanaged.IMemoryBlock slice) | void CopyTo(NumSharp.Backends.Unmanaged.IMemoryBlock block) | void CopyTo(System.IntPtr ptr) | void CopyTo(System.Void* address) | void CopyTo(T* address) | void CopyTo(T[] array),src/NumSharp.Core/Backends/NDArray.CopyTo.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.CopyTo.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.delete,numsharp,ndarray,NumSharp-only APIs,delete,method,False,extension,extension,extension,,NumSharp.NDArray.delete,NumSharp.NDArray delete(System.Collections.IEnumerable indices),src/NumSharp.Core/Manipulation/NdArray.delete.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NdArray.delete.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.Dispose,numsharp,ndarray,NumSharp-only APIs,Dispose,method,False,extension,extension,extension,,NumSharp.NDArray.Dispose,void Dispose(),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.dstack,numsharp,ndarray,NumSharp-only APIs,dstack,method,False,extension,extension,extension,,NumSharp.NDArray.dstack,NumSharp.NDArray dstack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/NdArray.DStack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.DStack.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.Equals,numsharp,ndarray,NumSharp-only APIs,Equals,method,False,extension,extension,extension,,NumSharp.NDArray.Equals,bool Equals(object obj),src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetAtIndex,numsharp,ndarray,NumSharp-only APIs,GetAtIndex,method,False,extension,extension,extension,,NumSharp.NDArray.GetAtIndex,T GetAtIndex(long index) | object GetAtIndex(long index),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetBoolean,numsharp,ndarray,NumSharp-only APIs,GetBoolean,method,False,extension,extension,extension,,NumSharp.NDArray.GetBoolean,bool GetBoolean(int[] indices) | bool GetBoolean(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetByte,numsharp,ndarray,NumSharp-only APIs,GetByte,method,False,extension,extension,extension,,NumSharp.NDArray.GetByte,byte GetByte(int[] indices) | byte GetByte(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetChar,numsharp,ndarray,NumSharp-only APIs,GetChar,method,False,extension,extension,extension,,NumSharp.NDArray.GetChar,char GetChar(int[] indices) | char GetChar(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetComplex,numsharp,ndarray,NumSharp-only APIs,GetComplex,method,False,extension,extension,extension,,NumSharp.NDArray.GetComplex,System.Numerics.Complex GetComplex(int[] indices) | System.Numerics.Complex GetComplex(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetData,numsharp,ndarray,NumSharp-only APIs,GetData,method,False,extension,extension,extension,,NumSharp.NDArray.GetData,NumSharp.Backends.Unmanaged.ArraySlice GetData() | NumSharp.Backends.Unmanaged.IArraySlice GetData() | NumSharp.NDArray GetData(int[] indices) | NumSharp.NDArray GetData(long[] indices),src/NumSharp.Core/Backends/NDArray.Container.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetDecimal,numsharp,ndarray,NumSharp-only APIs,GetDecimal,method,False,extension,extension,extension,,NumSharp.NDArray.GetDecimal,decimal GetDecimal(int[] indices) | decimal GetDecimal(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetDouble,numsharp,ndarray,NumSharp-only APIs,GetDouble,method,False,extension,extension,extension,,NumSharp.NDArray.GetDouble,double GetDouble(int[] indices) | double GetDouble(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetEnumerator,numsharp,ndarray,NumSharp-only APIs,GetEnumerator,method,False,extension,extension,extension,,NumSharp.NDArray.GetEnumerator,System.Collections.IEnumerator GetEnumerator(),src/NumSharp.Core/Backends/NDArray.Container.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetHalf,numsharp,ndarray,NumSharp-only APIs,GetHalf,method,False,extension,extension,extension,,NumSharp.NDArray.GetHalf,System.Half GetHalf(int[] indices) | System.Half GetHalf(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetHashCode,numsharp,ndarray,NumSharp-only APIs,GetHashCode,method,False,extension,extension,extension,,NumSharp.NDArray.GetHashCode,int GetHashCode(),src/NumSharp.Core/Backends/NDArray.Container.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetIndices,numsharp,ndarray,NumSharp-only APIs,GetIndices,method,False,extension,extension,extension,,NumSharp.NDArray.GetIndices,"NumSharp.NDArray GetIndices(NumSharp.NDArray out, NumSharp.NDArray[] indices)",src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetInt16,numsharp,ndarray,NumSharp-only APIs,GetInt16,method,False,extension,extension,extension,,NumSharp.NDArray.GetInt16,short GetInt16(int[] indices) | short GetInt16(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetInt32,numsharp,ndarray,NumSharp-only APIs,GetInt32,method,False,extension,extension,extension,,NumSharp.NDArray.GetInt32,int GetInt32(int[] indices) | int GetInt32(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetInt64,numsharp,ndarray,NumSharp-only APIs,GetInt64,method,False,extension,extension,extension,,NumSharp.NDArray.GetInt64,long GetInt64(int[] indices) | long GetInt64(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetNDArrays,numsharp,ndarray,NumSharp-only APIs,GetNDArrays,method,False,extension,extension,extension,,NumSharp.NDArray.GetNDArrays,NumSharp.NDArray[] GetNDArrays(int axis = 0),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetSByte,numsharp,ndarray,NumSharp-only APIs,GetSByte,method,False,extension,extension,extension,,NumSharp.NDArray.GetSByte,sbyte GetSByte(int[] indices) | sbyte GetSByte(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetSingle,numsharp,ndarray,NumSharp-only APIs,GetSingle,method,False,extension,extension,extension,,NumSharp.NDArray.GetSingle,float GetSingle(int[] indices) | float GetSingle(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetString,numsharp,ndarray,NumSharp-only APIs,GetString,method,False,extension,extension,extension,,NumSharp.NDArray.GetString,string GetString(params long[] indices),src/NumSharp.Core/Backends/NDArray.String.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetStringAt,numsharp,ndarray,NumSharp-only APIs,GetStringAt,method,False,extension,extension,extension,,NumSharp.NDArray.GetStringAt,string GetStringAt(long offset),src/NumSharp.Core/Backends/NDArray.String.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetUInt16,numsharp,ndarray,NumSharp-only APIs,GetUInt16,method,False,extension,extension,extension,,NumSharp.NDArray.GetUInt16,ushort GetUInt16(int[] indices) | ushort GetUInt16(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetUInt32,numsharp,ndarray,NumSharp-only APIs,GetUInt32,method,False,extension,extension,extension,,NumSharp.NDArray.GetUInt32,uint GetUInt32(int[] indices) | uint GetUInt32(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetUInt64,numsharp,ndarray,NumSharp-only APIs,GetUInt64,method,False,extension,extension,extension,,NumSharp.NDArray.GetUInt64,ulong GetUInt64(int[] indices) | ulong GetUInt64(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.GetValue,numsharp,ndarray,NumSharp-only APIs,GetValue,method,False,extension,extension,extension,,NumSharp.NDArray.GetValue,T GetValue(int[] indices) | T GetValue(params long[] indices) | object GetValue(int[] indices) | object GetValue(params long[] indices),src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.hstack,numsharp,ndarray,NumSharp-only APIs,hstack,method,False,extension,extension,extension,,NumSharp.NDArray.hstack,NumSharp.NDArray hstack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/NdArray.HStack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.HStack.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.IsDisposed,numsharp,ndarray,NumSharp-only APIs,IsDisposed,property,False,extension,extension,extension,,NumSharp.NDArray.IsDisposed,bool IsDisposed { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.Item,numsharp,ndarray,NumSharp-only APIs,Item,property,False,extension,extension,extension,,NumSharp.NDArray.Item,"NumSharp.NDArray Item[NumSharp.Generic.NDArray mask] { get; set; } | NumSharp.NDArray Item[System.Int64* dims, int ndims] { get; set; } | NumSharp.NDArray Item[params NumSharp.Generic.NDArray[] selection] { get; set; } | NumSharp.NDArray Item[params NumSharp.Slice[] slice] { get; set; } | NumSharp.NDArray Item[params object[] indicesObjects] { get; set; } | NumSharp.NDArray Item[string slice] { get; set; }",src/NumSharp.Core/Backends/NDArray.Container.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.itemset,numsharp,ndarray,NumSharp-only APIs,itemset,method,False,extension,extension,extension,,NumSharp.NDArray.itemset,"void itemset(NumSharp.Shape shape, object val) | void itemset(int[] shape, T val) | void itemset(int[] shape, object val) | void itemset(ref NumSharp.Shape shape, object val)",src/NumSharp.Core/Manipulation/NDArray.itemset.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.itemset.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.MakeGeneric,numsharp,ndarray,NumSharp-only APIs,MakeGeneric,method,False,extension,extension,extension,,NumSharp.NDArray.MakeGeneric,NumSharp.Generic.NDArray MakeGeneric(),src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.mgrid,numsharp,ndarray,NumSharp-only APIs,mgrid,method,False,extension,extension,extension,,NumSharp.NDArray.mgrid,"System.ValueTuple mgrid(NumSharp.NDArray rhs)",src/NumSharp.Core/Creation/NdArray.Mgrid.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.Mgrid.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.negate,numsharp,ndarray,NumSharp-only APIs,negate,method,False,extension,extension,extension,,NumSharp.NDArray.negate,NumSharp.NDArray negate(),src/NumSharp.Core/Math/NDArray.negate.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.negate.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.negative,numsharp,ndarray,NumSharp-only APIs,negative,method,False,extension,extension,extension,,NumSharp.NDArray.negative,NumSharp.NDArray negative(),src/NumSharp.Core/Math/NDArray.negative.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.negative.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.Normalize,numsharp,ndarray,NumSharp-only APIs,Normalize,method,False,extension,extension,extension,,NumSharp.NDArray.Normalize,void Normalize(),src/NumSharp.Core/Extensions/NdArray.Normalize.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Extensions/NdArray.Normalize.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.order,numsharp,ndarray,NumSharp-only APIs,order,property,False,extension,extension,extension,,NumSharp.NDArray.order,char order { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.positive,numsharp,ndarray,NumSharp-only APIs,positive,method,False,extension,extension,extension,,NumSharp.NDArray.positive,NumSharp.NDArray positive(),src/NumSharp.Core/Math/NDArray.positive.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.positive.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.ReplaceData,numsharp,ndarray,NumSharp-only APIs,ReplaceData,method,False,extension,extension,extension,,NumSharp.NDArray.ReplaceData,"void ReplaceData(NumSharp.Backends.Unmanaged.IArraySlice values) | void ReplaceData(NumSharp.Backends.Unmanaged.IArraySlice values, System.Type dtype) | void ReplaceData(NumSharp.NDArray nd) | void ReplaceData(System.Array values) | void ReplaceData(System.Array values, NumSharp.NPTypeCode typeCode) | void ReplaceData(System.Array values, System.Type dtype)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.reshape_unsafe,numsharp,ndarray,NumSharp-only APIs,reshape_unsafe,method,False,extension,extension,extension,,NumSharp.NDArray.reshape_unsafe,NumSharp.NDArray reshape_unsafe(NumSharp.Shape newshape) | NumSharp.NDArray reshape_unsafe(int[] shape) | NumSharp.NDArray reshape_unsafe(params long[] shape) | NumSharp.NDArray reshape_unsafe(ref NumSharp.Shape newshape),src/NumSharp.Core/Creation/NdArray.ReShape.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.ReShape.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.roll,numsharp,ndarray,NumSharp-only APIs,roll,method,False,extension,extension,extension,,NumSharp.NDArray.roll,"NumSharp.NDArray roll(int shift) | NumSharp.NDArray roll(int shift, int axis) | NumSharp.NDArray roll(long shift) | NumSharp.NDArray roll(long shift, int axis)",src/NumSharp.Core/Manipulation/NDArray.roll.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.roll.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetAtIndex,numsharp,ndarray,NumSharp-only APIs,SetAtIndex,method,False,extension,extension,extension,,NumSharp.NDArray.SetAtIndex,"void SetAtIndex(T value, long index) | void SetAtIndex(object obj, long index)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetBoolean,numsharp,ndarray,NumSharp-only APIs,SetBoolean,method,False,extension,extension,extension,,NumSharp.NDArray.SetBoolean,"void SetBoolean(bool value, int[] indices) | void SetBoolean(bool value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetByte,numsharp,ndarray,NumSharp-only APIs,SetByte,method,False,extension,extension,extension,,NumSharp.NDArray.SetByte,"void SetByte(byte value, int[] indices) | void SetByte(byte value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetChar,numsharp,ndarray,NumSharp-only APIs,SetChar,method,False,extension,extension,extension,,NumSharp.NDArray.SetChar,"void SetChar(char value, int[] indices) | void SetChar(char value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetComplex,numsharp,ndarray,NumSharp-only APIs,SetComplex,method,False,extension,extension,extension,,NumSharp.NDArray.SetComplex,"void SetComplex(System.Numerics.Complex value, int[] indices) | void SetComplex(System.Numerics.Complex value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetData,numsharp,ndarray,NumSharp-only APIs,SetData,method,False,extension,extension,extension,,NumSharp.NDArray.SetData,"void SetData(NumSharp.Backends.Unmanaged.IArraySlice value, int[] indices) | void SetData(NumSharp.Backends.Unmanaged.IArraySlice value, params long[] indices) | void SetData(NumSharp.NDArray value, int[] indices) | void SetData(NumSharp.NDArray value, params long[] indices) | void SetData(object value, int[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetDecimal,numsharp,ndarray,NumSharp-only APIs,SetDecimal,method,False,extension,extension,extension,,NumSharp.NDArray.SetDecimal,"void SetDecimal(decimal value, int[] indices) | void SetDecimal(decimal value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetDouble,numsharp,ndarray,NumSharp-only APIs,SetDouble,method,False,extension,extension,extension,,NumSharp.NDArray.SetDouble,"void SetDouble(double value, int[] indices) | void SetDouble(double value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetHalf,numsharp,ndarray,NumSharp-only APIs,SetHalf,method,False,extension,extension,extension,,NumSharp.NDArray.SetHalf,"void SetHalf(System.Half value, int[] indices) | void SetHalf(System.Half value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetIndices,numsharp,ndarray,NumSharp-only APIs,SetIndices,method,False,extension,extension,extension,,NumSharp.NDArray.SetIndices,"void SetIndices(NumSharp.NDArray values, NumSharp.NDArray[] indices)",src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetInt16,numsharp,ndarray,NumSharp-only APIs,SetInt16,method,False,extension,extension,extension,,NumSharp.NDArray.SetInt16,"void SetInt16(short value, int[] indices) | void SetInt16(short value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetInt32,numsharp,ndarray,NumSharp-only APIs,SetInt32,method,False,extension,extension,extension,,NumSharp.NDArray.SetInt32,"void SetInt32(int value, int[] indices) | void SetInt32(int value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetInt64,numsharp,ndarray,NumSharp-only APIs,SetInt64,method,False,extension,extension,extension,,NumSharp.NDArray.SetInt64,"void SetInt64(long value, int[] indices) | void SetInt64(long value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetSByte,numsharp,ndarray,NumSharp-only APIs,SetSByte,method,False,extension,extension,extension,,NumSharp.NDArray.SetSByte,"void SetSByte(sbyte value, int[] indices) | void SetSByte(sbyte value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetSingle,numsharp,ndarray,NumSharp-only APIs,SetSingle,method,False,extension,extension,extension,,NumSharp.NDArray.SetSingle,"void SetSingle(float value, int[] indices) | void SetSingle(float value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetString,numsharp,ndarray,NumSharp-only APIs,SetString,method,False,extension,extension,extension,,NumSharp.NDArray.SetString,"void SetString(string value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.String.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetStringAt,numsharp,ndarray,NumSharp-only APIs,SetStringAt,method,False,extension,extension,extension,,NumSharp.NDArray.SetStringAt,"void SetStringAt(string value, long offset)",src/NumSharp.Core/Backends/NDArray.String.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetUInt16,numsharp,ndarray,NumSharp-only APIs,SetUInt16,method,False,extension,extension,extension,,NumSharp.NDArray.SetUInt16,"void SetUInt16(ushort value, int[] indices) | void SetUInt16(ushort value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetUInt32,numsharp,ndarray,NumSharp-only APIs,SetUInt32,method,False,extension,extension,extension,,NumSharp.NDArray.SetUInt32,"void SetUInt32(uint value, int[] indices) | void SetUInt32(uint value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetUInt64,numsharp,ndarray,NumSharp-only APIs,SetUInt64,method,False,extension,extension,extension,,NumSharp.NDArray.SetUInt64,"void SetUInt64(ulong value, int[] indices) | void SetUInt64(ulong value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.SetValue,numsharp,ndarray,NumSharp-only APIs,SetValue,method,False,extension,extension,extension,,NumSharp.NDArray.SetValue,"void SetValue(T value, int[] indices) | void SetValue(T value, params long[] indices) | void SetValue(object value, int[] indices) | void SetValue(object value, params long[] indices)",src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.TensorEngine,numsharp,ndarray,NumSharp-only APIs,TensorEngine,property,False,extension,extension,extension,,NumSharp.NDArray.TensorEngine,NumSharp.TensorEngine TensorEngine { get; set; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.ToArray,numsharp,ndarray,NumSharp-only APIs,ToArray,method,False,extension,extension,extension,,NumSharp.NDArray.ToArray,T[] ToArray(),src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.ToJaggedArray,numsharp,ndarray,NumSharp-only APIs,ToJaggedArray,method,False,extension,extension,extension,,NumSharp.NDArray.ToJaggedArray,System.Array ToJaggedArray(),src/NumSharp.Core/Casting/NdArrayToJaggedArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArrayToJaggedArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.ToMuliDimArray,numsharp,ndarray,NumSharp-only APIs,ToMuliDimArray,method,False,extension,extension,extension,,NumSharp.NDArray.ToMuliDimArray,System.Array ToMuliDimArray(),src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.ToString,numsharp,ndarray,NumSharp-only APIs,ToString,method,False,extension,extension,extension,,NumSharp.NDArray.ToString,string ToString() | string ToString(bool flat),src/NumSharp.Core/Casting/NdArray.ToString.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArray.ToString.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.typecode,numsharp,ndarray,NumSharp-only APIs,typecode,property,False,extension,extension,extension,,NumSharp.NDArray.typecode,NumSharp.NPTypeCode typecode { get; },src/NumSharp.Core/Backends/NDArray.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.unique,numsharp,ndarray,NumSharp-only APIs,unique,method,False,extension,extension,extension,,NumSharp.NDArray.unique,"NumSharp.NDArray unique() | NumSharp.NDArray[] unique(bool return_index, bool return_inverse = false, bool return_counts = false, int? axis = null, bool equal_nan = true)",src/NumSharp.Core/Manipulation/NDArray.unique.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.unique.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.Unsafe,numsharp,ndarray,NumSharp-only APIs,Unsafe,property,False,extension,extension,extension,,NumSharp.NDArray.Unsafe,NumSharp.NDArray+_Unsafe Unsafe { get; },src/NumSharp.Core/Backends/NDArray.Unmanaged.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Unmanaged.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.ndarray.vstack,numsharp,ndarray,NumSharp-only APIs,vstack,method,False,extension,extension,extension,,NumSharp.NDArray.vstack,NumSharp.NDArray vstack(params NumSharp.NDArray[] tup),src/NumSharp.Core/Creation/NdArray.VStack.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.VStack.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.are_broadcastable,numsharp,np,NumSharp-only APIs,are_broadcastable,method,False,extension,extension,extension,,NumSharp.np.are_broadcastable,"bool are_broadcastable(NumSharp.NDArray lhs, NumSharp.NDArray rhs) | bool are_broadcastable(long[] shape1, long[] shape2) | bool are_broadcastable(params NumSharp.NDArray[] ndArrays) | bool are_broadcastable(params NumSharp.Shape[] shapes) | bool are_broadcastable(params int[][] shapes)",src/NumSharp.Core/Creation/np.are_broadcastable.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.are_broadcastable.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.asscalar,numsharp,np,NumSharp-only APIs,asscalar,method,False,extension,extension,extension,,NumSharp.np.asscalar,T asscalar(NumSharp.Backends.Unmanaged.ArraySlice arr) | T asscalar(NumSharp.Backends.Unmanaged.IArraySlice arr) | T asscalar(NumSharp.NDArray nd) | T asscalar(System.Array arr) | object asscalar(NumSharp.NDArray nd) | object asscalar(System.Array arr),src/NumSharp.Core/Manipulation/np.asscalar.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.asscalar.cs,True,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.average_returned,numsharp,np,NumSharp-only APIs,average_returned,method,False,extension,extension,extension,,NumSharp.np.average_returned,"System.ValueTuple average_returned(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray weights = null, bool keepdims = false) | System.ValueTuple average_returned(NumSharp.NDArray a, int[] axis, NumSharp.NDArray weights = null, bool keepdims = false)",src/NumSharp.Core/Statistics/np.average.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.average.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.BackendEngine,numsharp,np,NumSharp-only APIs,BackendEngine,property,False,extension,extension,extension,,NumSharp.np.BackendEngine,NumSharp.BackendType BackendEngine { get; set; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.bool8,numsharp,np,NumSharp-only APIs,bool8,field,False,extension,extension,extension,,NumSharp.np.bool8,readonly System.Type bool8,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.chars,numsharp,np,NumSharp-only APIs,chars,property,False,extension,extension,extension,,NumSharp.np.chars,System.Type chars { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.common_type_code,numsharp,np,NumSharp-only APIs,common_type_code,method,False,extension,extension,extension,,NumSharp.np.common_type_code,NumSharp.NPTypeCode common_type_code(params NumSharp.NDArray[] arrays) | NumSharp.NPTypeCode common_type_code(params NumSharp.NPTypeCode[] types),src/NumSharp.Core/Logic/np.common_type.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.common_type.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.complex_,numsharp,np,NumSharp-only APIs,complex_,field,False,extension,extension,extension,,NumSharp.np.complex_,readonly System.Type complex_,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.decimal,numsharp,np,NumSharp-only APIs,decimal,field,False,extension,extension,extension,,NumSharp.np.decimal,readonly System.Type decimal,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.evaluate,numsharp,np,NumSharp-only APIs,evaluate,method,False,extension,extension,extension,,NumSharp.np.evaluate,"NumSharp.NDArray evaluate(NumSharp.Backends.Iteration.NDExpr expr, NumSharp.NDArray out = null) | NumSharp.NDArray evaluate(NumSharp.Backends.Iteration.NDExpr expr, NumSharp.NDArray[] operands, NumSharp.NDArray out = null)",src/NumSharp.Core/APIs/np.evaluate.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.evaluate.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.find_common_type,numsharp,np,NumSharp-only APIs,find_common_type,method,False,extension,extension,extension,,NumSharp.np.find_common_type,"NumSharp.NPTypeCode find_common_type(NumSharp.NPTypeCode[] array_types, NumSharp.NPTypeCode[] scalar_types) | NumSharp.NPTypeCode find_common_type(NumSharp.NPTypeCode[] array_types, System.Type[] scalar_types) | NumSharp.NPTypeCode find_common_type(System.Type[] array_types) | NumSharp.NPTypeCode find_common_type(System.Type[] array_types, NumSharp.NPTypeCode[] scalar_types) | NumSharp.NPTypeCode find_common_type(System.Type[] array_types, System.Type[] scalar_types) | NumSharp.NPTypeCode find_common_type(params string[] involvedTypes) | NumSharp.NPTypeCode find_common_type(string[] array_types, string[] scalar_types)",src/NumSharp.Core/Logic/np.find_common_type.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.find_common_type.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.float_,numsharp,np,NumSharp-only APIs,float_,field,False,extension,extension,extension,,NumSharp.np.float_,readonly System.Type float_,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.indices_sparse,numsharp,np,NumSharp-only APIs,indices_sparse,method,False,extension,extension,extension,,NumSharp.np.indices_sparse,"NumSharp.NDArray[] indices_sparse(int[] dimensions, NumSharp.NPTypeCode dtype = NumSharp.NPTypeCode.Int64)",src/NumSharp.Core/Indexing/np.indices.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.indices.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.Inf,numsharp,np,NumSharp-only APIs,Inf,property,False,extension,extension,extension,,NumSharp.np.Inf,double Inf { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.Infinity,numsharp,np,NumSharp-only APIs,Infinity,property,False,extension,extension,extension,,NumSharp.np.Infinity,double Infinity { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.infinity,numsharp,np,NumSharp-only APIs,infinity,property,False,extension,extension,extension,,NumSharp.np.infinity,double infinity { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.infty,numsharp,np,NumSharp-only APIs,infty,property,False,extension,extension,extension,,NumSharp.np.infty,double infty { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.int0,numsharp,np,NumSharp-only APIs,int0,field,False,extension,extension,extension,,NumSharp.np.int0,readonly System.Type int0,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.issctype,numsharp,np,NumSharp-only APIs,issctype,method,False,extension,extension,extension,,NumSharp.np.issctype,bool issctype(object rep),src/NumSharp.Core/Logic/np.type_checks.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.issubsctype,numsharp,np,NumSharp-only APIs,issubsctype,method,False,extension,extension,extension,,NumSharp.np.issubsctype,"bool issubsctype(NumSharp.NPTypeCode arg1, NumSharp.NPTypeCode arg2)",src/NumSharp.Core/Logic/np.type_checks.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.load_npy,numsharp,np,NumSharp-only APIs,load_npy,method,False,extension,extension,extension,,NumSharp.np.load_npy,"NumSharp.NDArray load_npy(System.IO.Stream file, bool allow_pickle = false, long max_header_size = 10000) | NumSharp.NDArray load_npy(byte[] bytes, bool allow_pickle = false, long max_header_size = 10000) | NumSharp.NDArray load_npy(string file, bool allow_pickle = false, long max_header_size = 10000)",src/NumSharp.Core/APIs/np.load.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.load.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.load_npz,numsharp,np,NumSharp-only APIs,load_npz,method,False,extension,extension,extension,,NumSharp.np.load_npz,"NumSharp.IO.NpzFile load_npz(System.IO.Stream file, bool own_stream = false, bool allow_pickle = false, long max_header_size = 10000) | NumSharp.IO.NpzFile load_npz(byte[] bytes, bool allow_pickle = false, long max_header_size = 10000) | NumSharp.IO.NpzFile load_npz(string file, bool allow_pickle = false, long max_header_size = 10000)",src/NumSharp.Core/APIs/np.load.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.load.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.maximum_sctype,numsharp,np,NumSharp-only APIs,maximum_sctype,method,False,extension,extension,extension,,NumSharp.np.maximum_sctype,NumSharp.NPTypeCode maximum_sctype(NumSharp.NPTypeCode t),src/NumSharp.Core/Logic/np.type_checks.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.multithreading,numsharp,np,NumSharp-only APIs,multithreading,method,False,extension,extension,extension,,NumSharp.np.multithreading,"void multithreading(bool enabled, int max_threads = 8)",src/NumSharp.Core/APIs/np.multithreading.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.multithreading.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.NAN,numsharp,np,NumSharp-only APIs,NAN,property,False,extension,extension,extension,,NumSharp.np.NAN,double NAN { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.NaN,numsharp,np,NumSharp-only APIs,NaN,property,False,extension,extension,extension,,NumSharp.np.NaN,double NaN { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.ndarray,numsharp,np,NumSharp-only APIs,ndarray,method,False,extension,extension,extension,,NumSharp.np.ndarray,"NumSharp.NDArray ndarray(NumSharp.Shape shape, System.Type dtype = null, System.Array buffer = null, char order = 'F')",src/NumSharp.Core/APIs/np.array_manipulation.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array_manipulation.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.NINF,numsharp,np,NumSharp-only APIs,NINF,property,False,extension,extension,extension,,NumSharp.np.NINF,double NINF { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.PINF,numsharp,np,NumSharp-only APIs,PINF,property,False,extension,extension,extension,,NumSharp.np.PINF,double PINF { get; },src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.save_version,numsharp,np,NumSharp-only APIs,save_version,method,False,extension,extension,extension,,NumSharp.np.save_version,"void save_version(System.IO.Stream file, NumSharp.NDArray arr, NumSharp.IO.NpyFormat+FormatVersion? version, bool allow_pickle = true)",src/NumSharp.Core/APIs/np.save.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.sbyte,numsharp,np,NumSharp-only APIs,sbyte,field,False,extension,extension,extension,,NumSharp.np.sbyte,readonly System.Type sbyte,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.sctype2char,numsharp,np,NumSharp-only APIs,sctype2char,method,False,extension,extension,extension,,NumSharp.np.sctype2char,char sctype2char(NumSharp.NPTypeCode sctype),src/NumSharp.Core/Logic/np.type_checks.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.np.uint0,numsharp,np,NumSharp-only APIs,uint0,field,False,extension,extension,extension,,NumSharp.np.uint0,readonly System.Type uint0,src/NumSharp.Core/APIs/np.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.random.bernoulli,numsharp,random,NumSharp-only APIs,bernoulli,method,False,extension,extension,extension,,NumSharp.NumPyRandom.bernoulli,"NumSharp.NDArray bernoulli(double p) | NumSharp.NDArray bernoulli(double p, NumSharp.Shape size)",src/NumSharp.Core/RandomSampling/np.random.bernoulli.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.bernoulli.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., +numsharp.random.Seed,numsharp,random,NumSharp-only APIs,Seed,property,False,extension,extension,extension,,NumSharp.NumPyRandom.Seed,int Seed { get; set; },src/NumSharp.Core/RandomSampling/np.random.cs,https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs,False,NumSharp-only public API with no matching export on the compared NumPy surface., diff --git a/coverage/generated/coverage.json b/coverage/generated/coverage.json new file mode 100644 index 000000000..c93a3e661 --- /dev/null +++ b/coverage/generated/coverage.json @@ -0,0 +1,19979 @@ +{ + "schema_version": 1, + "generator_version": "1.1.0", + "numpy_version": "2.4.2", + "numsharp_assembly_version": "0.60.0.0", + "methodology": { + "headline": "Available default-scope APIs divided by all default-scope NumPy APIs.", + "default_scope": "Top-level NumPy callables; ndarray public methods and properties; callable exports of numpy.random, numpy.linalg, and numpy.fft.", + "availability_note": "Compiled API availability is distinct from fully verified behavioral parity." + }, + "summary": { + "default_scope": { + "total": 560, + "available": 338, + "partial": 3, + "unsupported": 0, + "missing": 219, + "exact": 301, + "alias": 40, + "coverage_percent": 60.4, + "addressed_percent": 60.9 + }, + "by_surface": { + "fft": { + "total": 18, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 18, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "linalg": { + "total": 31, + "available": 6, + "partial": 0, + "unsupported": 0, + "missing": 25, + "exact": 0, + "alias": 6, + "coverage_percent": 19.4, + "addressed_percent": 19.4 + }, + "ndarray": { + "total": 70, + "available": 50, + "partial": 1, + "unsupported": 0, + "missing": 19, + "exact": 35, + "alias": 16, + "coverage_percent": 71.4, + "addressed_percent": 72.9 + }, + "np": { + "total": 390, + "available": 234, + "partial": 1, + "unsupported": 0, + "missing": 155, + "exact": 220, + "alias": 15, + "coverage_percent": 60.0, + "addressed_percent": 60.3 + }, + "random": { + "total": 51, + "available": 48, + "partial": 1, + "unsupported": 0, + "missing": 2, + "exact": 46, + "alias": 3, + "coverage_percent": 94.1, + "addressed_percent": 96.1 + } + }, + "by_category": { + "Array attributes": { + "total": 17, + "available": 10, + "partial": 1, + "unsupported": 0, + "missing": 6, + "exact": 9, + "alias": 2, + "coverage_percent": 58.8, + "addressed_percent": 64.7 + }, + "Array creation": { + "total": 37, + "available": 24, + "partial": 0, + "unsupported": 0, + "missing": 13, + "exact": 24, + "alias": 0, + "coverage_percent": 64.9, + "addressed_percent": 64.9 + }, + "Array metadata & memory": { + "total": 5, + "available": 1, + "partial": 0, + "unsupported": 0, + "missing": 4, + "exact": 1, + "alias": 0, + "coverage_percent": 20.0, + "addressed_percent": 20.0 + }, + "Array methods": { + "total": 34, + "available": 23, + "partial": 0, + "unsupported": 0, + "missing": 11, + "exact": 14, + "alias": 9, + "coverage_percent": 67.6, + "addressed_percent": 67.6 + }, + "Date & time": { + "total": 6, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 6, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Dtype & promotion": { + "total": 9, + "available": 9, + "partial": 0, + "unsupported": 0, + "missing": 0, + "exact": 8, + "alias": 1, + "coverage_percent": 100.0, + "addressed_percent": 100.0 + }, + "Floating-point handling": { + "total": 7, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 7, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Fourier transforms": { + "total": 18, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 18, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Indexing & selection": { + "total": 22, + "available": 9, + "partial": 0, + "unsupported": 0, + "missing": 13, + "exact": 9, + "alias": 0, + "coverage_percent": 40.9, + "addressed_percent": 40.9 + }, + "Input & output": { + "total": 5, + "available": 4, + "partial": 0, + "unsupported": 0, + "missing": 1, + "exact": 4, + "alias": 0, + "coverage_percent": 80.0, + "addressed_percent": 80.0 + }, + "Linear algebra": { + "total": 43, + "available": 7, + "partial": 0, + "unsupported": 0, + "missing": 36, + "exact": 1, + "alias": 6, + "coverage_percent": 16.3, + "addressed_percent": 16.3 + }, + "Logic & comparison": { + "total": 29, + "available": 25, + "partial": 0, + "unsupported": 0, + "missing": 4, + "exact": 25, + "alias": 0, + "coverage_percent": 86.2, + "addressed_percent": 86.2 + }, + "Math": { + "total": 112, + "available": 69, + "partial": 0, + "unsupported": 0, + "missing": 43, + "exact": 59, + "alias": 10, + "coverage_percent": 61.6, + "addressed_percent": 61.6 + }, + "Polynomials": { + "total": 10, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 10, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Random": { + "total": 51, + "available": 48, + "partial": 1, + "unsupported": 0, + "missing": 2, + "exact": 46, + "alias": 3, + "coverage_percent": 94.1, + "addressed_percent": 96.1 + }, + "Reductions": { + "total": 50, + "available": 46, + "partial": 0, + "unsupported": 0, + "missing": 4, + "exact": 41, + "alias": 5, + "coverage_percent": 92.0, + "addressed_percent": 92.0 + }, + "Runtime & diagnostics": { + "total": 5, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 5, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Set operations": { + "total": 10, + "available": 1, + "partial": 0, + "unsupported": 0, + "missing": 9, + "exact": 1, + "alias": 0, + "coverage_percent": 10.0, + "addressed_percent": 10.0 + }, + "Shape manipulation": { + "total": 49, + "available": 44, + "partial": 1, + "unsupported": 0, + "missing": 4, + "exact": 43, + "alias": 2, + "coverage_percent": 89.8, + "addressed_percent": 91.8 + }, + "Sorting & searching": { + "total": 16, + "available": 10, + "partial": 0, + "unsupported": 0, + "missing": 6, + "exact": 8, + "alias": 2, + "coverage_percent": 62.5, + "addressed_percent": 62.5 + }, + "Statistics & histograms": { + "total": 9, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 9, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Text & formatting": { + "total": 11, + "available": 8, + "partial": 0, + "unsupported": 0, + "missing": 3, + "exact": 8, + "alias": 0, + "coverage_percent": 72.7, + "addressed_percent": 72.7 + }, + "Window functions": { + "total": 5, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 5, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + } + }, + "all_numpy_exports": 677, + "numsharp_extensions": 117, + "catalog_rows": 794 + }, + "rows": [ + { + "id": "numpy.fft.fft", + "origin": "numpy", + "surface": "fft", + "name": "fft", + "kind": "function", + "numpy_signature": "(a, n=None, axis=-1, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.fft.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.fft2", + "origin": "numpy", + "surface": "fft", + "name": "fft2", + "kind": "function", + "numpy_signature": "(a, s=None, axes=(-2, -1), norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.fft2.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.fftfreq", + "origin": "numpy", + "surface": "fft", + "name": "fftfreq", + "kind": "function", + "numpy_signature": "(n, d=1.0, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.fftfreq.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.fftn", + "origin": "numpy", + "surface": "fft", + "name": "fftn", + "kind": "function", + "numpy_signature": "(a, s=None, axes=None, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.fftn.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.fftshift", + "origin": "numpy", + "surface": "fft", + "name": "fftshift", + "kind": "function", + "numpy_signature": "(x, axes=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.fftshift.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.hfft", + "origin": "numpy", + "surface": "fft", + "name": "hfft", + "kind": "function", + "numpy_signature": "(a, n=None, axis=-1, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.hfft.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.ifft", + "origin": "numpy", + "surface": "fft", + "name": "ifft", + "kind": "function", + "numpy_signature": "(a, n=None, axis=-1, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.ifft2", + "origin": "numpy", + "surface": "fft", + "name": "ifft2", + "kind": "function", + "numpy_signature": "(a, s=None, axes=(-2, -1), norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft2.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.ifftn", + "origin": "numpy", + "surface": "fft", + "name": "ifftn", + "kind": "function", + "numpy_signature": "(a, s=None, axes=None, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftn.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.ifftshift", + "origin": "numpy", + "surface": "fft", + "name": "ifftshift", + "kind": "function", + "numpy_signature": "(x, axes=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftshift.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.ihfft", + "origin": "numpy", + "surface": "fft", + "name": "ihfft", + "kind": "function", + "numpy_signature": "(a, n=None, axis=-1, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.ihfft.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.irfft", + "origin": "numpy", + "surface": "fft", + "name": "irfft", + "kind": "function", + "numpy_signature": "(a, n=None, axis=-1, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.irfft2", + "origin": "numpy", + "surface": "fft", + "name": "irfft2", + "kind": "function", + "numpy_signature": "(a, s=None, axes=(-2, -1), norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft2.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.irfftn", + "origin": "numpy", + "surface": "fft", + "name": "irfftn", + "kind": "function", + "numpy_signature": "(a, s=None, axes=None, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.irfftn.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.rfft", + "origin": "numpy", + "surface": "fft", + "name": "rfft", + "kind": "function", + "numpy_signature": "(a, n=None, axis=-1, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.rfft2", + "origin": "numpy", + "surface": "fft", + "name": "rfft2", + "kind": "function", + "numpy_signature": "(a, s=None, axes=(-2, -1), norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft2.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.rfftfreq", + "origin": "numpy", + "surface": "fft", + "name": "rfftfreq", + "kind": "function", + "numpy_signature": "(n, d=1.0, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.rfftfreq.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft.rfftn", + "origin": "numpy", + "surface": "fft", + "name": "rfftn", + "kind": "function", + "numpy_signature": "(a, s=None, axes=None, norm=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fft.rfftn.html", + "in_default_scope": true, + "category": "Fourier transforms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.cholesky", + "origin": "numpy", + "surface": "linalg", + "name": "cholesky", + "kind": "function", + "numpy_signature": "(a, /, *, upper=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.cholesky.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.cond", + "origin": "numpy", + "surface": "linalg", + "name": "cond", + "kind": "function", + "numpy_signature": "(x, p=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.cond.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.cross", + "origin": "numpy", + "surface": "linalg", + "name": "cross", + "kind": "function", + "numpy_signature": "(x1, x2, /, *, axis=-1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.cross.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.det", + "origin": "numpy", + "surface": "linalg", + "name": "det", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.det.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.diagonal", + "origin": "numpy", + "surface": "linalg", + "name": "diagonal", + "kind": "function", + "numpy_signature": "(x, /, *, offset=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.diagonal.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.diagonal", + "numsharp_signatures": [ + "NumSharp.NDArray diagonal(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.diagonal.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.diagonal.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy linalg namespace function." + }, + { + "id": "numpy.linalg.eig", + "origin": "numpy", + "surface": "linalg", + "name": "eig", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.eigh", + "origin": "numpy", + "surface": "linalg", + "name": "eigh", + "kind": "function", + "numpy_signature": "(a, UPLO='L')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigh.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.eigvals", + "origin": "numpy", + "surface": "linalg", + "name": "eigvals", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigvals.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.eigvalsh", + "origin": "numpy", + "surface": "linalg", + "name": "eigvalsh", + "kind": "function", + "numpy_signature": "(a, UPLO='L')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigvalsh.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.inv", + "origin": "numpy", + "surface": "linalg", + "name": "inv", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.inv.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.LinAlgError", + "origin": "numpy", + "surface": "linalg", + "name": "LinAlgError", + "kind": "class", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.LinAlgError.html", + "in_default_scope": false, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.lstsq", + "origin": "numpy", + "surface": "linalg", + "name": "lstsq", + "kind": "function", + "numpy_signature": "(a, b, rcond=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.lstsq.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.matmul", + "origin": "numpy", + "surface": "linalg", + "name": "matmul", + "kind": "function", + "numpy_signature": "(x1, x2, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.matmul.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.matmul", + "numsharp_signatures": [ + "NumSharp.NDArray matmul(NumSharp.NDArray x1, NumSharp.NDArray x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/LinearAlgebra/np.matmul.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.matmul.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy linalg namespace function." + }, + { + "id": "numpy.linalg.matrix_norm", + "origin": "numpy", + "surface": "linalg", + "name": "matrix_norm", + "kind": "function", + "numpy_signature": "(x, /, *, keepdims=False, ord='fro')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_norm.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.matrix_power", + "origin": "numpy", + "surface": "linalg", + "name": "matrix_power", + "kind": "function", + "numpy_signature": "(a, n)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_power.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.matrix_power", + "numsharp_signatures": [ + "NumSharp.NDArray matrix_power(int power)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/LinearAlgebra/NDArray.matrix_power.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/NDArray.matrix_power.cs" + ], + "notes": "Matrix power is available as an NDArray instance method rather than under an linalg namespace." + }, + { + "id": "numpy.linalg.matrix_rank", + "origin": "numpy", + "surface": "linalg", + "name": "matrix_rank", + "kind": "function", + "numpy_signature": "(A, tol=None, hermitian=False, *, rtol=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_rank.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.matrix_transpose", + "origin": "numpy", + "surface": "linalg", + "name": "matrix_transpose", + "kind": "function", + "numpy_signature": "(x, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_transpose.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.matrix_transpose", + "numsharp_signatures": [ + "NumSharp.NDArray matrix_transpose(NumSharp.NDArray x)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.matrix_transpose.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.matrix_transpose.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy linalg namespace function." + }, + { + "id": "numpy.linalg.multi_dot", + "origin": "numpy", + "surface": "linalg", + "name": "multi_dot", + "kind": "function", + "numpy_signature": "(arrays, *, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.multi_dot.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.norm", + "origin": "numpy", + "surface": "linalg", + "name": "norm", + "kind": "function", + "numpy_signature": "(x, ord=None, axis=None, keepdims=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.outer", + "origin": "numpy", + "surface": "linalg", + "name": "outer", + "kind": "function", + "numpy_signature": "(x1, x2, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.outer.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.outer", + "numsharp_signatures": [ + "NumSharp.NDArray outer(NumSharp.NDArray a, NumSharp.NDArray b)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/LinearAlgebra/np.outer.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.outer.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy linalg namespace function." + }, + { + "id": "numpy.linalg.pinv", + "origin": "numpy", + "surface": "linalg", + "name": "pinv", + "kind": "function", + "numpy_signature": "(a, rcond=None, hermitian=False, *, rtol=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.pinv.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.qr", + "origin": "numpy", + "surface": "linalg", + "name": "qr", + "kind": "function", + "numpy_signature": "(a, mode='reduced')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.qr.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.slogdet", + "origin": "numpy", + "surface": "linalg", + "name": "slogdet", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.slogdet.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.solve", + "origin": "numpy", + "surface": "linalg", + "name": "solve", + "kind": "function", + "numpy_signature": "(a, b)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.svd", + "origin": "numpy", + "surface": "linalg", + "name": "svd", + "kind": "function", + "numpy_signature": "(a, full_matrices=True, compute_uv=True, hermitian=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.svd.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.svdvals", + "origin": "numpy", + "surface": "linalg", + "name": "svdvals", + "kind": "function", + "numpy_signature": "(x, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.svdvals.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.tensordot", + "origin": "numpy", + "surface": "linalg", + "name": "tensordot", + "kind": "function", + "numpy_signature": "(x1, x2, /, *, axes=2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensordot.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.tensorinv", + "origin": "numpy", + "surface": "linalg", + "name": "tensorinv", + "kind": "function", + "numpy_signature": "(a, ind=2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensorinv.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.tensorsolve", + "origin": "numpy", + "surface": "linalg", + "name": "tensorsolve", + "kind": "function", + "numpy_signature": "(a, b, axes=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensorsolve.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.trace", + "origin": "numpy", + "surface": "linalg", + "name": "trace", + "kind": "function", + "numpy_signature": "(x, /, *, offset=0, dtype=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.trace.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.trace", + "numsharp_signatures": [ + "NumSharp.NDArray trace(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1, System.Type dtype = null, NumSharp.NDArray out = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.trace.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.trace.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy linalg namespace function." + }, + { + "id": "numpy.linalg.vecdot", + "origin": "numpy", + "surface": "linalg", + "name": "vecdot", + "kind": "function", + "numpy_signature": "(x1, x2, /, *, axis=-1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.vecdot.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg.vector_norm", + "origin": "numpy", + "surface": "linalg", + "name": "vector_norm", + "kind": "function", + "numpy_signature": "(x, /, *, axis=None, keepdims=False, ord=2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linalg.vector_norm.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.all", + "origin": "numpy", + "surface": "ndarray", + "name": "all", + "kind": "method", + "numpy_signature": "(self, /, axis=None, out=None, keepdims=False, *, where=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.all.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.all", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray all(NumSharp.NDArray nd, bool keepdims)", + "NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int axis, bool keepdims = false)", + "NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int[] axis, bool keepdims = false)", + "NumSharp.NDArray all(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null)", + "NumSharp.NDArray all(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null)", + "bool all(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.all.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.all.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.any", + "origin": "numpy", + "surface": "ndarray", + "name": "any", + "kind": "method", + "numpy_signature": "(self, /, axis=None, out=None, keepdims=False, *, where=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.any.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.any", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray any(NumSharp.NDArray nd, bool keepdims)", + "NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int axis, bool keepdims = false)", + "NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int[] axis, bool keepdims = false)", + "NumSharp.NDArray any(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null)", + "NumSharp.NDArray any(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null)", + "bool any(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.any.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.any.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.argmax", + "origin": "numpy", + "surface": "ndarray", + "name": "argmax", + "kind": "method", + "numpy_signature": "(self, /, axis=None, out=None, *, keepdims=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argmax.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.argmax", + "numsharp_signatures": [ + "NumSharp.NDArray argmax(int axis, bool keepdims = false)", + "long argmax()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.argmax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.argmax.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.argmin", + "origin": "numpy", + "surface": "ndarray", + "name": "argmin", + "kind": "method", + "numpy_signature": "(self, /, axis=None, out=None, *, keepdims=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argmin.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.argmin", + "numsharp_signatures": [ + "NumSharp.NDArray argmin(int axis, bool keepdims = false)", + "long argmin()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.argmin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.argmin.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.argpartition", + "origin": "numpy", + "surface": "ndarray", + "name": "argpartition", + "kind": "method", + "numpy_signature": "(self, kth, /, axis=-1, kind='introselect', order=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argpartition.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.argsort", + "origin": "numpy", + "surface": "ndarray", + "name": "argsort", + "kind": "method", + "numpy_signature": "(self, /, axis=-1, kind=None, order=None, *, stable=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argsort.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.argsort", + "numsharp_signatures": [ + "NumSharp.NDArray argsort(int axis = -1)", + "NumSharp.NDArray argsort(int? axis = -1)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/ndarray.argsort.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/ndarray.argsort.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.astype", + "origin": "numpy", + "surface": "ndarray", + "name": "astype", + "kind": "method", + "numpy_signature": "(self, /, dtype, order='K', casting='unsafe', subok=True, copy=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.astype.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.astype", + "numsharp_signatures": [ + "NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy = true)", + "NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy, char order, string casting = \"unsafe\")", + "NumSharp.NDArray astype(System.Type dtype, bool copy = true)", + "NumSharp.NDArray astype(System.Type dtype, bool copy, char order, string casting = \"unsafe\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.base", + "origin": "numpy", + "surface": "ndarray", + "name": "base", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.base.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.base", + "numsharp_signatures": [ + "NumSharp.NDArray base { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.byteswap", + "origin": "numpy", + "surface": "ndarray", + "name": "byteswap", + "kind": "method", + "numpy_signature": "(self, /, inplace=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.byteswap.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.choose", + "origin": "numpy", + "surface": "ndarray", + "name": "choose", + "kind": "method", + "numpy_signature": "(self, /, choices, out=None, mode='raise')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.choose.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.clip", + "origin": "numpy", + "surface": "ndarray", + "name": "clip", + "kind": "method", + "numpy_signature": "(self, /, min=None, max=None, out=None, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.clip.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.clip", + "numsharp_signatures": [ + "NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min = null, NumSharp.NDArray a_max = null, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, NumSharp.NDArray min = null, NumSharp.NDArray max = null)", + "NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min, NumSharp.NDArray a_max, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.clip.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.clip.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.compress", + "origin": "numpy", + "surface": "ndarray", + "name": "compress", + "kind": "method", + "numpy_signature": "(self, /, condition, axis=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.compress.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.compress", + "numsharp_signatures": [ + "NumSharp.NDArray compress(NumSharp.NDArray condition, NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.compress.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.compress.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.conj", + "origin": "numpy", + "surface": "ndarray", + "name": "conj", + "kind": "method", + "numpy_signature": "(self, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.conj.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.conjugate", + "origin": "numpy", + "surface": "ndarray", + "name": "conjugate", + "kind": "method", + "numpy_signature": "(self, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.conjugate.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.copy", + "origin": "numpy", + "surface": "ndarray", + "name": "copy", + "kind": "method", + "numpy_signature": "(self, /, order='C')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.copy.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.copy", + "numsharp_signatures": [ + "NumSharp.NDArray copy(char order = 'C')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NDArray.Copy.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NDArray.Copy.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.ctypes", + "origin": "numpy", + "surface": "ndarray", + "name": "ctypes", + "kind": "property", + "numpy_signature": "An object to simplify the interaction of the array with the ctypes", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ctypes.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.cumprod", + "origin": "numpy", + "surface": "ndarray", + "name": "cumprod", + "kind": "method", + "numpy_signature": "(self, /, axis=None, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.cumprod.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cumprod", + "numsharp_signatures": [ + "NumSharp.NDArray cumprod(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cumprod.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumprod.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.cumsum", + "origin": "numpy", + "surface": "ndarray", + "name": "cumsum", + "kind": "method", + "numpy_signature": "(self, /, axis=None, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.cumsum.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.cumsum", + "numsharp_signatures": [ + "NumSharp.NDArray cumsum(int? axis = null, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/NDArray.cumsum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.cumsum.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.data", + "origin": "numpy", + "surface": "ndarray", + "name": "data", + "kind": "property", + "numpy_signature": "Python buffer object pointing to the start of the array's data.", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.data.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "alias", + "support": "partial", + "status": "partial", + "numsharp_target": "NumSharp.NDArray.Data", + "numsharp_signatures": [ + "NumSharp.Backends.Unmanaged.ArraySlice Data()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp exposes typed unmanaged data through the generic Data() method rather than NumPy's buffer-view property. Data() returns a typed NumSharp ArraySlice and is not NumPy's Python buffer object." + }, + { + "id": "numpy.ndarray.device", + "origin": "numpy", + "surface": "ndarray", + "name": "device", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.device.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.diagonal", + "origin": "numpy", + "surface": "ndarray", + "name": "diagonal", + "kind": "method", + "numpy_signature": "(self, /, offset=0, axis1=0, axis2=1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.diagonal.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.diagonal", + "numsharp_signatures": [ + "NumSharp.NDArray diagonal(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.diagonal.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.diagonal.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.dot", + "origin": "numpy", + "surface": "ndarray", + "name": "dot", + "kind": "method", + "numpy_signature": "(self, other, /, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dot.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.dot", + "numsharp_signatures": [ + "NumSharp.NDArray dot(NumSharp.NDArray b)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/LinearAlgebra/NDArray.dot.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/NDArray.dot.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.dtype", + "origin": "numpy", + "surface": "ndarray", + "name": "dtype", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dtype.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.dtype", + "numsharp_signatures": [ + "System.Type dtype { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.dump", + "origin": "numpy", + "surface": "ndarray", + "name": "dump", + "kind": "method", + "numpy_signature": "(self, /, file)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dump.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.dumps", + "origin": "numpy", + "surface": "ndarray", + "name": "dumps", + "kind": "method", + "numpy_signature": "(self, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.dumps.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.fill", + "origin": "numpy", + "surface": "ndarray", + "name": "fill", + "kind": "method", + "numpy_signature": "(self, /, value)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.fill.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.flags", + "origin": "numpy", + "surface": "ndarray", + "name": "flags", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.flat", + "origin": "numpy", + "surface": "ndarray", + "name": "flat", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flat.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.flat", + "numsharp_signatures": [ + "NumSharp.NDArray flat { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.flatten", + "origin": "numpy", + "surface": "ndarray", + "name": "flatten", + "kind": "method", + "numpy_signature": "(self, /, order='C')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flatten.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.flatten", + "numsharp_signatures": [ + "NumSharp.NDArray flatten(char order = 'C')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.flatten.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.flatten.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.getfield", + "origin": "numpy", + "surface": "ndarray", + "name": "getfield", + "kind": "method", + "numpy_signature": "(self, /, dtype, offset=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.getfield.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.imag", + "origin": "numpy", + "surface": "ndarray", + "name": "imag", + "kind": "property", + "numpy_signature": "The imaginary part of the array.", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.imag.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.item", + "origin": "numpy", + "surface": "ndarray", + "name": "item", + "kind": "method", + "numpy_signature": "(self, /, *args)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.item.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.item", + "numsharp_signatures": [ + "T item()", + "T item(long i, long j)", + "T item(long i, long j, long k)", + "T item(long index)", + "T item(params long[] indices)", + "object item()", + "object item(long i, long j)", + "object item(long i, long j, long k)", + "object item(long index)", + "object item(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.item.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.item.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.itemsize", + "origin": "numpy", + "surface": "ndarray", + "name": "itemsize", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.itemsize.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.dtypesize", + "numsharp_signatures": [ + "int dtypesize { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "The element size is exposed as dtypesize in NumSharp." + }, + { + "id": "numpy.ndarray.max", + "origin": "numpy", + "surface": "ndarray", + "name": "max", + "kind": "method", + "numpy_signature": "(self, /, axis=None, out=None, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.max.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.max", + "numsharp_signatures": [ + "NumSharp.NDArray max(System.Type dtype = null)", + "NumSharp.NDArray max(int axis, bool keepdims = false, System.Type dtype = null)", + "T max()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.amax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amax.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.mean", + "origin": "numpy", + "surface": "ndarray", + "name": "mean", + "kind": "method", + "numpy_signature": "(self, /, axis=None, dtype=None, out=None, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.mean.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.mean", + "numsharp_signatures": [ + "NumSharp.NDArray mean()", + "NumSharp.NDArray mean(int axis)", + "NumSharp.NDArray mean(int axis, NumSharp.NPTypeCode type, bool keepdims = false)", + "NumSharp.NDArray mean(int axis, System.Type type, bool keepdims = false)", + "NumSharp.NDArray mean(int axis, bool keepdims)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.mean.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.mean.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.min", + "origin": "numpy", + "surface": "ndarray", + "name": "min", + "kind": "method", + "numpy_signature": "(self, /, axis=None, out=None, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.min.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.min", + "numsharp_signatures": [ + "NumSharp.NDArray min(System.Type dtype = null)", + "NumSharp.NDArray min(int axis, bool keepdims = false, System.Type dtype = null)", + "T min()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.amin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amin.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.mT", + "origin": "numpy", + "surface": "ndarray", + "name": "mT", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.mT.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.mT", + "numsharp_signatures": [ + "NumSharp.NDArray mT { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.nbytes", + "origin": "numpy", + "surface": "ndarray", + "name": "nbytes", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.nbytes.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.ndim", + "origin": "numpy", + "surface": "ndarray", + "name": "ndim", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ndim.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.ndim", + "numsharp_signatures": [ + "int ndim { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.nonzero", + "origin": "numpy", + "surface": "ndarray", + "name": "nonzero", + "kind": "method", + "numpy_signature": "(self, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.nonzero.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nonzero", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray[] nonzero(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.nonzero.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.nonzero.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.partition", + "origin": "numpy", + "surface": "ndarray", + "name": "partition", + "kind": "method", + "numpy_signature": "(self, kth, /, axis=-1, kind='introselect', order=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.partition.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.prod", + "origin": "numpy", + "surface": "ndarray", + "name": "prod", + "kind": "method", + "numpy_signature": "(self, /, axis=None, dtype=None, out=None, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.prod.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.prod", + "numsharp_signatures": [ + "NumSharp.NDArray prod(int? axis = null, System.Type dtype = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/NDArray.prod.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.prod.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.put", + "origin": "numpy", + "surface": "ndarray", + "name": "put", + "kind": "method", + "numpy_signature": "(self, indices, values, /, mode='raise')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.put.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.put", + "numsharp_signatures": [ + "void put(NumSharp.NDArray a, NumSharp.NDArray indices, NumSharp.NDArray values, string mode = \"raise\")", + "void put(NumSharp.NDArray a, long index, object value, string mode = \"raise\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.put.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.put.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.ravel", + "origin": "numpy", + "surface": "ndarray", + "name": "ravel", + "kind": "method", + "numpy_signature": "(self, /, order='C')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ravel.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.ravel", + "numsharp_signatures": [ + "NumSharp.NDArray ravel()", + "NumSharp.NDArray ravel(char order)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.ravel.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.ravel.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.real", + "origin": "numpy", + "surface": "ndarray", + "name": "real", + "kind": "property", + "numpy_signature": "The real part of the array.", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.real.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.repeat", + "origin": "numpy", + "surface": "ndarray", + "name": "repeat", + "kind": "method", + "numpy_signature": "(self, repeats, /, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.repeat.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.repeat", + "numsharp_signatures": [ + "NumSharp.NDArray repeat(NumSharp.NDArray a, NumSharp.NDArray repeats, int? axis = null)", + "NumSharp.NDArray repeat(NumSharp.NDArray a, int repeats, int? axis = null)", + "NumSharp.NDArray repeat(NumSharp.NDArray a, long repeats, int? axis = null)", + "NumSharp.NDArray repeat(T a, int repeats)", + "NumSharp.NDArray repeat(T a, long repeats)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.repeat.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.repeat.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.reshape", + "origin": "numpy", + "surface": "ndarray", + "name": "reshape", + "kind": "method", + "numpy_signature": "(self, /, *shape, order='C', copy=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.reshape.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.reshape", + "numsharp_signatures": [ + "NumSharp.NDArray reshape(NumSharp.Shape newShape)", + "NumSharp.NDArray reshape(NumSharp.Shape newShape, char order)", + "NumSharp.NDArray reshape(int[] shape)", + "NumSharp.NDArray reshape(params long[] shape)", + "NumSharp.NDArray reshape(ref NumSharp.Shape newShape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.ReShape.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.ReShape.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.resize", + "origin": "numpy", + "surface": "ndarray", + "name": "resize", + "kind": "method", + "numpy_signature": "(self, /, *new_shape, refcheck=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.resize.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.resize", + "numsharp_signatures": [ + "void resize(NumSharp.Shape new_shape, bool refcheck = true)", + "void resize(params long[] new_shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.resize.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.resize.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.round", + "origin": "numpy", + "surface": "ndarray", + "name": "round", + "kind": "method", + "numpy_signature": "(self, /, decimals=0, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.round.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.round_", + "numsharp_signatures": [ + "NumSharp.NDArray round_(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray round_(NumSharp.NDArray x, System.Type dtype)", + "NumSharp.NDArray round_(NumSharp.NDArray x, int decimals = 0, NumSharp.NDArray out = null)", + "NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.round.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.round.cs" + ], + "notes": "Use the static np.round_ API; NumSharp does not expose ndarray.round as an instance member." + }, + { + "id": "numpy.ndarray.searchsorted", + "origin": "numpy", + "surface": "ndarray", + "name": "searchsorted", + "kind": "method", + "numpy_signature": "(self, v, /, side='left', sorter=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.searchsorted.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.searchsorted", + "numsharp_signatures": [ + "NumSharp.NDArray searchsorted(NumSharp.NDArray a, NumSharp.NDArray v, string side = \"left\", NumSharp.NDArray sorter = null)", + "long searchsorted(NumSharp.NDArray a, double v, string side = \"left\", NumSharp.NDArray sorter = null)", + "long searchsorted(NumSharp.NDArray a, int v, string side = \"left\", NumSharp.NDArray sorter = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.setfield", + "origin": "numpy", + "surface": "ndarray", + "name": "setfield", + "kind": "method", + "numpy_signature": "(self, val, /, dtype, offset=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.setfield.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.setflags", + "origin": "numpy", + "surface": "ndarray", + "name": "setflags", + "kind": "method", + "numpy_signature": "(self, /, *, write=None, align=None, uic=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.setflags.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.shape", + "origin": "numpy", + "surface": "ndarray", + "name": "shape", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.shape.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.shape", + "numsharp_signatures": [ + "long[] shape { get; set; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.size", + "origin": "numpy", + "surface": "ndarray", + "name": "size", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.size.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.size", + "numsharp_signatures": [ + "long size { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.sort", + "origin": "numpy", + "surface": "ndarray", + "name": "sort", + "kind": "method", + "numpy_signature": "(self, /, axis=-1, kind=None, order=None, *, stable=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.sort.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.sort", + "numsharp_signatures": [ + "void sort(int? axis = -1, string kind = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.squeeze", + "origin": "numpy", + "surface": "ndarray", + "name": "squeeze", + "kind": "method", + "numpy_signature": "(self, /, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.squeeze.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.squeeze", + "numsharp_signatures": [ + "NumSharp.NDArray squeeze(NumSharp.NDArray a)", + "NumSharp.NDArray squeeze(NumSharp.NDArray a, int axis)", + "NumSharp.Shape squeeze(NumSharp.Shape shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.squeeze.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.squeeze.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.std", + "origin": "numpy", + "surface": "ndarray", + "name": "std", + "kind": "method", + "numpy_signature": "(self, /, axis=None, dtype=None, out=None, ddof=0, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.std.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.std", + "numsharp_signatures": [ + "NumSharp.NDArray std(bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray std(int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.std.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.std.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.strides", + "origin": "numpy", + "surface": "ndarray", + "name": "strides", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.strides.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.strides", + "numsharp_signatures": [ + "long[] strides { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.sum", + "origin": "numpy", + "surface": "ndarray", + "name": "sum", + "kind": "method", + "numpy_signature": "(self, /, axis=None, dtype=None, out=None, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.sum.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.sum", + "numsharp_signatures": [ + "NumSharp.NDArray sum()", + "NumSharp.NDArray sum(int axis)", + "NumSharp.NDArray sum(int axis, bool keepdims, NumSharp.NPTypeCode? typeCode = null)", + "NumSharp.NDArray sum(int axis, bool keepdims, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/NDArray.sum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.sum.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.swapaxes", + "origin": "numpy", + "surface": "ndarray", + "name": "swapaxes", + "kind": "method", + "numpy_signature": "(self, axis1, axis2, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.swapaxes.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.swapaxes", + "numsharp_signatures": [ + "NumSharp.NDArray swapaxes(int axis1, int axis2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NdArray.swapaxes.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NdArray.swapaxes.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.T", + "origin": "numpy", + "surface": "ndarray", + "name": "T", + "kind": "property", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.T.html", + "in_default_scope": true, + "category": "Array attributes", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.T", + "numsharp_signatures": [ + "NumSharp.NDArray T { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.take", + "origin": "numpy", + "surface": "ndarray", + "name": "take", + "kind": "method", + "numpy_signature": "(self, indices, /, axis=None, out=None, mode='raise')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.take.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.take", + "numsharp_signatures": [ + "NumSharp.NDArray take(NumSharp.NDArray a, NumSharp.NDArray indices, int? axis = null, NumSharp.NDArray out = null, string mode = \"raise\")", + "NumSharp.NDArray take(NumSharp.NDArray a, long index, int? axis = null, NumSharp.NDArray out = null, string mode = \"raise\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.take.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.take.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.to_device", + "origin": "numpy", + "surface": "ndarray", + "name": "to_device", + "kind": "method", + "numpy_signature": "(self, device, /, *, stream=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.to_device.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndarray.tobytes", + "origin": "numpy", + "surface": "ndarray", + "name": "tobytes", + "kind": "method", + "numpy_signature": "(self, /, order='C')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tobytes.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.tobytes", + "numsharp_signatures": [ + "byte[] tobytes(char order = 'C')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Casting/NdArray.tobytes.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArray.tobytes.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.tofile", + "origin": "numpy", + "surface": "ndarray", + "name": "tofile", + "kind": "method", + "numpy_signature": "(self, fid, /, sep='', format='%s')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tofile.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.tofile", + "numsharp_signatures": [ + "void tofile(System.IO.Stream stream, string sep = \"\", string format = \"%s\")", + "void tofile(string fid, string sep = \"\", string format = \"%s\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.tofile.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.tofile.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.tolist", + "origin": "numpy", + "surface": "ndarray", + "name": "tolist", + "kind": "method", + "numpy_signature": "(self, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tolist.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.tolist", + "numsharp_signatures": [ + "object tolist()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.tolist.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.tolist.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.trace", + "origin": "numpy", + "surface": "ndarray", + "name": "trace", + "kind": "method", + "numpy_signature": "(self, /, offset=0, axis1=0, axis2=1, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.trace.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.trace", + "numsharp_signatures": [ + "NumSharp.NDArray trace(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1, System.Type dtype = null, NumSharp.NDArray out = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.trace.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.trace.cs" + ], + "notes": "Available through the static NumSharp np API instead of the NumPy instance method." + }, + { + "id": "numpy.ndarray.transpose", + "origin": "numpy", + "surface": "ndarray", + "name": "transpose", + "kind": "method", + "numpy_signature": "(self, /, *axes)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.transpose.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.transpose", + "numsharp_signatures": [ + "NumSharp.NDArray transpose(int[] premute = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NdArray.Transpose.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NdArray.Transpose.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.var", + "origin": "numpy", + "surface": "ndarray", + "name": "var", + "kind": "method", + "numpy_signature": "(self, /, axis=None, dtype=None, out=None, ddof=0, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.var.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.var", + "numsharp_signatures": [ + "NumSharp.NDArray var(bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray var(int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.var.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.var.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray.view", + "origin": "numpy", + "surface": "ndarray", + "name": "view", + "kind": "method", + "numpy_signature": "(self, /, *args, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndarray.view.html", + "in_default_scope": true, + "category": "Array methods", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.view", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray view()", + "NumSharp.NDArray view(System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.__array_namespace_info__", + "origin": "numpy", + "surface": "np", + "name": "__array_namespace_info__", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.__version__", + "origin": "numpy", + "surface": "np", + "name": "__version__", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.abs", + "origin": "numpy", + "surface": "np", + "name": "abs", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.absolute.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.abs", + "numsharp_signatures": [ + "NumSharp.NDArray abs(NumSharp.NDArray a)", + "NumSharp.NDArray abs(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray abs(NumSharp.NDArray a, NumSharp.NPTypeCode? dtype)", + "NumSharp.NDArray abs(NumSharp.NDArray a, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.absolute.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.absolute.cs" + ], + "notes": "" + }, + { + "id": "numpy.absolute", + "origin": "numpy", + "surface": "np", + "name": "absolute", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.absolute.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.absolute", + "numsharp_signatures": [ + "NumSharp.NDArray absolute(NumSharp.NDArray a)", + "NumSharp.NDArray absolute(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray absolute(NumSharp.NDArray a, NumSharp.NPTypeCode? dtype)", + "NumSharp.NDArray absolute(NumSharp.NDArray a, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.absolute.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.absolute.cs" + ], + "notes": "" + }, + { + "id": "numpy.acos", + "origin": "numpy", + "surface": "np", + "name": "acos", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.acos.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arccos", + "numsharp_signatures": [ + "NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arccos(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.cos.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs" + ], + "notes": "NumSharp exposes the canonical NumPy name arccos." + }, + { + "id": "numpy.acosh", + "origin": "numpy", + "surface": "np", + "name": "acosh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.acosh.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.add", + "origin": "numpy", + "surface": "np", + "name": "add", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.add.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.add", + "numsharp_signatures": [ + "NumSharp.NDArray add(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.all", + "origin": "numpy", + "surface": "np", + "name": "all", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, *, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.all.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.all", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray all(NumSharp.NDArray nd, bool keepdims)", + "NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int axis, bool keepdims = false)", + "NumSharp.Generic.NDArray all(NumSharp.NDArray nd, int[] axis, bool keepdims = false)", + "NumSharp.NDArray all(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null)", + "NumSharp.NDArray all(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null)", + "bool all(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.all.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.all.cs" + ], + "notes": "" + }, + { + "id": "numpy.allclose", + "origin": "numpy", + "surface": "np", + "name": "allclose", + "kind": "function", + "numpy_signature": "(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.allclose.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.allclose", + "numsharp_signatures": [ + "bool allclose(NumSharp.NDArray a, NumSharp.NDArray b, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.allclose.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.allclose.cs" + ], + "notes": "" + }, + { + "id": "numpy.amax", + "origin": "numpy", + "surface": "np", + "name": "amax", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.amax.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.amax", + "numsharp_signatures": [ + "NumSharp.NDArray amax(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null)", + "T amax(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs" + ], + "notes": "" + }, + { + "id": "numpy.amin", + "origin": "numpy", + "surface": "np", + "name": "amin", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.amin.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.amin", + "numsharp_signatures": [ + "NumSharp.NDArray amin(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null)", + "T amin(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs" + ], + "notes": "" + }, + { + "id": "numpy.angle", + "origin": "numpy", + "surface": "np", + "name": "angle", + "kind": "function", + "numpy_signature": "(z, deg=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.angle.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.any", + "origin": "numpy", + "surface": "np", + "name": "any", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, *, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.any.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.any", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray any(NumSharp.NDArray nd, bool keepdims)", + "NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int axis, bool keepdims = false)", + "NumSharp.Generic.NDArray any(NumSharp.NDArray nd, int[] axis, bool keepdims = false)", + "NumSharp.NDArray any(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false, NumSharp.NDArray where = null)", + "NumSharp.NDArray any(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out, bool keepdims = false, NumSharp.NDArray where = null)", + "bool any(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.any.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.any.cs" + ], + "notes": "" + }, + { + "id": "numpy.append", + "origin": "numpy", + "surface": "np", + "name": "append", + "kind": "function", + "numpy_signature": "(arr, values, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.append.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.append", + "numsharp_signatures": [ + "NumSharp.NDArray append(NumSharp.NDArray arr, NumSharp.NDArray values, int? axis = null)", + "NumSharp.NDArray append(NumSharp.NDArray arr, object values, int? axis = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.append.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.append.cs" + ], + "notes": "" + }, + { + "id": "numpy.apply_along_axis", + "origin": "numpy", + "surface": "np", + "name": "apply_along_axis", + "kind": "function", + "numpy_signature": "(func1d, axis, arr, *args, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.apply_along_axis.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.apply_over_axes", + "origin": "numpy", + "surface": "np", + "name": "apply_over_axes", + "kind": "function", + "numpy_signature": "(func, a, axes)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.apply_over_axes.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.arange", + "origin": "numpy", + "surface": "np", + "name": "arange", + "kind": "function", + "numpy_signature": "(start_or_stop, /, stop=None, step=1, *, dtype=None, device=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arange.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arange", + "numsharp_signatures": [ + "NumSharp.NDArray arange(double start, double stop, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arange(double start, double stop, System.Type dtype)", + "NumSharp.NDArray arange(double start, double stop, double step = 1)", + "NumSharp.NDArray arange(double start, double stop, double step, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arange(double start, double stop, double step, System.Type dtype)", + "NumSharp.NDArray arange(double stop)", + "NumSharp.NDArray arange(double stop, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arange(double stop, System.Type dtype)", + "NumSharp.NDArray arange(float start, float stop, float step = 1)", + "NumSharp.NDArray arange(float stop)", + "NumSharp.NDArray arange(int start, int stop, int step = 1)", + "NumSharp.NDArray arange(int stop)", + "NumSharp.NDArray arange(long start, long stop, long step = 1)", + "NumSharp.NDArray arange(long stop)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.arange.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.arange.cs" + ], + "notes": "" + }, + { + "id": "numpy.arccos", + "origin": "numpy", + "surface": "np", + "name": "arccos", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arccos.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arccos", + "numsharp_signatures": [ + "NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arccos(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arccos(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.cos.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs" + ], + "notes": "" + }, + { + "id": "numpy.arccosh", + "origin": "numpy", + "surface": "np", + "name": "arccosh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arccosh.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.arcsin", + "origin": "numpy", + "surface": "np", + "name": "arcsin", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arcsin", + "numsharp_signatures": [ + "NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arcsin(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.sin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs" + ], + "notes": "" + }, + { + "id": "numpy.arcsinh", + "origin": "numpy", + "surface": "np", + "name": "arcsinh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arcsinh.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.arctan", + "origin": "numpy", + "surface": "np", + "name": "arctan", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arctan.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arctan", + "numsharp_signatures": [ + "NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arctan(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.tan.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs" + ], + "notes": "" + }, + { + "id": "numpy.arctan2", + "origin": "numpy", + "surface": "np", + "name": "arctan2", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arctan2", + "numsharp_signatures": [ + "NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.tan.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs" + ], + "notes": "" + }, + { + "id": "numpy.arctanh", + "origin": "numpy", + "surface": "np", + "name": "arctanh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.arctanh.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.argmax", + "origin": "numpy", + "surface": "np", + "name": "argmax", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, *, keepdims=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.argmax.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.argmax", + "numsharp_signatures": [ + "NumSharp.NDArray argmax(NumSharp.NDArray a, int axis, bool keepdims = false)", + "long argmax(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs" + ], + "notes": "" + }, + { + "id": "numpy.argmin", + "origin": "numpy", + "surface": "np", + "name": "argmin", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, *, keepdims=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.argmin.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.argmin", + "numsharp_signatures": [ + "NumSharp.NDArray argmin(NumSharp.NDArray a, int axis, bool keepdims = false)", + "long argmin(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.argmax.cs" + ], + "notes": "" + }, + { + "id": "numpy.argpartition", + "origin": "numpy", + "surface": "np", + "name": "argpartition", + "kind": "function", + "numpy_signature": "(a, kth, axis=-1, kind='introselect', order=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.argpartition.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.argsort", + "origin": "numpy", + "surface": "np", + "name": "argsort", + "kind": "function", + "numpy_signature": "(a, axis=-1, kind=None, order=None, *, stable=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.argsort.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.argsort", + "numsharp_signatures": [ + "NumSharp.NDArray argsort(NumSharp.NDArray nd, int axis = -1)", + "NumSharp.NDArray argsort(NumSharp.NDArray nd, int? axis = -1)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.argsort.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.argsort.cs" + ], + "notes": "" + }, + { + "id": "numpy.argwhere", + "origin": "numpy", + "surface": "np", + "name": "argwhere", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.argwhere.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.argwhere", + "numsharp_signatures": [ + "NumSharp.NDArray argwhere(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.argwhere.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.argwhere.cs" + ], + "notes": "" + }, + { + "id": "numpy.around", + "origin": "numpy", + "surface": "np", + "name": "around", + "kind": "function", + "numpy_signature": "(a, decimals=0, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.around.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.around", + "numsharp_signatures": [ + "NumSharp.NDArray around(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray around(NumSharp.NDArray x, System.Type dtype)", + "NumSharp.NDArray around(NumSharp.NDArray x, int decimals = 0, NumSharp.NDArray out = null)", + "NumSharp.NDArray around(NumSharp.NDArray x, int decimals, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray around(NumSharp.NDArray x, int decimals, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.round.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.round.cs" + ], + "notes": "" + }, + { + "id": "numpy.array", + "origin": "numpy", + "surface": "np", + "name": "array", + "kind": "function", + "numpy_signature": "(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, ndmax=0, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.array.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.array", + "numsharp_signatures": [ + "NumSharp.NDArray array(NumSharp.NDArray nd, bool copy = true)", + "NumSharp.NDArray array(System.Array array, System.Type dtype = null, int ndmin = 1, bool copy = true, char order = 'C')", + "NumSharp.NDArray array(System.Collections.Generic.IEnumerable data)", + "NumSharp.NDArray array(System.Collections.Generic.IEnumerable data, int size)", + "NumSharp.NDArray array(System.Collections.Generic.IEnumerable data, long size)", + "NumSharp.NDArray array(T scalar)", + "NumSharp.NDArray array(T[] data, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray array(T[] data, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray array(T[] data, System.Type dtype)", + "NumSharp.NDArray array(T[] data, System.Type dtype)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy = true)", + "NumSharp.NDArray array(T[] data, bool copy)", + "NumSharp.NDArray array(T[][] data)", + "NumSharp.NDArray array(T[][][] data)", + "NumSharp.NDArray array(T[][][][] data)", + "NumSharp.NDArray array(T[][][][][] data)", + "NumSharp.NDArray array(params T[] data)", + "NumSharp.NDArray array(string chars)", + "NumSharp.NDArray array(string[] strArray)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.array.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.array.cs" + ], + "notes": "" + }, + { + "id": "numpy.array2string", + "origin": "numpy", + "surface": "np", + "name": "array2string", + "kind": "function", + "numpy_signature": "(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', *, formatter=None, threshold=None, edgeitems=None, sign=None, floatmode=None, suffix='', legacy=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.array2string.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.array2string", + "numsharp_signatures": [ + "string array2string(NumSharp.NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null, string separator = \" \", string prefix = \"\", int? threshold = null, int? edgeitems = null, char? sign = null, string floatmode = null, string suffix = \"\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.array_equal", + "origin": "numpy", + "surface": "np", + "name": "array_equal", + "kind": "function", + "numpy_signature": "(a1, a2, equal_nan=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.array_equal.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.array_equal", + "numsharp_signatures": [ + "bool array_equal(NumSharp.NDArray a, NumSharp.NDArray b)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.array_equal.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.array_equal.cs" + ], + "notes": "" + }, + { + "id": "numpy.array_equiv", + "origin": "numpy", + "surface": "np", + "name": "array_equiv", + "kind": "function", + "numpy_signature": "(a1, a2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.array_equiv.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.array_repr", + "origin": "numpy", + "surface": "np", + "name": "array_repr", + "kind": "function", + "numpy_signature": "(arr, max_line_width=None, precision=None, suppress_small=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.array_repr.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.array_repr", + "numsharp_signatures": [ + "string array_repr(NumSharp.NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.array_split", + "origin": "numpy", + "surface": "np", + "name": "array_split", + "kind": "function", + "numpy_signature": "(ary, indices_or_sections, axis=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.array_split.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.array_split", + "numsharp_signatures": [ + "NumSharp.NDArray[] array_split(NumSharp.NDArray ary, int indices_or_sections, int axis = 0)", + "NumSharp.NDArray[] array_split(NumSharp.NDArray ary, int[] indices, int axis = 0)", + "NumSharp.NDArray[] array_split(NumSharp.NDArray ary, long[] indices, int axis = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.split.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.split.cs" + ], + "notes": "" + }, + { + "id": "numpy.array_str", + "origin": "numpy", + "surface": "np", + "name": "array_str", + "kind": "function", + "numpy_signature": "(a, max_line_width=None, precision=None, suppress_small=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.array_str.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.array_str", + "numsharp_signatures": [ + "string array_str(NumSharp.NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.asanyarray", + "origin": "numpy", + "surface": "np", + "name": "asanyarray", + "kind": "function", + "numpy_signature": "(a, dtype=None, order=None, *, device=None, copy=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.asanyarray.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.asanyarray", + "numsharp_signatures": [ + "NumSharp.NDArray asanyarray(ref object a, System.Type dtype = null)", + "NumSharp.NDArray asanyarray(ref object a, System.Type dtype, char order)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.asanyarray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asanyarray.cs" + ], + "notes": "" + }, + { + "id": "numpy.asarray", + "origin": "numpy", + "surface": "np", + "name": "asarray", + "kind": "function", + "numpy_signature": "(a, dtype=None, order=None, *, device=None, copy=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.asarray.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.asarray", + "numsharp_signatures": [ + "NumSharp.NDArray asarray(NumSharp.NDArray a, NumSharp.DType dtype, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null)", + "NumSharp.NDArray asarray(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null)", + "NumSharp.NDArray asarray(NumSharp.NDArray a, System.Type dtype = null, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null)", + "NumSharp.NDArray asarray(NumSharp.NDArray a, string dtype, char order = 'K', bool? copy = null, NumSharp.NDArray like = null, string device = null)", + "NumSharp.NDArray asarray(T data)", + "NumSharp.NDArray asarray(T[] data, int ndim = 1)", + "NumSharp.NDArray asarray(string data)", + "NumSharp.NDArray asarray(string[] data, int ndim = 1)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.asarray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asarray.cs" + ], + "notes": "" + }, + { + "id": "numpy.asarray_chkfinite", + "origin": "numpy", + "surface": "np", + "name": "asarray_chkfinite", + "kind": "function", + "numpy_signature": "(a, dtype=None, order=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.asarray_chkfinite.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.asarray_chkfinite", + "numsharp_signatures": [ + "NumSharp.NDArray asarray_chkfinite(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, char order = 'K')", + "NumSharp.NDArray asarray_chkfinite(NumSharp.NDArray a, System.Type dtype = null, char order = 'K')", + "NumSharp.NDArray asarray_chkfinite(NumSharp.NDArray a, string dtype, char order = 'K')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.asarray_chkfinite.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asarray_chkfinite.cs" + ], + "notes": "" + }, + { + "id": "numpy.ascontiguousarray", + "origin": "numpy", + "surface": "np", + "name": "ascontiguousarray", + "kind": "function", + "numpy_signature": "(a, dtype=None, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ascontiguousarray.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ascontiguousarray", + "numsharp_signatures": [ + "NumSharp.NDArray ascontiguousarray(NumSharp.NDArray a, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.ascontiguousarray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.ascontiguousarray.cs" + ], + "notes": "" + }, + { + "id": "numpy.asfortranarray", + "origin": "numpy", + "surface": "np", + "name": "asfortranarray", + "kind": "function", + "numpy_signature": "(a, dtype=None, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.asfortranarray.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.asfortranarray", + "numsharp_signatures": [ + "NumSharp.NDArray asfortranarray(NumSharp.NDArray a, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.asfortranarray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asfortranarray.cs" + ], + "notes": "" + }, + { + "id": "numpy.asin", + "origin": "numpy", + "surface": "np", + "name": "asin", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.asin.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arcsin", + "numsharp_signatures": [ + "NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arcsin(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arcsin(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.sin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs" + ], + "notes": "NumSharp exposes the canonical NumPy name arcsin." + }, + { + "id": "numpy.asinh", + "origin": "numpy", + "surface": "np", + "name": "asinh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.asinh.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.asmatrix", + "origin": "numpy", + "surface": "np", + "name": "asmatrix", + "kind": "function", + "numpy_signature": "(data, dtype=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.asmatrix.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.asmatrix", + "numsharp_signatures": [ + "NumSharp.NDArray asmatrix(NumSharp.NDArray data, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray asmatrix(NumSharp.NDArray data, System.Type dtype = null)", + "NumSharp.NDArray asmatrix(NumSharp.NDArray data, string dtype)", + "NumSharp.NDArray asmatrix(string data, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray asmatrix(string data, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.asmatrix.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.asmatrix.cs" + ], + "notes": "" + }, + { + "id": "numpy.astype", + "origin": "numpy", + "surface": "np", + "name": "astype", + "kind": "function", + "numpy_signature": "(x, dtype, /, *, copy=True, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.astype.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray.astype", + "numsharp_signatures": [ + "NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy = true)", + "NumSharp.NDArray astype(NumSharp.NPTypeCode typeCode, bool copy, char order, string casting = \"unsafe\")", + "NumSharp.NDArray astype(System.Type dtype, bool copy = true)", + "NumSharp.NDArray astype(System.Type dtype, bool copy, char order, string casting = \"unsafe\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "The NumPy 2.x top-level helper is available as the NDArray instance method." + }, + { + "id": "numpy.atan", + "origin": "numpy", + "surface": "np", + "name": "atan", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.atan.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arctan", + "numsharp_signatures": [ + "NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arctan(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arctan(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.tan.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs" + ], + "notes": "NumSharp exposes the canonical NumPy name arctan." + }, + { + "id": "numpy.atan2", + "origin": "numpy", + "surface": "np", + "name": "atan2", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.atan2.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.arctan2", + "numsharp_signatures": [ + "NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray arctan2(NumSharp.NDArray y, NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.tan.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs" + ], + "notes": "NumSharp exposes the canonical NumPy name arctan2." + }, + { + "id": "numpy.atanh", + "origin": "numpy", + "surface": "np", + "name": "atanh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.atanh.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.atleast_1d", + "origin": "numpy", + "surface": "np", + "name": "atleast_1d", + "kind": "function", + "numpy_signature": "(*arys)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.atleast_1d.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.atleast_1d", + "numsharp_signatures": [ + "NumSharp.NDArray atleast_1d(NumSharp.NDArray arr)", + "NumSharp.NDArray atleast_1d(object arys)", + "NumSharp.NDArray[] atleast_1d(params NumSharp.NDArray[] arys)", + "NumSharp.NDArray[] atleast_1d(params object[] arys)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.atleastd.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.atleastd.cs" + ], + "notes": "" + }, + { + "id": "numpy.atleast_2d", + "origin": "numpy", + "surface": "np", + "name": "atleast_2d", + "kind": "function", + "numpy_signature": "(*arys)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.atleast_2d", + "numsharp_signatures": [ + "NumSharp.NDArray atleast_2d(NumSharp.NDArray arr)", + "NumSharp.NDArray atleast_2d(object arys)", + "NumSharp.NDArray[] atleast_2d(params NumSharp.NDArray[] arys)", + "NumSharp.NDArray[] atleast_2d(params object[] arys)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.atleastd.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.atleastd.cs" + ], + "notes": "" + }, + { + "id": "numpy.atleast_3d", + "origin": "numpy", + "surface": "np", + "name": "atleast_3d", + "kind": "function", + "numpy_signature": "(*arys)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.atleast_3d.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.atleast_3d", + "numsharp_signatures": [ + "NumSharp.NDArray atleast_3d(NumSharp.NDArray arr)", + "NumSharp.NDArray atleast_3d(object arys)", + "NumSharp.NDArray[] atleast_3d(params NumSharp.NDArray[] arys)", + "NumSharp.NDArray[] atleast_3d(params object[] arys)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.atleastd.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.atleastd.cs" + ], + "notes": "" + }, + { + "id": "numpy.average", + "origin": "numpy", + "surface": "np", + "name": "average", + "kind": "function", + "numpy_signature": "(a, axis=None, weights=None, returned=False, *, keepdims=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.average.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.average", + "numsharp_signatures": [ + "NumSharp.NDArray average(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray weights = null, bool keepdims = false)", + "NumSharp.NDArray average(NumSharp.NDArray a, int[] axis, NumSharp.NDArray weights = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.average.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.average.cs" + ], + "notes": "" + }, + { + "id": "numpy.bartlett", + "origin": "numpy", + "surface": "np", + "name": "bartlett", + "kind": "function", + "numpy_signature": "(M)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bartlett.html", + "in_default_scope": true, + "category": "Window functions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.base_repr", + "origin": "numpy", + "surface": "np", + "name": "base_repr", + "kind": "function", + "numpy_signature": "(number, base=2, padding=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.base_repr.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.binary_repr", + "origin": "numpy", + "surface": "np", + "name": "binary_repr", + "kind": "function", + "numpy_signature": "(num, width=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.binary_repr.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.bincount", + "origin": "numpy", + "surface": "np", + "name": "bincount", + "kind": "function", + "numpy_signature": "(x, /, weights=None, minlength=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bincount.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.bitwise_and", + "origin": "numpy", + "surface": "np", + "name": "bitwise_and", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bitwise_and.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.bitwise_and", + "numsharp_signatures": [ + "NumSharp.NDArray bitwise_and(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.bitwise.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.bitwise.cs" + ], + "notes": "" + }, + { + "id": "numpy.bitwise_count", + "origin": "numpy", + "surface": "np", + "name": "bitwise_count", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bitwise_count.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.bitwise_invert", + "origin": "numpy", + "surface": "np", + "name": "bitwise_invert", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bitwise_invert.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.invert", + "numsharp_signatures": [ + "NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NPTypeCode outType)", + "NumSharp.NDArray invert(NumSharp.NDArray x, System.Type outType)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.invert.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.invert.cs" + ], + "notes": "NumSharp exposes the ufunc alias invert." + }, + { + "id": "numpy.bitwise_left_shift", + "origin": "numpy", + "surface": "np", + "name": "bitwise_left_shift", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bitwise_left_shift.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.left_shift", + "numsharp_signatures": [ + "NumSharp.NDArray left_shift(NumSharp.NDArray x1, NumSharp.NDArray x2)", + "NumSharp.NDArray left_shift(NumSharp.NDArray x1, object x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.left_shift.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.left_shift.cs" + ], + "notes": "NumSharp exposes the ufunc alias left_shift." + }, + { + "id": "numpy.bitwise_not", + "origin": "numpy", + "surface": "np", + "name": "bitwise_not", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.invert.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.bitwise_not", + "numsharp_signatures": [ + "NumSharp.NDArray bitwise_not(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray bitwise_not(NumSharp.NDArray x, NumSharp.NPTypeCode outType)", + "NumSharp.NDArray bitwise_not(NumSharp.NDArray x, System.Type outType)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.invert.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.invert.cs" + ], + "notes": "" + }, + { + "id": "numpy.bitwise_or", + "origin": "numpy", + "surface": "np", + "name": "bitwise_or", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bitwise_or.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.bitwise_or", + "numsharp_signatures": [ + "NumSharp.NDArray bitwise_or(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.bitwise.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.bitwise.cs" + ], + "notes": "" + }, + { + "id": "numpy.bitwise_right_shift", + "origin": "numpy", + "surface": "np", + "name": "bitwise_right_shift", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bitwise_right_shift.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.right_shift", + "numsharp_signatures": [ + "NumSharp.NDArray right_shift(NumSharp.NDArray x1, NumSharp.NDArray x2)", + "NumSharp.NDArray right_shift(NumSharp.NDArray x1, object x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.right_shift.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.right_shift.cs" + ], + "notes": "NumSharp exposes the ufunc alias right_shift." + }, + { + "id": "numpy.bitwise_xor", + "origin": "numpy", + "surface": "np", + "name": "bitwise_xor", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bitwise_xor.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.bitwise_xor", + "numsharp_signatures": [ + "NumSharp.NDArray bitwise_xor(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.bitwise.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.bitwise.cs" + ], + "notes": "" + }, + { + "id": "numpy.blackman", + "origin": "numpy", + "surface": "np", + "name": "blackman", + "kind": "function", + "numpy_signature": "(M)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.blackman.html", + "in_default_scope": true, + "category": "Window functions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.block", + "origin": "numpy", + "surface": "np", + "name": "block", + "kind": "function", + "numpy_signature": "(arrays)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.block.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.block", + "numsharp_signatures": [ + "NumSharp.NDArray block(object arrays)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.block.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.block.cs" + ], + "notes": "" + }, + { + "id": "numpy.bmat", + "origin": "numpy", + "surface": "np", + "name": "bmat", + "kind": "function", + "numpy_signature": "(obj, ldict=None, gdict=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.bmat.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.bool", + "origin": "numpy", + "surface": "np", + "name": "bool", + "kind": "class", + "numpy_signature": "(value=False, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.bool", + "numsharp_signatures": [ + "readonly System.Type bool" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.bool_", + "origin": "numpy", + "surface": "np", + "name": "bool_", + "kind": "class", + "numpy_signature": "(value=False, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.bool_", + "numsharp_signatures": [ + "readonly System.Type bool_" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.broadcast", + "origin": "numpy", + "surface": "np", + "name": "broadcast", + "kind": "class", + "numpy_signature": "(*arrays)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.broadcast", + "numsharp_signatures": [ + "NumSharp.np+Broadcast broadcast(NumSharp.NDArray nd1, NumSharp.NDArray nd2)", + "NumSharp.np+Broadcast broadcast(params NumSharp.NDArray[] arrays)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.broadcast.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.broadcast.cs" + ], + "notes": "" + }, + { + "id": "numpy.broadcast_arrays", + "origin": "numpy", + "surface": "np", + "name": "broadcast_arrays", + "kind": "function", + "numpy_signature": "(*args, subok=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.broadcast_arrays", + "numsharp_signatures": [ + "NumSharp.NDArray[] broadcast_arrays(params NumSharp.NDArray[] ndArrays)", + "System.ValueTuple broadcast_arrays(NumSharp.NDArray lhs, NumSharp.NDArray rhs)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.broadcast_arrays.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.broadcast_arrays.cs" + ], + "notes": "" + }, + { + "id": "numpy.broadcast_shapes", + "origin": "numpy", + "surface": "np", + "name": "broadcast_shapes", + "kind": "function", + "numpy_signature": "(*args)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.broadcast_shapes.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.broadcast_to", + "origin": "numpy", + "surface": "np", + "name": "broadcast_to", + "kind": "function", + "numpy_signature": "(array, shape, subok=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.broadcast_to", + "numsharp_signatures": [ + "NumSharp.NDArray broadcast_to(NumSharp.Backends.UnmanagedStorage from, NumSharp.Backends.UnmanagedStorage against)", + "NumSharp.NDArray broadcast_to(NumSharp.Backends.UnmanagedStorage from, NumSharp.NDArray against)", + "NumSharp.NDArray broadcast_to(NumSharp.Backends.UnmanagedStorage from, NumSharp.Shape against)", + "NumSharp.NDArray broadcast_to(NumSharp.NDArray from, NumSharp.Backends.UnmanagedStorage against)", + "NumSharp.NDArray broadcast_to(NumSharp.NDArray from, NumSharp.NDArray against)", + "NumSharp.NDArray broadcast_to(NumSharp.NDArray from, NumSharp.Shape against)", + "NumSharp.Shape broadcast_to(NumSharp.Shape from, NumSharp.Backends.UnmanagedStorage against)", + "NumSharp.Shape broadcast_to(NumSharp.Shape from, NumSharp.NDArray against)", + "NumSharp.Shape broadcast_to(NumSharp.Shape from, NumSharp.Shape against)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.broadcast_to.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.broadcast_to.cs" + ], + "notes": "" + }, + { + "id": "numpy.busday_count", + "origin": "numpy", + "surface": "np", + "name": "busday_count", + "kind": "function", + "numpy_signature": "(begindates, enddates, weekmask='1111100', holidays=(), busdaycal=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.busday_count.html", + "in_default_scope": true, + "category": "Date & time", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.busday_offset", + "origin": "numpy", + "surface": "np", + "name": "busday_offset", + "kind": "function", + "numpy_signature": "(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.busday_offset.html", + "in_default_scope": true, + "category": "Date & time", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.busdaycalendar", + "origin": "numpy", + "surface": "np", + "name": "busdaycalendar", + "kind": "class", + "numpy_signature": "(weekmask='1111100', holidays=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.byte", + "origin": "numpy", + "surface": "np", + "name": "byte", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.byte", + "numsharp_signatures": [ + "readonly System.Type byte" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.bytes_", + "origin": "numpy", + "surface": "np", + "name": "bytes_", + "kind": "class", + "numpy_signature": "(value='', /, *args, **kwargs)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.c_", + "origin": "numpy", + "surface": "np", + "name": "c_", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.can_cast", + "origin": "numpy", + "surface": "np", + "name": "can_cast", + "kind": "function", + "numpy_signature": "(from_, to, casting='safe')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.can_cast.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.can_cast", + "numsharp_signatures": [ + "bool can_cast(NumSharp.NDArray from, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(NumSharp.NPTypeCode from, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(System.Type from, System.Type to, string casting = \"safe\")", + "bool can_cast(bool value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(byte value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(decimal value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(double value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(float value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(int value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(long value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(object value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(short value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(string casting = \"safe\")", + "bool can_cast(uint value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(ulong value, NumSharp.NPTypeCode to, string casting = \"safe\")", + "bool can_cast(ushort value, NumSharp.NPTypeCode to, string casting = \"safe\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.can_cast.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.can_cast.cs" + ], + "notes": "" + }, + { + "id": "numpy.cbrt", + "origin": "numpy", + "surface": "np", + "name": "cbrt", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cbrt.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cbrt", + "numsharp_signatures": [ + "NumSharp.NDArray cbrt(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray cbrt(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray cbrt(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.cbrt.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cbrt.cs" + ], + "notes": "" + }, + { + "id": "numpy.cdouble", + "origin": "numpy", + "surface": "np", + "name": "cdouble", + "kind": "class", + "numpy_signature": "(real=0, imag=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cdouble", + "numsharp_signatures": [ + "readonly System.Type cdouble" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ceil", + "origin": "numpy", + "surface": "np", + "name": "ceil", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ceil.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ceil", + "numsharp_signatures": [ + "NumSharp.NDArray ceil(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray ceil(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray ceil(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.ceil.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.ceil.cs" + ], + "notes": "" + }, + { + "id": "numpy.char", + "origin": "numpy", + "surface": "np", + "name": "char", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.char", + "numsharp_signatures": [ + "readonly System.Type char" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.character", + "origin": "numpy", + "surface": "np", + "name": "character", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.choose", + "origin": "numpy", + "surface": "np", + "name": "choose", + "kind": "function", + "numpy_signature": "(a, choices, out=None, mode='raise')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.choose.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.clip", + "origin": "numpy", + "surface": "np", + "name": "clip", + "kind": "function", + "numpy_signature": "(a, a_min=, a_max=, out=None, *, min=, max=, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.clip.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.clip", + "numsharp_signatures": [ + "NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min = null, NumSharp.NDArray a_max = null, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, NumSharp.NDArray min = null, NumSharp.NDArray max = null)", + "NumSharp.NDArray clip(NumSharp.NDArray a, NumSharp.NDArray a_min, NumSharp.NDArray a_max, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.clip.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.clip.cs" + ], + "notes": "" + }, + { + "id": "numpy.clongdouble", + "origin": "numpy", + "surface": "np", + "name": "clongdouble", + "kind": "class", + "numpy_signature": "(real=0, imag=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.clongdouble", + "numsharp_signatures": [ + "readonly System.Type clongdouble" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.column_stack", + "origin": "numpy", + "surface": "np", + "name": "column_stack", + "kind": "function", + "numpy_signature": "(tup)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.column_stack.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.column_stack", + "numsharp_signatures": [ + "NumSharp.NDArray column_stack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.column_stack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.column_stack.cs" + ], + "notes": "" + }, + { + "id": "numpy.common_type", + "origin": "numpy", + "surface": "np", + "name": "common_type", + "kind": "function", + "numpy_signature": "(*arrays)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.common_type.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.common_type", + "numsharp_signatures": [ + "System.Type common_type(params NumSharp.NDArray[] arrays)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.common_type.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.common_type.cs" + ], + "notes": "" + }, + { + "id": "numpy.complex128", + "origin": "numpy", + "surface": "np", + "name": "complex128", + "kind": "class", + "numpy_signature": "(real=0, imag=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.complex128", + "numsharp_signatures": [ + "readonly System.Type complex128" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.complex64", + "origin": "numpy", + "surface": "np", + "name": "complex64", + "kind": "class", + "numpy_signature": "(real=0, imag=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "unsupported", + "status": "unsupported", + "numsharp_target": "NumSharp.np.complex64", + "numsharp_signatures": [ + "System.Type complex64 { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "The public compatibility symbol exists, but NumSharp does not implement a Complex64 storage dtype." + }, + { + "id": "numpy.complexfloating", + "origin": "numpy", + "surface": "np", + "name": "complexfloating", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.compress", + "origin": "numpy", + "surface": "np", + "name": "compress", + "kind": "function", + "numpy_signature": "(condition, a, axis=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.compress.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.compress", + "numsharp_signatures": [ + "NumSharp.NDArray compress(NumSharp.NDArray condition, NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.compress.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.compress.cs" + ], + "notes": "" + }, + { + "id": "numpy.concat", + "origin": "numpy", + "surface": "np", + "name": "concat", + "kind": "function", + "numpy_signature": "(arrays, /, axis=0, out=None, *, dtype=None, casting='same_kind')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.concat.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.concat", + "numsharp_signatures": [ + "NumSharp.NDArray concat(NumSharp.NDArray[] arrays, int? axis = 0, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, string casting = \"same_kind\")", + "NumSharp.NDArray concat(System.ValueTuple> arrays, int axis = 0)", + "NumSharp.NDArray concat(System.ValueTuple> arrays, int axis = 0)", + "NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concat(System.ValueTuple arrays, int axis = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.concat.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.concat.cs" + ], + "notes": "" + }, + { + "id": "numpy.concatenate", + "origin": "numpy", + "surface": "np", + "name": "concatenate", + "kind": "function", + "numpy_signature": "(arrays, /, axis=0, out=None, *, dtype=None, casting='same_kind')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.concatenate", + "numsharp_signatures": [ + "NumSharp.NDArray concatenate(NumSharp.NDArray[] arrays, int? axis = 0, NumSharp.NDArray out = null, NumSharp.NPTypeCode? dtype = null, string casting = \"same_kind\")", + "NumSharp.NDArray concatenate(System.ValueTuple> arrays, int axis = 0)", + "NumSharp.NDArray concatenate(System.ValueTuple> arrays, int axis = 0)", + "NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0)", + "NumSharp.NDArray concatenate(System.ValueTuple arrays, int axis = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.concatenate.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.concatenate.cs" + ], + "notes": "" + }, + { + "id": "numpy.conj", + "origin": "numpy", + "surface": "np", + "name": "conj", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.conj.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.conjugate", + "origin": "numpy", + "surface": "np", + "name": "conjugate", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.conjugate.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.convolve", + "origin": "numpy", + "surface": "np", + "name": "convolve", + "kind": "function", + "numpy_signature": "(a, v, mode='full')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.convolve.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.convolve", + "numsharp_signatures": [ + "NumSharp.NDArray convolve(NumSharp.NDArray a, NumSharp.NDArray v, string mode = \"full\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.copy", + "origin": "numpy", + "surface": "np", + "name": "copy", + "kind": "function", + "numpy_signature": "(a, order='K', subok=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.copy.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.copy", + "numsharp_signatures": [ + "NumSharp.NDArray copy(NumSharp.NDArray a, char order = 'K')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.copy.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.copy.cs" + ], + "notes": "" + }, + { + "id": "numpy.copysign", + "origin": "numpy", + "surface": "np", + "name": "copysign", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.copysign.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.copyto", + "origin": "numpy", + "surface": "np", + "name": "copyto", + "kind": "function", + "numpy_signature": "(dst, src, casting='same_kind', where=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.copyto.html", + "in_default_scope": true, + "category": "Array metadata & memory", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.copyto", + "numsharp_signatures": [ + "void copyto(NumSharp.NDArray dst, NumSharp.NDArray src, string casting = \"same_kind\", NumSharp.NDArray where = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.copyto.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.copyto.cs" + ], + "notes": "" + }, + { + "id": "numpy.core", + "origin": "numpy", + "surface": "np", + "name": "core", + "kind": "module", + "numpy_signature": "The `numpy.core` submodule exists solely for backward compatibility", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.corrcoef", + "origin": "numpy", + "surface": "np", + "name": "corrcoef", + "kind": "function", + "numpy_signature": "(x, y=None, rowvar=True, *, dtype=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.corrcoef.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.correlate", + "origin": "numpy", + "surface": "np", + "name": "correlate", + "kind": "function", + "numpy_signature": "(a, v, mode='valid')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.correlate.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.cos", + "origin": "numpy", + "surface": "np", + "name": "cos", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cos.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cos", + "numsharp_signatures": [ + "NumSharp.NDArray cos(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray cos(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray cos(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.cos.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs" + ], + "notes": "" + }, + { + "id": "numpy.cosh", + "origin": "numpy", + "surface": "np", + "name": "cosh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cosh.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cosh", + "numsharp_signatures": [ + "NumSharp.NDArray cosh(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray cosh(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray cosh(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.cos.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.cos.cs" + ], + "notes": "" + }, + { + "id": "numpy.count_nonzero", + "origin": "numpy", + "surface": "np", + "name": "count_nonzero", + "kind": "function", + "numpy_signature": "(a, axis=None, *, keepdims=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.count_nonzero.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.count_nonzero", + "numsharp_signatures": [ + "NumSharp.NDArray count_nonzero(NumSharp.NDArray a, int axis, bool keepdims = false)", + "long count_nonzero(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.count_nonzero.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.count_nonzero.cs" + ], + "notes": "" + }, + { + "id": "numpy.cov", + "origin": "numpy", + "surface": "np", + "name": "cov", + "kind": "function", + "numpy_signature": "(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None, *, dtype=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cov.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.cross", + "origin": "numpy", + "surface": "np", + "name": "cross", + "kind": "function", + "numpy_signature": "(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cross.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.csingle", + "origin": "numpy", + "surface": "np", + "name": "csingle", + "kind": "class", + "numpy_signature": "(real=0, imag=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.csingle", + "numsharp_signatures": [ + "System.Type csingle { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ctypeslib", + "origin": "numpy", + "surface": "np", + "name": "ctypeslib", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.cumprod", + "origin": "numpy", + "surface": "np", + "name": "cumprod", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cumprod.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cumprod", + "numsharp_signatures": [ + "NumSharp.NDArray cumprod(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cumprod.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumprod.cs" + ], + "notes": "" + }, + { + "id": "numpy.cumsum", + "origin": "numpy", + "surface": "np", + "name": "cumsum", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cumsum", + "numsharp_signatures": [ + "NumSharp.NDArray cumsum(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cumsum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumsum.cs" + ], + "notes": "" + }, + { + "id": "numpy.cumulative_prod", + "origin": "numpy", + "surface": "np", + "name": "cumulative_prod", + "kind": "function", + "numpy_signature": "(x, /, *, axis=None, dtype=None, out=None, include_initial=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cumulative_prod.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cumprod", + "numsharp_signatures": [ + "NumSharp.NDArray cumprod(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cumprod.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumprod.cs" + ], + "notes": "NumSharp exposes the established cumprod spelling." + }, + { + "id": "numpy.cumulative_sum", + "origin": "numpy", + "surface": "np", + "name": "cumulative_sum", + "kind": "function", + "numpy_signature": "(x, /, *, axis=None, dtype=None, out=None, include_initial=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.cumulative_sum.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.cumsum", + "numsharp_signatures": [ + "NumSharp.NDArray cumsum(NumSharp.NDArray arr, int? axis = null, NumSharp.NPTypeCode? typeCode = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cumsum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cumsum.cs" + ], + "notes": "NumSharp exposes the established cumsum spelling." + }, + { + "id": "numpy.datetime64", + "origin": "numpy", + "surface": "np", + "name": "datetime64", + "kind": "class", + "numpy_signature": "(value=None, /, *args)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.datetime_as_string", + "origin": "numpy", + "surface": "np", + "name": "datetime_as_string", + "kind": "function", + "numpy_signature": "(arr, unit=None, timezone='naive', casting='same_kind')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.datetime_as_string.html", + "in_default_scope": true, + "category": "Date & time", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.datetime_data", + "origin": "numpy", + "surface": "np", + "name": "datetime_data", + "kind": "function", + "numpy_signature": "(dtype, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.datetime_data.html", + "in_default_scope": true, + "category": "Date & time", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.deg2rad", + "origin": "numpy", + "surface": "np", + "name": "deg2rad", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.deg2rad.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.deg2rad", + "numsharp_signatures": [ + "NumSharp.NDArray deg2rad(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray deg2rad(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray deg2rad(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.deg2rad.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.deg2rad.cs" + ], + "notes": "" + }, + { + "id": "numpy.degrees", + "origin": "numpy", + "surface": "np", + "name": "degrees", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.degrees.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.degrees", + "numsharp_signatures": [ + "NumSharp.NDArray degrees(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray degrees(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray degrees(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.rad2deg.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.rad2deg.cs" + ], + "notes": "" + }, + { + "id": "numpy.delete", + "origin": "numpy", + "surface": "np", + "name": "delete", + "kind": "function", + "numpy_signature": "(arr, obj, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.delete.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.delete", + "numsharp_signatures": [ + "NumSharp.NDArray delete(NumSharp.NDArray arr, NumSharp.NDArray obj, int? axis = null)", + "NumSharp.NDArray delete(NumSharp.NDArray arr, NumSharp.Slice obj, int? axis = null)", + "NumSharp.NDArray delete(NumSharp.NDArray arr, bool[] obj, int? axis = null)", + "NumSharp.NDArray delete(NumSharp.NDArray arr, int obj, int? axis = null)", + "NumSharp.NDArray delete(NumSharp.NDArray arr, int[] obj, int? axis = null)", + "NumSharp.NDArray delete(NumSharp.NDArray arr, long obj, int? axis = null)", + "NumSharp.NDArray delete(NumSharp.NDArray arr, long[] obj, int? axis = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.delete.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.delete.cs" + ], + "notes": "" + }, + { + "id": "numpy.diag", + "origin": "numpy", + "surface": "np", + "name": "diag", + "kind": "function", + "numpy_signature": "(v, k=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.diag.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.diag_indices", + "origin": "numpy", + "surface": "np", + "name": "diag_indices", + "kind": "function", + "numpy_signature": "(n, ndim=2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.diag_indices.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.diag_indices_from", + "origin": "numpy", + "surface": "np", + "name": "diag_indices_from", + "kind": "function", + "numpy_signature": "(arr)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.diag_indices_from.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.diagflat", + "origin": "numpy", + "surface": "np", + "name": "diagflat", + "kind": "function", + "numpy_signature": "(v, k=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.diagflat.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.diagonal", + "origin": "numpy", + "surface": "np", + "name": "diagonal", + "kind": "function", + "numpy_signature": "(a, offset=0, axis1=0, axis2=1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.diagonal.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.diagonal", + "numsharp_signatures": [ + "NumSharp.NDArray diagonal(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.diagonal.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.diagonal.cs" + ], + "notes": "" + }, + { + "id": "numpy.diff", + "origin": "numpy", + "surface": "np", + "name": "diff", + "kind": "function", + "numpy_signature": "(a, n=1, axis=-1, prepend=, append=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.diff.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.diff", + "numsharp_signatures": [ + "NumSharp.NDArray diff(NumSharp.NDArray a, int n = 1, int axis = -1, object prepend = null, object append = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.diff.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.diff.cs" + ], + "notes": "" + }, + { + "id": "numpy.digitize", + "origin": "numpy", + "surface": "np", + "name": "digitize", + "kind": "function", + "numpy_signature": "(x, bins, right=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.digitize.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.divide", + "origin": "numpy", + "surface": "np", + "name": "divide", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.divide.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.divide", + "numsharp_signatures": [ + "NumSharp.NDArray divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.divmod", + "origin": "numpy", + "surface": "np", + "name": "divmod", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.divmod.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.dot", + "origin": "numpy", + "surface": "np", + "name": "dot", + "kind": "function", + "numpy_signature": "(a, b, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.dot.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.dot", + "numsharp_signatures": [ + "NumSharp.NDArray dot(NumSharp.NDArray a, NumSharp.NDArray b)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/LinearAlgebra/np.dot.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.dot.cs" + ], + "notes": "" + }, + { + "id": "numpy.double", + "origin": "numpy", + "surface": "np", + "name": "double", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.double", + "numsharp_signatures": [ + "readonly System.Type double" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.dsplit", + "origin": "numpy", + "surface": "np", + "name": "dsplit", + "kind": "function", + "numpy_signature": "(ary, indices_or_sections)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.dsplit.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.dsplit", + "numsharp_signatures": [ + "NumSharp.NDArray[] dsplit(NumSharp.NDArray ary, int indices_or_sections)", + "NumSharp.NDArray[] dsplit(NumSharp.NDArray ary, int[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.dsplit.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.dsplit.cs" + ], + "notes": "" + }, + { + "id": "numpy.dstack", + "origin": "numpy", + "surface": "np", + "name": "dstack", + "kind": "function", + "numpy_signature": "(tup)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.dstack.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.dstack", + "numsharp_signatures": [ + "NumSharp.NDArray dstack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.dstack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.dstack.cs" + ], + "notes": "" + }, + { + "id": "numpy.dtype", + "origin": "numpy", + "surface": "np", + "name": "dtype", + "kind": "class", + "numpy_signature": "(dtype, align=False, copy=False, **kwargs)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.dtype", + "numsharp_signatures": [ + "NumSharp.DType dtype(string dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.dtype.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.dtype.cs" + ], + "notes": "" + }, + { + "id": "numpy.dtypes", + "origin": "numpy", + "surface": "np", + "name": "dtypes", + "kind": "module", + "numpy_signature": "This module is home to specific dtypes related functionality and their classes.", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.e", + "origin": "numpy", + "surface": "np", + "name": "e", + "kind": "constant", + "numpy_signature": "Convert a string or number to a floating-point number, if possible.", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.e", + "numsharp_signatures": [ + "double e { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ediff1d", + "origin": "numpy", + "surface": "np", + "name": "ediff1d", + "kind": "function", + "numpy_signature": "(ary, to_end=None, to_begin=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ediff1d.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ediff1d", + "numsharp_signatures": [ + "NumSharp.NDArray ediff1d(NumSharp.NDArray ary, object to_end = null, object to_begin = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.ediff1d.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.ediff1d.cs" + ], + "notes": "" + }, + { + "id": "numpy.einsum", + "origin": "numpy", + "surface": "np", + "name": "einsum", + "kind": "function", + "numpy_signature": "(*operands, out=None, optimize=False, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.einsum.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.einsum_path", + "origin": "numpy", + "surface": "np", + "name": "einsum_path", + "kind": "function", + "numpy_signature": "(*operands, optimize='greedy', einsum_call=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.einsum_path.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.emath", + "origin": "numpy", + "surface": "np", + "name": "emath", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.empty", + "origin": "numpy", + "surface": "np", + "name": "empty", + "kind": "function", + "numpy_signature": "(shape, dtype=None, order='C', *, device=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.empty.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.empty", + "numsharp_signatures": [ + "NumSharp.NDArray empty(NumSharp.Shape shape)", + "NumSharp.NDArray empty(NumSharp.Shape shape, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray empty(NumSharp.Shape shape, System.Type dtype)", + "NumSharp.NDArray empty(NumSharp.Shape shape, char order, System.Type dtype = null)", + "NumSharp.NDArray empty(int shape)", + "NumSharp.NDArray empty(int[] shape)", + "NumSharp.NDArray empty(int[] shape)", + "NumSharp.NDArray empty(long[] shape)", + "NumSharp.NDArray empty(long[] shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.empty.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.empty.cs" + ], + "notes": "" + }, + { + "id": "numpy.empty_like", + "origin": "numpy", + "surface": "np", + "name": "empty_like", + "kind": "function", + "numpy_signature": "(prototype, /, dtype=None, order='K', subok=True, shape=None, *, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.empty_like.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.empty_like", + "numsharp_signatures": [ + "NumSharp.NDArray empty_like(NumSharp.NDArray prototype, NumSharp.NPTypeCode typeCode, NumSharp.Shape shape = null)", + "NumSharp.NDArray empty_like(NumSharp.NDArray prototype, NumSharp.NPTypeCode typeCode, NumSharp.Shape shape, char order)", + "NumSharp.NDArray empty_like(NumSharp.NDArray prototype, System.Type dtype = null, NumSharp.Shape shape = null)", + "NumSharp.NDArray empty_like(NumSharp.NDArray prototype, System.Type dtype, NumSharp.Shape shape, char order)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.empty_like.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.empty_like.cs" + ], + "notes": "" + }, + { + "id": "numpy.equal", + "origin": "numpy", + "surface": "np", + "name": "equal", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.equal.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.equal", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray equal(NumSharp.NDArray x1, object x2)", + "NumSharp.Generic.NDArray equal(object x1, NumSharp.NDArray x2)", + "NumSharp.NDArray equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.comparison.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs" + ], + "notes": "" + }, + { + "id": "numpy.errstate", + "origin": "numpy", + "surface": "np", + "name": "errstate", + "kind": "class", + "numpy_signature": "(*, call=, all=None, divide=None, over=None, under=None, invalid=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.euler_gamma", + "origin": "numpy", + "surface": "np", + "name": "euler_gamma", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.euler_gamma", + "numsharp_signatures": [ + "double euler_gamma { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.exceptions", + "origin": "numpy", + "surface": "np", + "name": "exceptions", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.exp", + "origin": "numpy", + "surface": "np", + "name": "exp", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.exp.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.exp", + "numsharp_signatures": [ + "NumSharp.NDArray exp(NumSharp.NDArray a)", + "NumSharp.NDArray exp(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray exp(NumSharp.NDArray a, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray exp(NumSharp.NDArray a, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.exp.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.exp.cs" + ], + "notes": "" + }, + { + "id": "numpy.exp2", + "origin": "numpy", + "surface": "np", + "name": "exp2", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.exp2.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.exp2", + "numsharp_signatures": [ + "NumSharp.NDArray exp2(NumSharp.NDArray a)", + "NumSharp.NDArray exp2(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray exp2(NumSharp.NDArray a, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray exp2(NumSharp.NDArray a, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.exp.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.exp.cs" + ], + "notes": "" + }, + { + "id": "numpy.expand_dims", + "origin": "numpy", + "surface": "np", + "name": "expand_dims", + "kind": "function", + "numpy_signature": "(a, axis)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.expand_dims.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.expand_dims", + "numsharp_signatures": [ + "NumSharp.NDArray expand_dims(NumSharp.NDArray a, System.Collections.Generic.IEnumerable axis)", + "NumSharp.NDArray expand_dims(NumSharp.NDArray a, int axis)", + "NumSharp.NDArray expand_dims(NumSharp.NDArray a, int[] axis)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.expand_dims.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.expand_dims.cs" + ], + "notes": "" + }, + { + "id": "numpy.expm1", + "origin": "numpy", + "surface": "np", + "name": "expm1", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.expm1.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.expm1", + "numsharp_signatures": [ + "NumSharp.NDArray expm1(NumSharp.NDArray a)", + "NumSharp.NDArray expm1(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray expm1(NumSharp.NDArray a, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray expm1(NumSharp.NDArray a, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.exp.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.exp.cs" + ], + "notes": "" + }, + { + "id": "numpy.extract", + "origin": "numpy", + "surface": "np", + "name": "extract", + "kind": "function", + "numpy_signature": "(condition, arr)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.extract.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.extract", + "numsharp_signatures": [ + "NumSharp.NDArray extract(NumSharp.NDArray condition, NumSharp.NDArray arr)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.extract.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.extract.cs" + ], + "notes": "" + }, + { + "id": "numpy.eye", + "origin": "numpy", + "surface": "np", + "name": "eye", + "kind": "function", + "numpy_signature": "(N, M=None, k=0, dtype=, order='C', *, device=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.eye.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.eye", + "numsharp_signatures": [ + "NumSharp.NDArray eye(int N, int? M = null, int k = 0, System.Type dtype = null, char order = 'C')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.eye.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.eye.cs" + ], + "notes": "" + }, + { + "id": "numpy.f2py", + "origin": "numpy", + "surface": "np", + "name": "f2py", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fabs", + "origin": "numpy", + "surface": "np", + "name": "fabs", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fabs.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.False_", + "origin": "numpy", + "surface": "np", + "name": "False_", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fft", + "origin": "numpy", + "surface": "np", + "name": "fft", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fill_diagonal", + "origin": "numpy", + "surface": "np", + "name": "fill_diagonal", + "kind": "function", + "numpy_signature": "(a, val, wrap=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fill_diagonal.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.finfo", + "origin": "numpy", + "surface": "np", + "name": "finfo", + "kind": "class", + "numpy_signature": "(dtype)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.finfo", + "numsharp_signatures": [ + "NumSharp.finfo finfo()", + "NumSharp.finfo finfo(NumSharp.NDArray arr)", + "NumSharp.finfo finfo(NumSharp.NPTypeCode typeCode)", + "NumSharp.finfo finfo(System.Type type)", + "NumSharp.finfo finfo(string dtypeName)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.finfo.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.finfo.cs" + ], + "notes": "" + }, + { + "id": "numpy.fix", + "origin": "numpy", + "surface": "np", + "name": "fix", + "kind": "function", + "numpy_signature": "(x, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fix.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.flatiter", + "origin": "numpy", + "surface": "np", + "name": "flatiter", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.flatnonzero", + "origin": "numpy", + "surface": "np", + "name": "flatnonzero", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.flatnonzero.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.flatnonzero", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray flatnonzero(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.flatnonzero.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.flatnonzero.cs" + ], + "notes": "" + }, + { + "id": "numpy.flexible", + "origin": "numpy", + "surface": "np", + "name": "flexible", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.flip", + "origin": "numpy", + "surface": "np", + "name": "flip", + "kind": "function", + "numpy_signature": "(m, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.flip.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.flip", + "numsharp_signatures": [ + "NumSharp.NDArray flip(NumSharp.NDArray m, int? axis = null)", + "NumSharp.NDArray flip(NumSharp.NDArray m, int[] axis)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.flip.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.flip.cs" + ], + "notes": "" + }, + { + "id": "numpy.fliplr", + "origin": "numpy", + "surface": "np", + "name": "fliplr", + "kind": "function", + "numpy_signature": "(m)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fliplr.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.fliplr", + "numsharp_signatures": [ + "NumSharp.NDArray fliplr(NumSharp.NDArray m)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.flip.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.flip.cs" + ], + "notes": "" + }, + { + "id": "numpy.flipud", + "origin": "numpy", + "surface": "np", + "name": "flipud", + "kind": "function", + "numpy_signature": "(m)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.flipud.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.flipud", + "numsharp_signatures": [ + "NumSharp.NDArray flipud(NumSharp.NDArray m)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.flip.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.flip.cs" + ], + "notes": "" + }, + { + "id": "numpy.float16", + "origin": "numpy", + "surface": "np", + "name": "float16", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.float16", + "numsharp_signatures": [ + "readonly System.Type float16" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.float32", + "origin": "numpy", + "surface": "np", + "name": "float32", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.float32", + "numsharp_signatures": [ + "readonly System.Type float32" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.float64", + "origin": "numpy", + "surface": "np", + "name": "float64", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.float64", + "numsharp_signatures": [ + "readonly System.Type float64" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.float_power", + "origin": "numpy", + "surface": "np", + "name": "float_power", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.float_power.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.floating", + "origin": "numpy", + "surface": "np", + "name": "floating", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.floor", + "origin": "numpy", + "surface": "np", + "name": "floor", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.floor.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.floor", + "numsharp_signatures": [ + "NumSharp.NDArray floor(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray floor(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray floor(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.floor.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.floor.cs" + ], + "notes": "" + }, + { + "id": "numpy.floor_divide", + "origin": "numpy", + "surface": "np", + "name": "floor_divide", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.floor_divide.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.floor_divide", + "numsharp_signatures": [ + "NumSharp.NDArray floor_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray floor_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray floor_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)", + "NumSharp.NDArray floor_divide(NumSharp.NDArray x1, object x2)", + "NumSharp.NDArray floor_divide(NumSharp.NDArray x1, object x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray floor_divide(NumSharp.NDArray x1, object x2, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.floor_divide.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.floor_divide.cs" + ], + "notes": "" + }, + { + "id": "numpy.fmax", + "origin": "numpy", + "surface": "np", + "name": "fmax", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fmax.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.fmax", + "numsharp_signatures": [ + "NumSharp.NDArray fmax(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out)", + "NumSharp.NDArray fmax(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray fmax(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.maximum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.maximum.cs" + ], + "notes": "" + }, + { + "id": "numpy.fmin", + "origin": "numpy", + "surface": "np", + "name": "fmin", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fmin.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.fmin", + "numsharp_signatures": [ + "NumSharp.NDArray fmin(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out)", + "NumSharp.NDArray fmin(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray fmin(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.minimum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.minimum.cs" + ], + "notes": "" + }, + { + "id": "numpy.fmod", + "origin": "numpy", + "surface": "np", + "name": "fmod", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fmod.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.format_float_positional", + "origin": "numpy", + "surface": "np", + "name": "format_float_positional", + "kind": "function", + "numpy_signature": "(x, precision=None, unique=True, fractional=True, trim='k', sign=False, pad_left=None, pad_right=None, min_digits=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.format_float_positional.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.format_float_positional", + "numsharp_signatures": [ + "string format_float_positional(double x, int? precision = null, bool unique = true, bool fractional = true, char trim = 'k', bool sign = false, int? pad_left = null, int? pad_right = null, int? min_digits = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.format_float_scientific", + "origin": "numpy", + "surface": "np", + "name": "format_float_scientific", + "kind": "function", + "numpy_signature": "(x, precision=None, unique=True, trim='k', sign=False, pad_left=None, exp_digits=None, min_digits=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.format_float_scientific.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.format_float_scientific", + "numsharp_signatures": [ + "string format_float_scientific(double x, int? precision = null, bool unique = true, char trim = 'k', bool sign = false, int? pad_left = null, int? exp_digits = null, int? min_digits = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.frexp", + "origin": "numpy", + "surface": "np", + "name": "frexp", + "kind": "ufunc", + "numpy_signature": "(x, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.frexp.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.from_dlpack", + "origin": "numpy", + "surface": "np", + "name": "from_dlpack", + "kind": "function", + "numpy_signature": "(x, /, *, device=None, copy=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.from_dlpack.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.frombuffer", + "origin": "numpy", + "surface": "np", + "name": "frombuffer", + "kind": "function", + "numpy_signature": "(buffer, dtype=None, count=-1, offset=0, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.frombuffer.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.frombuffer", + "numsharp_signatures": [ + "NumSharp.NDArray frombuffer(System.ArraySegment segment, NumSharp.NPTypeCode dtype, long count = -1)", + "NumSharp.NDArray frombuffer(System.ArraySegment segment, System.Type dtype = null, long count = -1)", + "NumSharp.NDArray frombuffer(System.IntPtr address, long byteLength, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0, System.Action dispose = null)", + "NumSharp.NDArray frombuffer(System.IntPtr address, long byteLength, System.Type dtype = null, long count = -1, long offset = 0, System.Action dispose = null)", + "NumSharp.NDArray frombuffer(System.Memory memory, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(System.Memory memory, System.Type dtype = null, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(System.ReadOnlySpan buffer, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(System.ReadOnlySpan buffer, System.Type dtype = null, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(System.Void* address, long byteLength, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0, System.Action dispose = null)", + "NumSharp.NDArray frombuffer(System.Void* address, long byteLength, System.Type dtype = null, long count = -1, long offset = 0, System.Action dispose = null)", + "NumSharp.NDArray frombuffer(TSource[] array, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(TSource[] array, System.Type dtype = null, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(byte[] buffer, NumSharp.NPTypeCode dtype, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(byte[] buffer, System.Type dtype = null, long count = -1, long offset = 0)", + "NumSharp.NDArray frombuffer(byte[] buffer, string dtype, long count = -1, long offset = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.frombuffer.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.frombuffer.cs" + ], + "notes": "" + }, + { + "id": "numpy.fromfile", + "origin": "numpy", + "surface": "np", + "name": "fromfile", + "kind": "function", + "numpy_signature": "(file, dtype=None, count=-1, sep='', offset=0, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fromfile.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.fromfile", + "numsharp_signatures": [ + "NumSharp.NDArray fromfile(System.IO.Stream stream, NumSharp.NPTypeCode dtype, int count = -1, string sep = \"\", long offset = 0)", + "NumSharp.NDArray fromfile(System.IO.Stream stream, System.Type dtype = null, int count = -1, string sep = \"\", long offset = 0)", + "NumSharp.NDArray fromfile(string file, NumSharp.NPTypeCode dtype, int count = -1, string sep = \"\", long offset = 0)", + "NumSharp.NDArray fromfile(string file, System.Type dtype = null, int count = -1, string sep = \"\", long offset = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.fromfile.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.fromfile.cs" + ], + "notes": "" + }, + { + "id": "numpy.fromfunction", + "origin": "numpy", + "surface": "np", + "name": "fromfunction", + "kind": "function", + "numpy_signature": "(function, shape, *, dtype=, like=None, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fromfunction.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fromiter", + "origin": "numpy", + "surface": "np", + "name": "fromiter", + "kind": "function", + "numpy_signature": "(iter, dtype, count=-1, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fromiter.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.frompyfunc", + "origin": "numpy", + "surface": "np", + "name": "frompyfunc", + "kind": "function", + "numpy_signature": "(func, /, nin, nout, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.frompyfunc.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fromregex", + "origin": "numpy", + "surface": "np", + "name": "fromregex", + "kind": "function", + "numpy_signature": "(file, regexp, dtype, encoding=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fromregex.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.fromstring", + "origin": "numpy", + "surface": "np", + "name": "fromstring", + "kind": "function", + "numpy_signature": "fromstring(string, dtype=float, count=-1, *, sep, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.fromstring.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.full", + "origin": "numpy", + "surface": "np", + "name": "full", + "kind": "function", + "numpy_signature": "(shape, fill_value, dtype=None, order='C', *, device=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.full.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.full", + "numsharp_signatures": [ + "NumSharp.NDArray full(NumSharp.Shape shape, object fill_value, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray full(NumSharp.Shape shape, object fill_value, System.Type dtype = null)", + "NumSharp.NDArray full(int[] shape, object fill_value)", + "NumSharp.NDArray full(int[] shape, object fill_value)", + "NumSharp.NDArray full(long[] shape, object fill_value)", + "NumSharp.NDArray full(long[] shape, object fill_value)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.full.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.full.cs" + ], + "notes": "" + }, + { + "id": "numpy.full_like", + "origin": "numpy", + "surface": "np", + "name": "full_like", + "kind": "function", + "numpy_signature": "(a, fill_value, dtype=None, order='K', subok=True, shape=None, *, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.full_like.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.full_like", + "numsharp_signatures": [ + "NumSharp.NDArray full_like(NumSharp.NDArray a, object fill_value, System.Type dtype = null)", + "NumSharp.NDArray full_like(NumSharp.NDArray a, object fill_value, System.Type dtype, char order)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.full_like.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.full_like.cs" + ], + "notes": "" + }, + { + "id": "numpy.gcd", + "origin": "numpy", + "surface": "np", + "name": "gcd", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.gcd.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.generic", + "origin": "numpy", + "surface": "np", + "name": "generic", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.genfromtxt", + "origin": "numpy", + "surface": "np", + "name": "genfromtxt", + "kind": "function", + "numpy_signature": "(fname, dtype=, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=\" !#$%&'()*+,-./:;<=>?@[\\\\]^{|}~\", replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding=None, *, ndmin=0, l…", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.genfromtxt.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.geomspace", + "origin": "numpy", + "surface": "np", + "name": "geomspace", + "kind": "function", + "numpy_signature": "(start, stop, num=50, endpoint=True, dtype=None, axis=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.geomspace.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.get_include", + "origin": "numpy", + "surface": "np", + "name": "get_include", + "kind": "function", + "numpy_signature": "()", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.get_include.html", + "in_default_scope": true, + "category": "Runtime & diagnostics", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.get_printoptions", + "origin": "numpy", + "surface": "np", + "name": "get_printoptions", + "kind": "function", + "numpy_signature": "()", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.get_printoptions.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.get_printoptions", + "numsharp_signatures": [ + "System.Collections.Generic.IReadOnlyDictionary get_printoptions()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.getbufsize", + "origin": "numpy", + "surface": "np", + "name": "getbufsize", + "kind": "function", + "numpy_signature": "()", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.getbufsize.html", + "in_default_scope": true, + "category": "Floating-point handling", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.geterr", + "origin": "numpy", + "surface": "np", + "name": "geterr", + "kind": "function", + "numpy_signature": "()", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.geterr.html", + "in_default_scope": true, + "category": "Floating-point handling", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.geterrcall", + "origin": "numpy", + "surface": "np", + "name": "geterrcall", + "kind": "function", + "numpy_signature": "()", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.geterrcall.html", + "in_default_scope": true, + "category": "Floating-point handling", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.gradient", + "origin": "numpy", + "surface": "np", + "name": "gradient", + "kind": "function", + "numpy_signature": "(f, *varargs, axis=None, edge_order=1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.gradient.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.greater", + "origin": "numpy", + "surface": "np", + "name": "greater", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.greater.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.greater", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray greater(NumSharp.NDArray x1, object x2)", + "NumSharp.Generic.NDArray greater(object x1, NumSharp.NDArray x2)", + "NumSharp.NDArray greater(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.comparison.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs" + ], + "notes": "" + }, + { + "id": "numpy.greater_equal", + "origin": "numpy", + "surface": "np", + "name": "greater_equal", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.greater_equal.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.greater_equal", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray greater_equal(NumSharp.NDArray x1, object x2)", + "NumSharp.Generic.NDArray greater_equal(object x1, NumSharp.NDArray x2)", + "NumSharp.NDArray greater_equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.comparison.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs" + ], + "notes": "" + }, + { + "id": "numpy.half", + "origin": "numpy", + "surface": "np", + "name": "half", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.half", + "numsharp_signatures": [ + "readonly System.Type half" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.hamming", + "origin": "numpy", + "surface": "np", + "name": "hamming", + "kind": "function", + "numpy_signature": "(M)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.hamming.html", + "in_default_scope": true, + "category": "Window functions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.hanning", + "origin": "numpy", + "surface": "np", + "name": "hanning", + "kind": "function", + "numpy_signature": "(M)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.hanning.html", + "in_default_scope": true, + "category": "Window functions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.heaviside", + "origin": "numpy", + "surface": "np", + "name": "heaviside", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.heaviside.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.histogram", + "origin": "numpy", + "surface": "np", + "name": "histogram", + "kind": "function", + "numpy_signature": "(a, bins=10, range=None, density=None, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.histogram.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.histogram2d", + "origin": "numpy", + "surface": "np", + "name": "histogram2d", + "kind": "function", + "numpy_signature": "(x, y, bins=10, range=None, density=None, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.histogram2d.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.histogram_bin_edges", + "origin": "numpy", + "surface": "np", + "name": "histogram_bin_edges", + "kind": "function", + "numpy_signature": "(a, bins=10, range=None, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.histogram_bin_edges.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.histogramdd", + "origin": "numpy", + "surface": "np", + "name": "histogramdd", + "kind": "function", + "numpy_signature": "(sample, bins=10, range=None, density=None, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.histogramdd.html", + "in_default_scope": true, + "category": "Statistics & histograms", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.hsplit", + "origin": "numpy", + "surface": "np", + "name": "hsplit", + "kind": "function", + "numpy_signature": "(ary, indices_or_sections)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.hsplit.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.hsplit", + "numsharp_signatures": [ + "NumSharp.NDArray[] hsplit(NumSharp.NDArray ary, int indices_or_sections)", + "NumSharp.NDArray[] hsplit(NumSharp.NDArray ary, int[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.hsplit.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.hsplit.cs" + ], + "notes": "" + }, + { + "id": "numpy.hstack", + "origin": "numpy", + "surface": "np", + "name": "hstack", + "kind": "function", + "numpy_signature": "(tup, *, dtype=None, casting='same_kind')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.hstack.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.hstack", + "numsharp_signatures": [ + "NumSharp.NDArray hstack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.hstack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.hstack.cs" + ], + "notes": "" + }, + { + "id": "numpy.hypot", + "origin": "numpy", + "surface": "np", + "name": "hypot", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.hypot.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.i0", + "origin": "numpy", + "surface": "np", + "name": "i0", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.i0.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.identity", + "origin": "numpy", + "surface": "np", + "name": "identity", + "kind": "function", + "numpy_signature": "(n, dtype=None, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.identity.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.identity", + "numsharp_signatures": [ + "NumSharp.NDArray identity(int n, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.eye.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.eye.cs" + ], + "notes": "" + }, + { + "id": "numpy.iinfo", + "origin": "numpy", + "surface": "np", + "name": "iinfo", + "kind": "class", + "numpy_signature": "(int_type)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.iinfo", + "numsharp_signatures": [ + "NumSharp.iinfo iinfo()", + "NumSharp.iinfo iinfo(NumSharp.NDArray arr)", + "NumSharp.iinfo iinfo(NumSharp.NPTypeCode typeCode)", + "NumSharp.iinfo iinfo(System.Type type)", + "NumSharp.iinfo iinfo(string dtypeName)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.iinfo.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.iinfo.cs" + ], + "notes": "" + }, + { + "id": "numpy.imag", + "origin": "numpy", + "surface": "np", + "name": "imag", + "kind": "function", + "numpy_signature": "(val)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.imag.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.index_exp", + "origin": "numpy", + "surface": "np", + "name": "index_exp", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.indices", + "origin": "numpy", + "surface": "np", + "name": "indices", + "kind": "function", + "numpy_signature": "(dimensions, dtype=, sparse=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.indices.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.indices", + "numsharp_signatures": [ + "NumSharp.NDArray indices(int[] dimensions, NumSharp.NPTypeCode dtype = NumSharp.NPTypeCode.Int64)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.indices.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.indices.cs" + ], + "notes": "" + }, + { + "id": "numpy.inexact", + "origin": "numpy", + "surface": "np", + "name": "inexact", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.inf", + "origin": "numpy", + "surface": "np", + "name": "inf", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.inf", + "numsharp_signatures": [ + "double inf { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.info", + "origin": "numpy", + "surface": "np", + "name": "info", + "kind": "function", + "numpy_signature": "(object=None, maxwidth=76, output=None, toplevel='numpy')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.info.html", + "in_default_scope": true, + "category": "Runtime & diagnostics", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.inner", + "origin": "numpy", + "surface": "np", + "name": "inner", + "kind": "function", + "numpy_signature": "(a, b, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.inner.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.insert", + "origin": "numpy", + "surface": "np", + "name": "insert", + "kind": "function", + "numpy_signature": "(arr, obj, values, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.insert.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.insert", + "numsharp_signatures": [ + "NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.NDArray obj, NumSharp.NDArray values, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.NDArray obj, object value, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.Slice obj, NumSharp.NDArray values, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, NumSharp.Slice obj, object value, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, int obj, NumSharp.NDArray values, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, int obj, object value, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, int[] obj, NumSharp.NDArray values, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, int[] obj, object value, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, long obj, NumSharp.NDArray values, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, long obj, object value, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, long[] obj, NumSharp.NDArray values, int? axis = null)", + "NumSharp.NDArray insert(NumSharp.NDArray arr, long[] obj, object value, int? axis = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.insert.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.insert.cs" + ], + "notes": "" + }, + { + "id": "numpy.int16", + "origin": "numpy", + "surface": "np", + "name": "int16", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.int16", + "numsharp_signatures": [ + "readonly System.Type int16" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.int32", + "origin": "numpy", + "surface": "np", + "name": "int32", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.int32", + "numsharp_signatures": [ + "readonly System.Type int32" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.int64", + "origin": "numpy", + "surface": "np", + "name": "int64", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.int64", + "numsharp_signatures": [ + "readonly System.Type int64" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.int8", + "origin": "numpy", + "surface": "np", + "name": "int8", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.int8", + "numsharp_signatures": [ + "readonly System.Type int8" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.int_", + "origin": "numpy", + "surface": "np", + "name": "int_", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.int_", + "numsharp_signatures": [ + "readonly System.Type int_" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.intc", + "origin": "numpy", + "surface": "np", + "name": "intc", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.intc", + "numsharp_signatures": [ + "readonly System.Type intc" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.integer", + "origin": "numpy", + "surface": "np", + "name": "integer", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.interp", + "origin": "numpy", + "surface": "np", + "name": "interp", + "kind": "function", + "numpy_signature": "(x, xp, fp, left=None, right=None, period=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.interp.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.intersect1d", + "origin": "numpy", + "surface": "np", + "name": "intersect1d", + "kind": "function", + "numpy_signature": "(ar1, ar2, assume_unique=False, return_indices=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.intersect1d.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.intp", + "origin": "numpy", + "surface": "np", + "name": "intp", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.intp", + "numsharp_signatures": [ + "readonly System.Type intp" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.invert", + "origin": "numpy", + "surface": "np", + "name": "invert", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.invert.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.invert", + "numsharp_signatures": [ + "NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray invert(NumSharp.NDArray x, NumSharp.NPTypeCode outType)", + "NumSharp.NDArray invert(NumSharp.NDArray x, System.Type outType)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.invert.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.invert.cs" + ], + "notes": "" + }, + { + "id": "numpy.is_busday", + "origin": "numpy", + "surface": "np", + "name": "is_busday", + "kind": "function", + "numpy_signature": "(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.is_busday.html", + "in_default_scope": true, + "category": "Date & time", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.isclose", + "origin": "numpy", + "surface": "np", + "name": "isclose", + "kind": "function", + "numpy_signature": "(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isclose.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isclose", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray isclose(NumSharp.NDArray a, NumSharp.NDArray b, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.is.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs" + ], + "notes": "" + }, + { + "id": "numpy.iscomplex", + "origin": "numpy", + "surface": "np", + "name": "iscomplex", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.iscomplex.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.iscomplex", + "numsharp_signatures": [ + "NumSharp.NDArray iscomplex(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "notes": "" + }, + { + "id": "numpy.iscomplexobj", + "origin": "numpy", + "surface": "np", + "name": "iscomplexobj", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.iscomplexobj.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.iscomplexobj", + "numsharp_signatures": [ + "bool iscomplexobj(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "notes": "" + }, + { + "id": "numpy.isdtype", + "origin": "numpy", + "surface": "np", + "name": "isdtype", + "kind": "function", + "numpy_signature": "(dtype, kind)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isdtype.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isdtype", + "numsharp_signatures": [ + "bool isdtype(NumSharp.NDArray arr, string kind)", + "bool isdtype(NumSharp.NDArray arr, string[] kinds)", + "bool isdtype(NumSharp.NPTypeCode dtype, string kind)", + "bool isdtype(NumSharp.NPTypeCode dtype, string[] kinds)", + "bool isdtype(System.Type type, string kind)", + "bool isdtype(System.Type type, string[] kinds)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "notes": "" + }, + { + "id": "numpy.isfinite", + "origin": "numpy", + "surface": "np", + "name": "isfinite", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isfinite.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isfinite", + "numsharp_signatures": [ + "NumSharp.NDArray isfinite(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.is.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs" + ], + "notes": "" + }, + { + "id": "numpy.isfortran", + "origin": "numpy", + "surface": "np", + "name": "isfortran", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isfortran.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.isin", + "origin": "numpy", + "surface": "np", + "name": "isin", + "kind": "function", + "numpy_signature": "(element, test_elements, assume_unique=False, invert=False, *, kind=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isin.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.isinf", + "origin": "numpy", + "surface": "np", + "name": "isinf", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isinf.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isinf", + "numsharp_signatures": [ + "NumSharp.NDArray isinf(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.is.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs" + ], + "notes": "" + }, + { + "id": "numpy.isnan", + "origin": "numpy", + "surface": "np", + "name": "isnan", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isnan.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isnan", + "numsharp_signatures": [ + "NumSharp.NDArray isnan(NumSharp.NDArray a, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.is.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs" + ], + "notes": "" + }, + { + "id": "numpy.isnat", + "origin": "numpy", + "surface": "np", + "name": "isnat", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isnat.html", + "in_default_scope": true, + "category": "Date & time", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.isneginf", + "origin": "numpy", + "surface": "np", + "name": "isneginf", + "kind": "function", + "numpy_signature": "(x, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isneginf.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.isposinf", + "origin": "numpy", + "surface": "np", + "name": "isposinf", + "kind": "function", + "numpy_signature": "(x, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isposinf.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.isreal", + "origin": "numpy", + "surface": "np", + "name": "isreal", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isreal.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isreal", + "numsharp_signatures": [ + "NumSharp.NDArray isreal(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "notes": "" + }, + { + "id": "numpy.isrealobj", + "origin": "numpy", + "surface": "np", + "name": "isrealobj", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isrealobj.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isrealobj", + "numsharp_signatures": [ + "bool isrealobj(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.isreal_iscomplex.cs" + ], + "notes": "" + }, + { + "id": "numpy.isscalar", + "origin": "numpy", + "surface": "np", + "name": "isscalar", + "kind": "function", + "numpy_signature": "(element)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.isscalar.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.isscalar", + "numsharp_signatures": [ + "bool isscalar(object obj)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.is.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.is.cs" + ], + "notes": "" + }, + { + "id": "numpy.issubdtype", + "origin": "numpy", + "surface": "np", + "name": "issubdtype", + "kind": "function", + "numpy_signature": "(arg1, arg2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.issubdtype.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.issubdtype", + "numsharp_signatures": [ + "bool issubdtype(NumSharp.NDArray arr, string arg2)", + "bool issubdtype(NumSharp.NPTypeCode arg1, NumSharp.NPTypeCode arg2)", + "bool issubdtype(NumSharp.NPTypeCode arg1, string arg2)", + "bool issubdtype(System.Type arg1, System.Type arg2)", + "bool issubdtype(System.Type arg1, string arg2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.issubdtype.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.issubdtype.cs" + ], + "notes": "" + }, + { + "id": "numpy.iterable", + "origin": "numpy", + "surface": "np", + "name": "iterable", + "kind": "function", + "numpy_signature": "(y)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.iterable.html", + "in_default_scope": true, + "category": "Array metadata & memory", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ix_", + "origin": "numpy", + "surface": "np", + "name": "ix_", + "kind": "function", + "numpy_signature": "(*args)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ix_.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.kaiser", + "origin": "numpy", + "surface": "np", + "name": "kaiser", + "kind": "function", + "numpy_signature": "(M, beta)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.kaiser.html", + "in_default_scope": true, + "category": "Window functions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.kron", + "origin": "numpy", + "surface": "np", + "name": "kron", + "kind": "function", + "numpy_signature": "(a, b)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.kron.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.lcm", + "origin": "numpy", + "surface": "np", + "name": "lcm", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.lcm.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ldexp", + "origin": "numpy", + "surface": "np", + "name": "ldexp", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ldexp.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.left_shift", + "origin": "numpy", + "surface": "np", + "name": "left_shift", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.left_shift.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.left_shift", + "numsharp_signatures": [ + "NumSharp.NDArray left_shift(NumSharp.NDArray x1, NumSharp.NDArray x2)", + "NumSharp.NDArray left_shift(NumSharp.NDArray x1, object x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.left_shift.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.left_shift.cs" + ], + "notes": "" + }, + { + "id": "numpy.less", + "origin": "numpy", + "surface": "np", + "name": "less", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.less.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.less", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray less(NumSharp.NDArray x1, object x2)", + "NumSharp.Generic.NDArray less(object x1, NumSharp.NDArray x2)", + "NumSharp.NDArray less(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.comparison.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs" + ], + "notes": "" + }, + { + "id": "numpy.less_equal", + "origin": "numpy", + "surface": "np", + "name": "less_equal", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.less_equal.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.less_equal", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray less_equal(NumSharp.NDArray x1, object x2)", + "NumSharp.Generic.NDArray less_equal(object x1, NumSharp.NDArray x2)", + "NumSharp.NDArray less_equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.comparison.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs" + ], + "notes": "" + }, + { + "id": "numpy.lexsort", + "origin": "numpy", + "surface": "np", + "name": "lexsort", + "kind": "function", + "numpy_signature": "(keys, axis=-1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.lexsort.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.lib", + "origin": "numpy", + "surface": "np", + "name": "lib", + "kind": "module", + "numpy_signature": "``numpy.lib`` is mostly a space for implementing functions that don't", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linalg", + "origin": "numpy", + "surface": "np", + "name": "linalg", + "kind": "module", + "numpy_signature": "``numpy.linalg``", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.linspace", + "origin": "numpy", + "surface": "np", + "name": "linspace", + "kind": "function", + "numpy_signature": "(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, *, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.linspace.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.linspace", + "numsharp_signatures": [ + "NumSharp.NDArray linspace(double start, double stop, int num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double)", + "NumSharp.NDArray linspace(double start, double stop, int num, bool endpoint, System.Type dtype)", + "NumSharp.NDArray linspace(double start, double stop, long num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double)", + "NumSharp.NDArray linspace(double start, double stop, long num, bool endpoint, System.Type dtype)", + "NumSharp.NDArray linspace(float start, float stop, int num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double)", + "NumSharp.NDArray linspace(float start, float stop, int num, bool endpoint, System.Type dtype)", + "NumSharp.NDArray linspace(float start, float stop, long num, bool endpoint = true, NumSharp.NPTypeCode typeCode = NumSharp.NPTypeCode.Double)", + "NumSharp.NDArray linspace(float start, float stop, long num, bool endpoint, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.linspace.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.linspace.cs" + ], + "notes": "" + }, + { + "id": "numpy.little_endian", + "origin": "numpy", + "surface": "np", + "name": "little_endian", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.load", + "origin": "numpy", + "surface": "np", + "name": "load", + "kind": "function", + "numpy_signature": "(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII', *, max_header_size=10000)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.load.html", + "in_default_scope": true, + "category": "Input & output", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.load", + "numsharp_signatures": [ + "object load(System.IO.Stream file, string mmap_mode = null, bool allow_pickle = false, bool fix_imports = true, string encoding = \"ASCII\", long max_header_size = 10000)", + "object load(byte[] bytes, string mmap_mode = null, bool allow_pickle = false, bool fix_imports = true, string encoding = \"ASCII\", long max_header_size = 10000)", + "object load(string file, string mmap_mode = null, bool allow_pickle = false, bool fix_imports = true, string encoding = \"ASCII\", long max_header_size = 10000)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.load.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.load.cs" + ], + "notes": "" + }, + { + "id": "numpy.loadtxt", + "origin": "numpy", + "surface": "np", + "name": "loadtxt", + "kind": "function", + "numpy_signature": "(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=None, max_rows=None, *, quotechar=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.loadtxt.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.log", + "origin": "numpy", + "surface": "np", + "name": "log", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.log.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.log", + "numsharp_signatures": [ + "NumSharp.NDArray log(NumSharp.NDArray x)", + "NumSharp.NDArray log(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray log(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray log(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.log.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs" + ], + "notes": "" + }, + { + "id": "numpy.log10", + "origin": "numpy", + "surface": "np", + "name": "log10", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.log10.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.log10", + "numsharp_signatures": [ + "NumSharp.NDArray log10(NumSharp.NDArray x)", + "NumSharp.NDArray log10(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray log10(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray log10(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.log.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs" + ], + "notes": "" + }, + { + "id": "numpy.log1p", + "origin": "numpy", + "surface": "np", + "name": "log1p", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.log1p.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.log1p", + "numsharp_signatures": [ + "NumSharp.NDArray log1p(NumSharp.NDArray x)", + "NumSharp.NDArray log1p(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray log1p(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray log1p(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.log.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs" + ], + "notes": "" + }, + { + "id": "numpy.log2", + "origin": "numpy", + "surface": "np", + "name": "log2", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.log2.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.log2", + "numsharp_signatures": [ + "NumSharp.NDArray log2(NumSharp.NDArray x)", + "NumSharp.NDArray log2(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray log2(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray log2(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.log.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.log.cs" + ], + "notes": "" + }, + { + "id": "numpy.logaddexp", + "origin": "numpy", + "surface": "np", + "name": "logaddexp", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.logaddexp.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.logaddexp2", + "origin": "numpy", + "surface": "np", + "name": "logaddexp2", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.logaddexp2.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.logical_and", + "origin": "numpy", + "surface": "np", + "name": "logical_and", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.logical_and.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.logical_and", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray logical_and(NumSharp.NDArray x1, NumSharp.NDArray x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.logical.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs" + ], + "notes": "" + }, + { + "id": "numpy.logical_not", + "origin": "numpy", + "surface": "np", + "name": "logical_not", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.logical_not.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.logical_not", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray logical_not(NumSharp.NDArray x)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.logical.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs" + ], + "notes": "" + }, + { + "id": "numpy.logical_or", + "origin": "numpy", + "surface": "np", + "name": "logical_or", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.logical_or.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.logical_or", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray logical_or(NumSharp.NDArray x1, NumSharp.NDArray x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.logical.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs" + ], + "notes": "" + }, + { + "id": "numpy.logical_xor", + "origin": "numpy", + "surface": "np", + "name": "logical_xor", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.logical_xor.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.logical_xor", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray logical_xor(NumSharp.NDArray x1, NumSharp.NDArray x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.logical.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.logical.cs" + ], + "notes": "" + }, + { + "id": "numpy.logspace", + "origin": "numpy", + "surface": "np", + "name": "logspace", + "kind": "function", + "numpy_signature": "(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.logspace.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.long", + "origin": "numpy", + "surface": "np", + "name": "long", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.long", + "numsharp_signatures": [ + "readonly System.Type long" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.longdouble", + "origin": "numpy", + "surface": "np", + "name": "longdouble", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.longlong", + "origin": "numpy", + "surface": "np", + "name": "longlong", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.longlong", + "numsharp_signatures": [ + "readonly System.Type longlong" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ma", + "origin": "numpy", + "surface": "np", + "name": "ma", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.mask_indices", + "origin": "numpy", + "surface": "np", + "name": "mask_indices", + "kind": "function", + "numpy_signature": "(n, mask_func, k=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.mask_indices.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.matmul", + "origin": "numpy", + "surface": "np", + "name": "matmul", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.matmul.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.matmul", + "numsharp_signatures": [ + "NumSharp.NDArray matmul(NumSharp.NDArray x1, NumSharp.NDArray x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/LinearAlgebra/np.matmul.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.matmul.cs" + ], + "notes": "" + }, + { + "id": "numpy.matrix", + "origin": "numpy", + "surface": "np", + "name": "matrix", + "kind": "class", + "numpy_signature": "(data, dtype=None, copy=True)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.matrix_transpose", + "origin": "numpy", + "surface": "np", + "name": "matrix_transpose", + "kind": "function", + "numpy_signature": "(x, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.matrix_transpose.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.matrix_transpose", + "numsharp_signatures": [ + "NumSharp.NDArray matrix_transpose(NumSharp.NDArray x)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.matrix_transpose.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.matrix_transpose.cs" + ], + "notes": "" + }, + { + "id": "numpy.matvec", + "origin": "numpy", + "surface": "np", + "name": "matvec", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.matvec.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.max", + "origin": "numpy", + "surface": "np", + "name": "max", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.max.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.max", + "numsharp_signatures": [ + "NumSharp.NDArray max(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.amax.cs" + ], + "notes": "" + }, + { + "id": "numpy.maximum", + "origin": "numpy", + "surface": "np", + "name": "maximum", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.maximum.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.maximum", + "numsharp_signatures": [ + "NumSharp.NDArray maximum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out)", + "NumSharp.NDArray maximum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray maximum(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.maximum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.maximum.cs" + ], + "notes": "" + }, + { + "id": "numpy.may_share_memory", + "origin": "numpy", + "surface": "np", + "name": "may_share_memory", + "kind": "function", + "numpy_signature": "(a, b, /, max_work=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.may_share_memory.html", + "in_default_scope": true, + "category": "Array metadata & memory", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.mean", + "origin": "numpy", + "surface": "np", + "name": "mean", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, keepdims=, *, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.mean.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.mean", + "numsharp_signatures": [ + "NumSharp.NDArray mean(NumSharp.NDArray a)", + "NumSharp.NDArray mean(NumSharp.NDArray a, bool keepdims)", + "NumSharp.NDArray mean(NumSharp.NDArray a, int axis)", + "NumSharp.NDArray mean(NumSharp.NDArray a, int axis, NumSharp.NPTypeCode type, bool keepdims = false)", + "NumSharp.NDArray mean(NumSharp.NDArray a, int axis, System.Type dtype, bool keepdims = false)", + "NumSharp.NDArray mean(NumSharp.NDArray a, int axis, bool keepdims)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.mean.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.mean.cs" + ], + "notes": "" + }, + { + "id": "numpy.median", + "origin": "numpy", + "surface": "np", + "name": "median", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, overwrite_input=False, keepdims=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.median.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.median", + "numsharp_signatures": [ + "NumSharp.NDArray median(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false)", + "NumSharp.NDArray median(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.median.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.median.cs" + ], + "notes": "" + }, + { + "id": "numpy.memmap", + "origin": "numpy", + "surface": "np", + "name": "memmap", + "kind": "class", + "numpy_signature": "(filename, dtype=, mode='r+', offset=0, shape=None, order='C')", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.meshgrid", + "origin": "numpy", + "surface": "np", + "name": "meshgrid", + "kind": "function", + "numpy_signature": "(*xi, copy=True, sparse=False, indexing='xy')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.meshgrid.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.meshgrid", + "numsharp_signatures": [ + "System.ValueTuple meshgrid(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.Kwargs kwargs = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.meshgrid.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.meshgrid.cs" + ], + "notes": "" + }, + { + "id": "numpy.mgrid", + "origin": "numpy", + "surface": "np", + "name": "mgrid", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.mgrid", + "numsharp_signatures": [ + "System.ValueTuple mgrid(NumSharp.NDArray lhs, NumSharp.NDArray rhs)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.mgrid.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.mgrid.cs" + ], + "notes": "" + }, + { + "id": "numpy.min", + "origin": "numpy", + "surface": "np", + "name": "min", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.min.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.min", + "numsharp_signatures": [ + "NumSharp.NDArray min(NumSharp.NDArray a, int? axis = null, bool keepdims = false, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.min.cs" + ], + "notes": "" + }, + { + "id": "numpy.min_scalar_type", + "origin": "numpy", + "surface": "np", + "name": "min_scalar_type", + "kind": "function", + "numpy_signature": "(a, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.min_scalar_type.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.min_scalar_type", + "numsharp_signatures": [ + "NumSharp.NPTypeCode min_scalar_type(object value)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.min_scalar_type.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.min_scalar_type.cs" + ], + "notes": "" + }, + { + "id": "numpy.minimum", + "origin": "numpy", + "surface": "np", + "name": "minimum", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.minimum.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.minimum", + "numsharp_signatures": [ + "NumSharp.NDArray minimum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out)", + "NumSharp.NDArray minimum(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray minimum(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.minimum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.minimum.cs" + ], + "notes": "" + }, + { + "id": "numpy.mintypecode", + "origin": "numpy", + "surface": "np", + "name": "mintypecode", + "kind": "function", + "numpy_signature": "(typechars, typeset='GDFgdf', default='d')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.mintypecode.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.mintypecode", + "numsharp_signatures": [ + "char mintypecode(char[] typechars, string typeset = \"GDFgdf\", char default = 'd')", + "char mintypecode(string typechars, string typeset = \"GDFgdf\", char default = 'd')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.dtype.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.dtype.cs" + ], + "notes": "" + }, + { + "id": "numpy.mod", + "origin": "numpy", + "surface": "np", + "name": "mod", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.mod.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.mod", + "numsharp_signatures": [ + "NumSharp.NDArray mod(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray mod(NumSharp.NDArray x1, float x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.modf", + "origin": "numpy", + "surface": "np", + "name": "modf", + "kind": "ufunc", + "numpy_signature": "(x, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.modf.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.modf", + "numsharp_signatures": [ + "System.ValueTuple modf(NumSharp.NDArray x, NumSharp.NPTypeCode? dtype = null)", + "System.ValueTuple modf(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.modf.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.modf.cs" + ], + "notes": "" + }, + { + "id": "numpy.moveaxis", + "origin": "numpy", + "surface": "np", + "name": "moveaxis", + "kind": "function", + "numpy_signature": "(a, source, destination)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.moveaxis.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.moveaxis", + "numsharp_signatures": [ + "NumSharp.NDArray moveaxis(NumSharp.NDArray a, int source, int destination)", + "NumSharp.NDArray moveaxis(NumSharp.NDArray a, int source, int[] destination)", + "NumSharp.NDArray moveaxis(NumSharp.NDArray a, int[] source, int destination)", + "NumSharp.NDArray moveaxis(NumSharp.NDArray a, int[] source, int[] destination)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.moveaxis.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.moveaxis.cs" + ], + "notes": "" + }, + { + "id": "numpy.multiply", + "origin": "numpy", + "surface": "np", + "name": "multiply", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.multiply.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.multiply", + "numsharp_signatures": [ + "NumSharp.NDArray multiply(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.nan", + "origin": "numpy", + "surface": "np", + "name": "nan", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nan", + "numsharp_signatures": [ + "double nan { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.nan_to_num", + "origin": "numpy", + "surface": "np", + "name": "nan_to_num", + "kind": "function", + "numpy_signature": "(x, copy=True, nan=0.0, posinf=None, neginf=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nan_to_num.html", + "in_default_scope": true, + "category": "Floating-point handling", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.nanargmax", + "origin": "numpy", + "surface": "np", + "name": "nanargmax", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, *, keepdims=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanargmax.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.nanargmin", + "origin": "numpy", + "surface": "np", + "name": "nanargmin", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, *, keepdims=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanargmin.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.nancumprod", + "origin": "numpy", + "surface": "np", + "name": "nancumprod", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nancumprod.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.nancumsum", + "origin": "numpy", + "surface": "np", + "name": "nancumsum", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nancumsum.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.nanmax", + "origin": "numpy", + "surface": "np", + "name": "nanmax", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanmax.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanmax", + "numsharp_signatures": [ + "NumSharp.NDArray nanmax(NumSharp.NDArray a, int? axis = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.nanmax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.nanmax.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanmean", + "origin": "numpy", + "surface": "np", + "name": "nanmean", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, keepdims=, *, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanmean.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanmean", + "numsharp_signatures": [ + "NumSharp.NDArray nanmean(NumSharp.NDArray a, int? axis = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.nanmean.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanmean.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanmedian", + "origin": "numpy", + "surface": "np", + "name": "nanmedian", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, overwrite_input=False, keepdims=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanmedian.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanmedian", + "numsharp_signatures": [ + "NumSharp.NDArray nanmedian(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false)", + "NumSharp.NDArray nanmedian(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.nanmedian.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanmedian.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanmin", + "origin": "numpy", + "surface": "np", + "name": "nanmin", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanmin.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanmin", + "numsharp_signatures": [ + "NumSharp.NDArray nanmin(NumSharp.NDArray a, int? axis = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.nanmin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.nanmin.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanpercentile", + "origin": "numpy", + "surface": "np", + "name": "nanpercentile", + "kind": "function", + "numpy_signature": "(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=, *, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanpercentile.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanpercentile", + "numsharp_signatures": [ + "NumSharp.NDArray nanpercentile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanpercentile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.nanpercentile.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanpercentile.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanprod", + "origin": "numpy", + "surface": "np", + "name": "nanprod", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanprod.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanprod", + "numsharp_signatures": [ + "NumSharp.NDArray nanprod(NumSharp.NDArray a, int? axis = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.nanprod.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.nanprod.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanquantile", + "origin": "numpy", + "surface": "np", + "name": "nanquantile", + "kind": "function", + "numpy_signature": "(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=, *, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanquantile.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanquantile", + "numsharp_signatures": [ + "NumSharp.NDArray nanquantile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanquantile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanquantile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanquantile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray nanquantile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.nanquantile.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanquantile.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanstd", + "origin": "numpy", + "surface": "np", + "name": "nanstd", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanstd.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanstd", + "numsharp_signatures": [ + "NumSharp.NDArray nanstd(NumSharp.NDArray a, int? axis = null, bool keepdims = false, int ddof = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.nanstd.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanstd.cs" + ], + "notes": "" + }, + { + "id": "numpy.nansum", + "origin": "numpy", + "surface": "np", + "name": "nansum", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nansum.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nansum", + "numsharp_signatures": [ + "NumSharp.NDArray nansum(NumSharp.NDArray a, int? axis = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.nansum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.nansum.cs" + ], + "notes": "" + }, + { + "id": "numpy.nanvar", + "origin": "numpy", + "surface": "np", + "name": "nanvar", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nanvar.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nanvar", + "numsharp_signatures": [ + "NumSharp.NDArray nanvar(NumSharp.NDArray a, int? axis = null, bool keepdims = false, int ddof = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.nanvar.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.nanvar.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndarray", + "origin": "numpy", + "surface": "np", + "name": "ndarray", + "kind": "class", + "numpy_signature": "(shape, dtype=None, buffer=None, offset=0, strides=None, order=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NDArray", + "numsharp_signatures": [ + "NumSharp.NDArray" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "" + }, + { + "id": "numpy.ndenumerate", + "origin": "numpy", + "surface": "np", + "name": "ndenumerate", + "kind": "class", + "numpy_signature": "(arr)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndim", + "origin": "numpy", + "surface": "np", + "name": "ndim", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ndim.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ndindex", + "origin": "numpy", + "surface": "np", + "name": "ndindex", + "kind": "class", + "numpy_signature": "(*shape)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.nditer", + "origin": "numpy", + "surface": "np", + "name": "nditer", + "kind": "class", + "numpy_signature": "(op, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', op_axes=None, itershape=None, buffersize=0)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.negative", + "origin": "numpy", + "surface": "np", + "name": "negative", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.negative.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.negative", + "numsharp_signatures": [ + "NumSharp.NDArray negative(NumSharp.NDArray nd, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.nested_iters", + "origin": "numpy", + "surface": "np", + "name": "nested_iters", + "kind": "function", + "numpy_signature": "(op, axes, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', buffersize=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nested_iters.html", + "in_default_scope": true, + "category": "Array metadata & memory", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.newaxis", + "origin": "numpy", + "surface": "np", + "name": "newaxis", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.newaxis", + "numsharp_signatures": [ + "readonly NumSharp.Slice newaxis" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.nextafter", + "origin": "numpy", + "surface": "np", + "name": "nextafter", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nextafter.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.nonzero", + "origin": "numpy", + "surface": "np", + "name": "nonzero", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.nonzero.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.nonzero", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray[] nonzero(NumSharp.NDArray a)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.nonzero.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.nonzero.cs" + ], + "notes": "" + }, + { + "id": "numpy.not_equal", + "origin": "numpy", + "surface": "np", + "name": "not_equal", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.not_equal.html", + "in_default_scope": true, + "category": "Logic & comparison", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.not_equal", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray not_equal(NumSharp.NDArray x1, object x2)", + "NumSharp.Generic.NDArray not_equal(object x1, NumSharp.NDArray x2)", + "NumSharp.NDArray not_equal(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.comparison.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.comparison.cs" + ], + "notes": "" + }, + { + "id": "numpy.number", + "origin": "numpy", + "surface": "np", + "name": "number", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.object_", + "origin": "numpy", + "surface": "np", + "name": "object_", + "kind": "class", + "numpy_signature": "(value=None, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ogrid", + "origin": "numpy", + "surface": "np", + "name": "ogrid", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ones", + "origin": "numpy", + "surface": "np", + "name": "ones", + "kind": "function", + "numpy_signature": "(shape, dtype=None, order='C', *, device=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ones.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ones", + "numsharp_signatures": [ + "NumSharp.NDArray ones(NumSharp.Shape shape)", + "NumSharp.NDArray ones(NumSharp.Shape shape, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray ones(NumSharp.Shape shape, System.Type dtype)", + "NumSharp.NDArray ones(int shape)", + "NumSharp.NDArray ones(int[] shape)", + "NumSharp.NDArray ones(int[] shape)", + "NumSharp.NDArray ones(int[] shape, System.Type dtype)", + "NumSharp.NDArray ones(long[] shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.ones.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.ones.cs" + ], + "notes": "" + }, + { + "id": "numpy.ones_like", + "origin": "numpy", + "surface": "np", + "name": "ones_like", + "kind": "function", + "numpy_signature": "(a, dtype=None, order='K', subok=True, shape=None, *, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ones_like.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ones_like", + "numsharp_signatures": [ + "NumSharp.NDArray ones_like(NumSharp.NDArray a, System.Type dtype = null)", + "NumSharp.NDArray ones_like(NumSharp.NDArray a, System.Type dtype, char order)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.ones_like.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.ones_like.cs" + ], + "notes": "" + }, + { + "id": "numpy.outer", + "origin": "numpy", + "surface": "np", + "name": "outer", + "kind": "function", + "numpy_signature": "(a, b, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.outer.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.outer", + "numsharp_signatures": [ + "NumSharp.NDArray outer(NumSharp.NDArray a, NumSharp.NDArray b)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/LinearAlgebra/np.outer.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/LinearAlgebra/np.outer.cs" + ], + "notes": "" + }, + { + "id": "numpy.packbits", + "origin": "numpy", + "surface": "np", + "name": "packbits", + "kind": "function", + "numpy_signature": "(a, /, axis=None, bitorder='big')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.packbits.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.pad", + "origin": "numpy", + "surface": "np", + "name": "pad", + "kind": "function", + "numpy_signature": "(array, pad_width, mode='constant', **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.pad.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.pad", + "numsharp_signatures": [ + "NumSharp.NDArray pad(NumSharp.NDArray array, System.Collections.Generic.IDictionary pad_width, NumSharp.np+PadFunc mode, object kwargs = null)", + "NumSharp.NDArray pad(NumSharp.NDArray array, System.Collections.Generic.IDictionary pad_width, string mode = \"constant\", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = \"even\")", + "NumSharp.NDArray pad(NumSharp.NDArray array, System.ValueTuple pad_width, NumSharp.np+PadFunc mode, object kwargs = null)", + "NumSharp.NDArray pad(NumSharp.NDArray array, System.ValueTuple pad_width, string mode = \"constant\", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = \"even\")", + "NumSharp.NDArray pad(NumSharp.NDArray array, int pad_width, NumSharp.np+PadFunc mode, object kwargs = null)", + "NumSharp.NDArray pad(NumSharp.NDArray array, int pad_width, string mode = \"constant\", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = \"even\")", + "NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, NumSharp.np+PadFunc mode, object kwargs = null)", + "NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, NumSharp.np+PadFunc mode, object kwargs = null)", + "NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, string mode = \"constant\", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = \"even\")", + "NumSharp.NDArray pad(NumSharp.NDArray array, int[] pad_width, string mode = \"constant\", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = \"even\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.pad.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.pad.cs" + ], + "notes": "" + }, + { + "id": "numpy.partition", + "origin": "numpy", + "surface": "np", + "name": "partition", + "kind": "function", + "numpy_signature": "(a, kth, axis=-1, kind='introselect', order=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.partition.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.percentile", + "origin": "numpy", + "surface": "np", + "name": "percentile", + "kind": "function", + "numpy_signature": "(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.percentile.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.percentile", + "numsharp_signatures": [ + "NumSharp.NDArray percentile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray percentile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray percentile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray percentile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray percentile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.percentile.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.percentile.cs" + ], + "notes": "" + }, + { + "id": "numpy.permute_dims", + "origin": "numpy", + "surface": "np", + "name": "permute_dims", + "kind": "function", + "numpy_signature": "(a, axes=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.permute_dims.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.permute_dims", + "numsharp_signatures": [ + "NumSharp.NDArray permute_dims(NumSharp.NDArray a, int[] axes = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.permute_dims.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.permute_dims.cs" + ], + "notes": "" + }, + { + "id": "numpy.pi", + "origin": "numpy", + "surface": "np", + "name": "pi", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.pi", + "numsharp_signatures": [ + "double pi { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.piecewise", + "origin": "numpy", + "surface": "np", + "name": "piecewise", + "kind": "function", + "numpy_signature": "(x, condlist, funclist, *args, **kw)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.piecewise.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.place", + "origin": "numpy", + "surface": "np", + "name": "place", + "kind": "function", + "numpy_signature": "(arr, mask, vals)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.place.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.place", + "numsharp_signatures": [ + "void place(NumSharp.NDArray arr, NumSharp.NDArray mask, NumSharp.NDArray vals)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.place.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.place.cs" + ], + "notes": "" + }, + { + "id": "numpy.poly", + "origin": "numpy", + "surface": "np", + "name": "poly", + "kind": "function", + "numpy_signature": "(seq_of_zeros)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.poly.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.poly1d", + "origin": "numpy", + "surface": "np", + "name": "poly1d", + "kind": "class", + "numpy_signature": "(c_or_r, r=False, variable=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polyadd", + "origin": "numpy", + "surface": "np", + "name": "polyadd", + "kind": "function", + "numpy_signature": "(a1, a2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polyadd.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polyder", + "origin": "numpy", + "surface": "np", + "name": "polyder", + "kind": "function", + "numpy_signature": "(p, m=1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polyder.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polydiv", + "origin": "numpy", + "surface": "np", + "name": "polydiv", + "kind": "function", + "numpy_signature": "(u, v)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polydiv.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polyfit", + "origin": "numpy", + "surface": "np", + "name": "polyfit", + "kind": "function", + "numpy_signature": "(x, y, deg, rcond=None, full=False, w=None, cov=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polyfit.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polyint", + "origin": "numpy", + "surface": "np", + "name": "polyint", + "kind": "function", + "numpy_signature": "(p, m=1, k=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polyint.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polymul", + "origin": "numpy", + "surface": "np", + "name": "polymul", + "kind": "function", + "numpy_signature": "(a1, a2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polymul.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polynomial", + "origin": "numpy", + "surface": "np", + "name": "polynomial", + "kind": "module", + "numpy_signature": "A sub-package for efficiently dealing with polynomials.", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polysub", + "origin": "numpy", + "surface": "np", + "name": "polysub", + "kind": "function", + "numpy_signature": "(a1, a2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polysub.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.polyval", + "origin": "numpy", + "surface": "np", + "name": "polyval", + "kind": "function", + "numpy_signature": "(p, x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.polyval.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.positive", + "origin": "numpy", + "surface": "np", + "name": "positive", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.positive.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.positive", + "numsharp_signatures": [ + "NumSharp.NDArray positive(NumSharp.NDArray nd, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.pow", + "origin": "numpy", + "surface": "np", + "name": "pow", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.pow.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.power", + "numsharp_signatures": [ + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2)", + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)", + "NumSharp.NDArray power(NumSharp.NDArray x1, object x2)", + "NumSharp.NDArray power(NumSharp.NDArray x1, object x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray power(NumSharp.NDArray x1, object x2, System.Type dtype)", + "NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2)", + "NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.power.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.power.cs" + ], + "notes": "NumSharp exposes the ufunc name power." + }, + { + "id": "numpy.power", + "origin": "numpy", + "surface": "np", + "name": "power", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.power.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.power", + "numsharp_signatures": [ + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2)", + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray power(NumSharp.NDArray x1, NumSharp.NDArray x2, System.Type dtype)", + "NumSharp.NDArray power(NumSharp.NDArray x1, object x2)", + "NumSharp.NDArray power(NumSharp.NDArray x1, object x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray power(NumSharp.NDArray x1, object x2, System.Type dtype)", + "NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2)", + "NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray power(ref NumSharp.NDArray x1, ref NumSharp.NDArray x2, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.power.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.power.cs" + ], + "notes": "" + }, + { + "id": "numpy.printoptions", + "origin": "numpy", + "surface": "np", + "name": "printoptions", + "kind": "function", + "numpy_signature": "(*args, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.printoptions.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.printoptions", + "numsharp_signatures": [ + "System.IDisposable printoptions(int? precision = null, int? threshold = null, int? edgeitems = null, int? linewidth = null, bool? suppress = null, string nanstr = null, string infstr = null, char? sign = null, string floatmode = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.prod", + "origin": "numpy", + "surface": "np", + "name": "prod", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.prod.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.prod", + "numsharp_signatures": [ + "NumSharp.NDArray prod(NumSharp.NDArray a, int? axis = null, System.Type dtype = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.promote_types", + "origin": "numpy", + "surface": "np", + "name": "promote_types", + "kind": "function", + "numpy_signature": "(type1, type2, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.promote_types.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.promote_types", + "numsharp_signatures": [ + "NumSharp.NPTypeCode promote_types()", + "NumSharp.NPTypeCode promote_types(NumSharp.NPTypeCode type1, NumSharp.NPTypeCode type2)", + "NumSharp.NPTypeCode promote_types(System.Type type1, System.Type type2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.promote_types.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.promote_types.cs" + ], + "notes": "" + }, + { + "id": "numpy.ptp", + "origin": "numpy", + "surface": "np", + "name": "ptp", + "kind": "function", + "numpy_signature": "(a, axis=None, out=None, keepdims=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ptp.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ptp", + "numsharp_signatures": [ + "NumSharp.NDArray ptp(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray out = null, bool keepdims = false)", + "NumSharp.NDArray ptp(NumSharp.NDArray a, int[] axis, NumSharp.NDArray out = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.ptp.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.ptp.cs" + ], + "notes": "" + }, + { + "id": "numpy.put", + "origin": "numpy", + "surface": "np", + "name": "put", + "kind": "function", + "numpy_signature": "(a, ind, v, mode='raise')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.put.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.put", + "numsharp_signatures": [ + "void put(NumSharp.NDArray a, NumSharp.NDArray indices, NumSharp.NDArray values, string mode = \"raise\")", + "void put(NumSharp.NDArray a, long index, object value, string mode = \"raise\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.put.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.put.cs" + ], + "notes": "" + }, + { + "id": "numpy.put_along_axis", + "origin": "numpy", + "surface": "np", + "name": "put_along_axis", + "kind": "function", + "numpy_signature": "(arr, indices, values, axis)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.put_along_axis.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.putmask", + "origin": "numpy", + "surface": "np", + "name": "putmask", + "kind": "function", + "numpy_signature": "(a, /, mask, values)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.putmask.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.quantile", + "origin": "numpy", + "surface": "np", + "name": "quantile", + "kind": "function", + "numpy_signature": "(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.quantile.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.quantile", + "numsharp_signatures": [ + "NumSharp.NDArray quantile(NumSharp.NDArray a, NumSharp.NDArray q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray quantile(NumSharp.NDArray a, double q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray quantile(NumSharp.NDArray a, double q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray quantile(NumSharp.NDArray a, double[] q, int? axis = null, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)", + "NumSharp.NDArray quantile(NumSharp.NDArray a, double[] q, int[] axis, NumSharp.NDArray out = null, bool overwrite_input = false, string method = \"linear\", bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.quantile.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.quantile.cs" + ], + "notes": "" + }, + { + "id": "numpy.r_", + "origin": "numpy", + "surface": "np", + "name": "r_", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.rad2deg", + "origin": "numpy", + "surface": "np", + "name": "rad2deg", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.rad2deg.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.rad2deg", + "numsharp_signatures": [ + "NumSharp.NDArray rad2deg(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray rad2deg(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray rad2deg(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.rad2deg.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.rad2deg.cs" + ], + "notes": "" + }, + { + "id": "numpy.radians", + "origin": "numpy", + "surface": "np", + "name": "radians", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.radians.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.radians", + "numsharp_signatures": [ + "NumSharp.NDArray radians(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray radians(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray radians(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.deg2rad.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.deg2rad.cs" + ], + "notes": "" + }, + { + "id": "numpy.random", + "origin": "numpy", + "surface": "np", + "name": "random", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.random", + "numsharp_signatures": [ + "NumSharp.NumPyRandom random { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ravel", + "origin": "numpy", + "surface": "np", + "name": "ravel", + "kind": "function", + "numpy_signature": "(a, order='C')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ravel.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ravel", + "numsharp_signatures": [ + "NumSharp.NDArray ravel(NumSharp.NDArray a)", + "NumSharp.NDArray ravel(NumSharp.NDArray a, char order)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.ravel.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.ravel.cs" + ], + "notes": "" + }, + { + "id": "numpy.ravel_multi_index", + "origin": "numpy", + "surface": "np", + "name": "ravel_multi_index", + "kind": "function", + "numpy_signature": "(multi_index, dims, mode='raise', order='C')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.ravel_multi_index.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ravel_multi_index", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray ravel_multi_index(NumSharp.NDArray[] multi_index, int[] dims, string mode = \"raise\", char order = 'C')", + "NumSharp.Generic.NDArray ravel_multi_index(NumSharp.NDArray[] multi_index, int[] dims, string[] modes, char order = 'C')", + "long ravel_multi_index(long[] coords, int[] dims, string mode = \"raise\", char order = 'C')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.ravel_multi_index.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.ravel_multi_index.cs" + ], + "notes": "" + }, + { + "id": "numpy.real", + "origin": "numpy", + "surface": "np", + "name": "real", + "kind": "function", + "numpy_signature": "(val)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.real.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.real_if_close", + "origin": "numpy", + "surface": "np", + "name": "real_if_close", + "kind": "function", + "numpy_signature": "(a, tol=100)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.real_if_close.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.rec", + "origin": "numpy", + "surface": "np", + "name": "rec", + "kind": "module", + "numpy_signature": "This module contains a set of functions for record arrays.", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.recarray", + "origin": "numpy", + "surface": "np", + "name": "recarray", + "kind": "class", + "numpy_signature": "(shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C')", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.reciprocal", + "origin": "numpy", + "surface": "np", + "name": "reciprocal", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.reciprocal.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.reciprocal", + "numsharp_signatures": [ + "NumSharp.NDArray reciprocal(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray reciprocal(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray reciprocal(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.reciprocal.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.reciprocal.cs" + ], + "notes": "" + }, + { + "id": "numpy.record", + "origin": "numpy", + "surface": "np", + "name": "record", + "kind": "class", + "numpy_signature": "(length_or_data, /, dtype=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.remainder", + "origin": "numpy", + "surface": "np", + "name": "remainder", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.remainder.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.mod", + "numsharp_signatures": [ + "NumSharp.NDArray mod(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray mod(NumSharp.NDArray x1, float x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "NumSharp exposes the equivalent ufunc name mod." + }, + { + "id": "numpy.repeat", + "origin": "numpy", + "surface": "np", + "name": "repeat", + "kind": "function", + "numpy_signature": "(a, repeats, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.repeat.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.repeat", + "numsharp_signatures": [ + "NumSharp.NDArray repeat(NumSharp.NDArray a, NumSharp.NDArray repeats, int? axis = null)", + "NumSharp.NDArray repeat(NumSharp.NDArray a, int repeats, int? axis = null)", + "NumSharp.NDArray repeat(NumSharp.NDArray a, long repeats, int? axis = null)", + "NumSharp.NDArray repeat(T a, int repeats)", + "NumSharp.NDArray repeat(T a, long repeats)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.repeat.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.repeat.cs" + ], + "notes": "" + }, + { + "id": "numpy.require", + "origin": "numpy", + "surface": "np", + "name": "require", + "kind": "function", + "numpy_signature": "(a, dtype=None, requirements=None, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.require.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.require", + "numsharp_signatures": [ + "NumSharp.NDArray require(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, string requirements)", + "NumSharp.NDArray require(NumSharp.NDArray a, NumSharp.NPTypeCode dtype, string[] requirements = null)", + "NumSharp.NDArray require(NumSharp.NDArray a, System.Type dtype = null, string[] requirements = null, NumSharp.NDArray like = null)", + "NumSharp.NDArray require(NumSharp.NDArray a, System.Type dtype, string requirements)", + "NumSharp.NDArray require(NumSharp.NDArray a, string dtype, string requirements)", + "NumSharp.NDArray require(NumSharp.NDArray a, string dtype, string[] requirements = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.require.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.require.cs" + ], + "notes": "" + }, + { + "id": "numpy.reshape", + "origin": "numpy", + "surface": "np", + "name": "reshape", + "kind": "function", + "numpy_signature": "(a, /, shape, order='C', *, copy=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.reshape.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.reshape", + "numsharp_signatures": [ + "NumSharp.NDArray reshape(NumSharp.NDArray nd, NumSharp.Shape shape)", + "NumSharp.NDArray reshape(NumSharp.NDArray nd, int[] shape)", + "NumSharp.NDArray reshape(NumSharp.NDArray nd, long[] shape)", + "NumSharp.NDArray reshape(NumSharp.NDArray nd, ref NumSharp.Shape shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.reshape.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.reshape.cs" + ], + "notes": "" + }, + { + "id": "numpy.resize", + "origin": "numpy", + "surface": "np", + "name": "resize", + "kind": "function", + "numpy_signature": "(a, new_shape)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.resize.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.resize", + "numsharp_signatures": [ + "NumSharp.NDArray resize(NumSharp.NDArray a, NumSharp.Shape new_shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.resize.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.resize.cs" + ], + "notes": "" + }, + { + "id": "numpy.result_type", + "origin": "numpy", + "surface": "np", + "name": "result_type", + "kind": "function", + "numpy_signature": "(*arrays_and_dtypes)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.result_type.html", + "in_default_scope": true, + "category": "Dtype & promotion", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.result_type", + "numsharp_signatures": [ + "NumSharp.NPTypeCode result_type(NumSharp.NDArray arr1, NumSharp.NDArray arr2)", + "NumSharp.NPTypeCode result_type(NumSharp.NPTypeCode type1, NumSharp.NPTypeCode type2)", + "NumSharp.NPTypeCode result_type(System.Type type1, System.Type type2)", + "NumSharp.NPTypeCode result_type(params NumSharp.NDArray[] arrays)", + "NumSharp.NPTypeCode result_type(params NumSharp.NPTypeCode[] types)", + "NumSharp.NPTypeCode result_type(params object[] arrays_and_dtypes)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.result_type.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.result_type.cs" + ], + "notes": "" + }, + { + "id": "numpy.right_shift", + "origin": "numpy", + "surface": "np", + "name": "right_shift", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.right_shift.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.right_shift", + "numsharp_signatures": [ + "NumSharp.NDArray right_shift(NumSharp.NDArray x1, NumSharp.NDArray x2)", + "NumSharp.NDArray right_shift(NumSharp.NDArray x1, object x2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.right_shift.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.right_shift.cs" + ], + "notes": "" + }, + { + "id": "numpy.rint", + "origin": "numpy", + "surface": "np", + "name": "rint", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.rint.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.rint", + "numsharp_signatures": [ + "NumSharp.NDArray rint(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray rint(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray rint(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.rint.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.rint.cs" + ], + "notes": "" + }, + { + "id": "numpy.roll", + "origin": "numpy", + "surface": "np", + "name": "roll", + "kind": "function", + "numpy_signature": "(a, shift, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.roll.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.roll", + "numsharp_signatures": [ + "NumSharp.NDArray roll(NumSharp.NDArray a, int shift, int? axis = null)", + "NumSharp.NDArray roll(NumSharp.NDArray a, long shift, int? axis = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.roll.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.roll.cs" + ], + "notes": "" + }, + { + "id": "numpy.rollaxis", + "origin": "numpy", + "surface": "np", + "name": "rollaxis", + "kind": "function", + "numpy_signature": "(a, axis, start=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.rollaxis.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.rollaxis", + "numsharp_signatures": [ + "NumSharp.NDArray rollaxis(NumSharp.NDArray a, int axis, int start = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.rollaxis.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.rollaxis.cs" + ], + "notes": "" + }, + { + "id": "numpy.roots", + "origin": "numpy", + "surface": "np", + "name": "roots", + "kind": "function", + "numpy_signature": "(p)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.roots.html", + "in_default_scope": true, + "category": "Polynomials", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.rot90", + "origin": "numpy", + "surface": "np", + "name": "rot90", + "kind": "function", + "numpy_signature": "(m, k=1, axes=(0, 1))", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.rot90.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.rot90", + "numsharp_signatures": [ + "NumSharp.NDArray rot90(NumSharp.NDArray m, int k = 1, int[] axes = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.rot90.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.rot90.cs" + ], + "notes": "" + }, + { + "id": "numpy.round", + "origin": "numpy", + "surface": "np", + "name": "round", + "kind": "function", + "numpy_signature": "(a, decimals=0, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.round.html", + "in_default_scope": true, + "category": "Math", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.round_", + "numsharp_signatures": [ + "NumSharp.NDArray round_(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray round_(NumSharp.NDArray x, System.Type dtype)", + "NumSharp.NDArray round_(NumSharp.NDArray x, int decimals = 0, NumSharp.NDArray out = null)", + "NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray round_(NumSharp.NDArray x, int decimals, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.round.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.round.cs" + ], + "notes": "C# uses round_ to avoid a naming collision while preserving NumPy round semantics." + }, + { + "id": "numpy.row_stack", + "origin": "numpy", + "surface": "np", + "name": "row_stack", + "kind": "function", + "numpy_signature": "(tup, *, dtype=None, casting='same_kind')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.vstack.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.vstack", + "numsharp_signatures": [ + "NumSharp.NDArray vstack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.vstack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.vstack.cs" + ], + "notes": "NumPy documents row_stack as an alias of vstack." + }, + { + "id": "numpy.s_", + "origin": "numpy", + "surface": "np", + "name": "s_", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.save", + "origin": "numpy", + "surface": "np", + "name": "save", + "kind": "function", + "numpy_signature": "(file, arr, allow_pickle=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.save.html", + "in_default_scope": true, + "category": "Input & output", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.save", + "numsharp_signatures": [ + "byte[] save(NumSharp.NDArray arr, bool allow_pickle = true)", + "void save(System.IO.Stream file, NumSharp.NDArray arr, bool allow_pickle = true)", + "void save(string file, NumSharp.NDArray arr, bool allow_pickle = true)", + "void save(string file, System.Array arr, bool allow_pickle = true)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.save.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs" + ], + "notes": "" + }, + { + "id": "numpy.savetxt", + "origin": "numpy", + "surface": "np", + "name": "savetxt", + "kind": "function", + "numpy_signature": "(fname, X, fmt='%.18e', delimiter=' ', newline='\\n', header='', footer='', comments='# ', encoding=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.savetxt.html", + "in_default_scope": true, + "category": "Input & output", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.savez", + "origin": "numpy", + "surface": "np", + "name": "savez", + "kind": "function", + "numpy_signature": "(file, *args, allow_pickle=True, **kwds)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.savez.html", + "in_default_scope": true, + "category": "Input & output", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.savez", + "numsharp_signatures": [ + "byte[] savez(System.Collections.Generic.IDictionary kwds)", + "byte[] savez(params NumSharp.NDArray[] args)", + "void savez(System.IO.Stream file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true)", + "void savez(System.IO.Stream file, System.Collections.Generic.IDictionary kwds)", + "void savez(System.IO.Stream file, params NumSharp.NDArray[] args)", + "void savez(string file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true)", + "void savez(string file, System.Collections.Generic.IDictionary kwds)", + "void savez(string file, params NumSharp.NDArray[] args)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.save.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs" + ], + "notes": "" + }, + { + "id": "numpy.savez_compressed", + "origin": "numpy", + "surface": "np", + "name": "savez_compressed", + "kind": "function", + "numpy_signature": "(file, *args, allow_pickle=True, **kwds)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.savez_compressed.html", + "in_default_scope": true, + "category": "Input & output", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.savez_compressed", + "numsharp_signatures": [ + "byte[] savez_compressed(System.Collections.Generic.IDictionary kwds)", + "byte[] savez_compressed(params NumSharp.NDArray[] args)", + "void savez_compressed(System.IO.Stream file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true)", + "void savez_compressed(System.IO.Stream file, System.Collections.Generic.IDictionary kwds)", + "void savez_compressed(System.IO.Stream file, params NumSharp.NDArray[] args)", + "void savez_compressed(string file, NumSharp.NDArray[] args, System.Collections.Generic.IDictionary kwds, bool allow_pickle = true)", + "void savez_compressed(string file, System.Collections.Generic.IDictionary kwds)", + "void savez_compressed(string file, params NumSharp.NDArray[] args)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.save.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs" + ], + "notes": "" + }, + { + "id": "numpy.ScalarType", + "origin": "numpy", + "surface": "np", + "name": "ScalarType", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.sctypeDict", + "origin": "numpy", + "surface": "np", + "name": "sctypeDict", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.searchsorted", + "origin": "numpy", + "surface": "np", + "name": "searchsorted", + "kind": "function", + "numpy_signature": "(a, v, side='left', sorter=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.searchsorted", + "numsharp_signatures": [ + "NumSharp.NDArray searchsorted(NumSharp.NDArray a, NumSharp.NDArray v, string side = \"left\", NumSharp.NDArray sorter = null)", + "long searchsorted(NumSharp.NDArray a, double v, string side = \"left\", NumSharp.NDArray sorter = null)", + "long searchsorted(NumSharp.NDArray a, int v, string side = \"left\", NumSharp.NDArray sorter = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.searchsorted.cs" + ], + "notes": "" + }, + { + "id": "numpy.select", + "origin": "numpy", + "surface": "np", + "name": "select", + "kind": "function", + "numpy_signature": "(condlist, choicelist, default=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.select.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.set_printoptions", + "origin": "numpy", + "surface": "np", + "name": "set_printoptions", + "kind": "function", + "numpy_signature": "(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None, override_repr=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.set_printoptions.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.set_printoptions", + "numsharp_signatures": [ + "void set_printoptions(int? precision = null, int? threshold = null, int? edgeitems = null, int? linewidth = null, bool? suppress = null, string nanstr = null, string infstr = null, char? sign = null, string floatmode = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array2string.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array2string.cs" + ], + "notes": "" + }, + { + "id": "numpy.setbufsize", + "origin": "numpy", + "surface": "np", + "name": "setbufsize", + "kind": "function", + "numpy_signature": "(size)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.setbufsize.html", + "in_default_scope": true, + "category": "Floating-point handling", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.setdiff1d", + "origin": "numpy", + "surface": "np", + "name": "setdiff1d", + "kind": "function", + "numpy_signature": "(ar1, ar2, assume_unique=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.setdiff1d.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.seterr", + "origin": "numpy", + "surface": "np", + "name": "seterr", + "kind": "function", + "numpy_signature": "(all=None, divide=None, over=None, under=None, invalid=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.seterr.html", + "in_default_scope": true, + "category": "Floating-point handling", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.seterrcall", + "origin": "numpy", + "surface": "np", + "name": "seterrcall", + "kind": "function", + "numpy_signature": "(func)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.seterrcall.html", + "in_default_scope": true, + "category": "Floating-point handling", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.setxor1d", + "origin": "numpy", + "surface": "np", + "name": "setxor1d", + "kind": "function", + "numpy_signature": "(ar1, ar2, assume_unique=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.setxor1d.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.shape", + "origin": "numpy", + "surface": "np", + "name": "shape", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.shape.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "alias", + "support": "partial", + "status": "partial", + "numsharp_target": "NumSharp.NDArray.Shape", + "numsharp_signatures": [ + "NumSharp.Shape Shape { get; set; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp exposes shape as an NDArray Shape property rather than the top-level NumPy tuple-returning helper. NDArray.Shape is a NumSharp Shape value, not the tuple returned by numpy.shape." + }, + { + "id": "numpy.shares_memory", + "origin": "numpy", + "surface": "np", + "name": "shares_memory", + "kind": "function", + "numpy_signature": "(a, b, /, max_work=-1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.shares_memory.html", + "in_default_scope": true, + "category": "Array metadata & memory", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.short", + "origin": "numpy", + "surface": "np", + "name": "short", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.short", + "numsharp_signatures": [ + "readonly System.Type short" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.show_config", + "origin": "numpy", + "surface": "np", + "name": "show_config", + "kind": "function", + "numpy_signature": "(mode='stdout')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.show_config.html", + "in_default_scope": true, + "category": "Runtime & diagnostics", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.show_runtime", + "origin": "numpy", + "surface": "np", + "name": "show_runtime", + "kind": "function", + "numpy_signature": "()", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.show_runtime.html", + "in_default_scope": true, + "category": "Runtime & diagnostics", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.sign", + "origin": "numpy", + "surface": "np", + "name": "sign", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sign.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.sign", + "numsharp_signatures": [ + "NumSharp.NDArray sign(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray sign(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray sign(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.sign.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sign.cs" + ], + "notes": "" + }, + { + "id": "numpy.signbit", + "origin": "numpy", + "surface": "np", + "name": "signbit", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.signbit.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.signedinteger", + "origin": "numpy", + "surface": "np", + "name": "signedinteger", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.sin", + "origin": "numpy", + "surface": "np", + "name": "sin", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sin.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.sin", + "numsharp_signatures": [ + "NumSharp.NDArray sin(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray sin(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray sin(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.sin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs" + ], + "notes": "" + }, + { + "id": "numpy.sinc", + "origin": "numpy", + "surface": "np", + "name": "sinc", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sinc.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.single", + "origin": "numpy", + "surface": "np", + "name": "single", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.single", + "numsharp_signatures": [ + "readonly System.Type single" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.sinh", + "origin": "numpy", + "surface": "np", + "name": "sinh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sinh.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.sinh", + "numsharp_signatures": [ + "NumSharp.NDArray sinh(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray sinh(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray sinh(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.sin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sin.cs" + ], + "notes": "" + }, + { + "id": "numpy.size", + "origin": "numpy", + "surface": "np", + "name": "size", + "kind": "function", + "numpy_signature": "(a, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.size.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.size", + "numsharp_signatures": [ + "long size(NumSharp.NDArray a, int? axis = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.size.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.size.cs" + ], + "notes": "" + }, + { + "id": "numpy.sort", + "origin": "numpy", + "surface": "np", + "name": "sort", + "kind": "function", + "numpy_signature": "(a, axis=-1, kind=None, order=None, *, stable=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sort.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.sort", + "numsharp_signatures": [ + "NumSharp.NDArray sort(NumSharp.NDArray a, int? axis = -1, string kind = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Sorting_Searching_Counting/np.sort.cs" + ], + "notes": "" + }, + { + "id": "numpy.sort_complex", + "origin": "numpy", + "surface": "np", + "name": "sort_complex", + "kind": "function", + "numpy_signature": "(a)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sort_complex.html", + "in_default_scope": true, + "category": "Sorting & searching", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.spacing", + "origin": "numpy", + "surface": "np", + "name": "spacing", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.spacing.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.split", + "origin": "numpy", + "surface": "np", + "name": "split", + "kind": "function", + "numpy_signature": "(ary, indices_or_sections, axis=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.split.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.split", + "numsharp_signatures": [ + "NumSharp.NDArray[] split(NumSharp.NDArray ary, int indices_or_sections, int axis = 0)", + "NumSharp.NDArray[] split(NumSharp.NDArray ary, int[] indices, int axis = 0)", + "NumSharp.NDArray[] split(NumSharp.NDArray ary, long[] indices, int axis = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.split.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.split.cs" + ], + "notes": "" + }, + { + "id": "numpy.sqrt", + "origin": "numpy", + "surface": "np", + "name": "sqrt", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.sqrt", + "numsharp_signatures": [ + "NumSharp.NDArray sqrt(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray sqrt(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray sqrt(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.sqrt.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sqrt.cs" + ], + "notes": "" + }, + { + "id": "numpy.square", + "origin": "numpy", + "surface": "np", + "name": "square", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.square.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.square", + "numsharp_signatures": [ + "NumSharp.NDArray square(NumSharp.NDArray x)", + "NumSharp.NDArray square(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.power.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.power.cs" + ], + "notes": "" + }, + { + "id": "numpy.squeeze", + "origin": "numpy", + "surface": "np", + "name": "squeeze", + "kind": "function", + "numpy_signature": "(a, axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.squeeze.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.squeeze", + "numsharp_signatures": [ + "NumSharp.NDArray squeeze(NumSharp.NDArray a)", + "NumSharp.NDArray squeeze(NumSharp.NDArray a, int axis)", + "NumSharp.Shape squeeze(NumSharp.Shape shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.squeeze.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.squeeze.cs" + ], + "notes": "" + }, + { + "id": "numpy.stack", + "origin": "numpy", + "surface": "np", + "name": "stack", + "kind": "function", + "numpy_signature": "(arrays, axis=0, out=None, *, dtype=None, casting='same_kind')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.stack.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.stack", + "numsharp_signatures": [ + "NumSharp.NDArray stack(NumSharp.NDArray[] arrays, int axis = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.stack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.stack.cs" + ], + "notes": "" + }, + { + "id": "numpy.std", + "origin": "numpy", + "surface": "np", + "name": "std", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.std.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.std", + "numsharp_signatures": [ + "NumSharp.NDArray std(NumSharp.NDArray a, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray std(NumSharp.NDArray a, int axis, NumSharp.NPTypeCode type, bool keepdims = false, int? ddof = null)", + "NumSharp.NDArray std(NumSharp.NDArray a, int axis, System.Type dtype, bool keepdims = false, int? ddof = null)", + "NumSharp.NDArray std(NumSharp.NDArray a, int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.std.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.std.cs" + ], + "notes": "" + }, + { + "id": "numpy.str_", + "origin": "numpy", + "surface": "np", + "name": "str_", + "kind": "class", + "numpy_signature": "(value='', /, *args, **kwargs)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.strings", + "origin": "numpy", + "surface": "np", + "name": "strings", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.subtract", + "origin": "numpy", + "surface": "np", + "name": "subtract", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.subtract.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.subtract", + "numsharp_signatures": [ + "NumSharp.NDArray subtract(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.sum", + "origin": "numpy", + "surface": "np", + "name": "sum", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.sum.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.sum", + "numsharp_signatures": [ + "NumSharp.NDArray sum(NumSharp.NDArray a)", + "NumSharp.NDArray sum(NumSharp.NDArray a, NumSharp.NPTypeCode? typeCode)", + "NumSharp.NDArray sum(NumSharp.NDArray a, System.Type dtype)", + "NumSharp.NDArray sum(NumSharp.NDArray a, bool keepdims)", + "NumSharp.NDArray sum(NumSharp.NDArray a, int axis)", + "NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, NumSharp.NPTypeCode? typeCode)", + "NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, System.Type dtype)", + "NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, bool keepdims)", + "NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, bool keepdims, NumSharp.NPTypeCode? typeCode)", + "NumSharp.NDArray sum(NumSharp.NDArray a, int? axis, bool keepdims, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.sum.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.sum.cs" + ], + "notes": "" + }, + { + "id": "numpy.swapaxes", + "origin": "numpy", + "surface": "np", + "name": "swapaxes", + "kind": "function", + "numpy_signature": "(a, axis1, axis2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.swapaxes.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.swapaxes", + "numsharp_signatures": [ + "NumSharp.NDArray swapaxes(NumSharp.NDArray a, int axis1, int axis2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.swapaxes.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.swapaxes.cs" + ], + "notes": "" + }, + { + "id": "numpy.take", + "origin": "numpy", + "surface": "np", + "name": "take", + "kind": "function", + "numpy_signature": "(a, indices, axis=None, out=None, mode='raise')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.take.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.take", + "numsharp_signatures": [ + "NumSharp.NDArray take(NumSharp.NDArray a, NumSharp.NDArray indices, int? axis = null, NumSharp.NDArray out = null, string mode = \"raise\")", + "NumSharp.NDArray take(NumSharp.NDArray a, long index, int? axis = null, NumSharp.NDArray out = null, string mode = \"raise\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.take.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.take.cs" + ], + "notes": "" + }, + { + "id": "numpy.take_along_axis", + "origin": "numpy", + "surface": "np", + "name": "take_along_axis", + "kind": "function", + "numpy_signature": "(arr, indices, axis=-1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.take_along_axis.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.tan", + "origin": "numpy", + "surface": "np", + "name": "tan", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tan.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.tan", + "numsharp_signatures": [ + "NumSharp.NDArray tan(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray tan(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray tan(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.tan.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs" + ], + "notes": "" + }, + { + "id": "numpy.tanh", + "origin": "numpy", + "surface": "np", + "name": "tanh", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tanh.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.tanh", + "numsharp_signatures": [ + "NumSharp.NDArray tanh(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray tanh(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray tanh(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.tan.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.tan.cs" + ], + "notes": "" + }, + { + "id": "numpy.tensordot", + "origin": "numpy", + "surface": "np", + "name": "tensordot", + "kind": "function", + "numpy_signature": "(a, b, axes=2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tensordot.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.test", + "origin": "numpy", + "surface": "np", + "name": "test", + "kind": "function", + "numpy_signature": "(label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, durations=-1, tests=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/testing.html", + "in_default_scope": true, + "category": "Runtime & diagnostics", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.testing", + "origin": "numpy", + "surface": "np", + "name": "testing", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.tile", + "origin": "numpy", + "surface": "np", + "name": "tile", + "kind": "function", + "numpy_signature": "(A, reps)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tile.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.tile", + "numsharp_signatures": [ + "NumSharp.NDArray tile(NumSharp.NDArray A, long[] reps)", + "NumSharp.NDArray tile(NumSharp.NDArray A, params int[] reps)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.tile.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.tile.cs" + ], + "notes": "" + }, + { + "id": "numpy.timedelta64", + "origin": "numpy", + "surface": "np", + "name": "timedelta64", + "kind": "class", + "numpy_signature": "(value=0, /, *args)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.trace", + "origin": "numpy", + "surface": "np", + "name": "trace", + "kind": "function", + "numpy_signature": "(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.trace.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.trace", + "numsharp_signatures": [ + "NumSharp.NDArray trace(NumSharp.NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1, System.Type dtype = null, NumSharp.NDArray out = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.trace.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.trace.cs" + ], + "notes": "" + }, + { + "id": "numpy.transpose", + "origin": "numpy", + "surface": "np", + "name": "transpose", + "kind": "function", + "numpy_signature": "(a, axes=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.transpose.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.transpose", + "numsharp_signatures": [ + "NumSharp.NDArray transpose(NumSharp.NDArray a, int[] premute = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.transpose.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.transpose.cs" + ], + "notes": "" + }, + { + "id": "numpy.trapezoid", + "origin": "numpy", + "surface": "np", + "name": "trapezoid", + "kind": "function", + "numpy_signature": "(y, x=None, dx=1.0, axis=-1)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.trapezoid.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.tri", + "origin": "numpy", + "surface": "np", + "name": "tri", + "kind": "function", + "numpy_signature": "(N, M=None, k=0, dtype=, *, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tri.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.tril", + "origin": "numpy", + "surface": "np", + "name": "tril", + "kind": "function", + "numpy_signature": "(m, k=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tril.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.tril_indices", + "origin": "numpy", + "surface": "np", + "name": "tril_indices", + "kind": "function", + "numpy_signature": "(n, k=0, m=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tril_indices.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.tril_indices_from", + "origin": "numpy", + "surface": "np", + "name": "tril_indices_from", + "kind": "function", + "numpy_signature": "(arr, k=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.tril_indices_from.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.trim_zeros", + "origin": "numpy", + "surface": "np", + "name": "trim_zeros", + "kind": "function", + "numpy_signature": "(filt, trim='fb', axis=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.trim_zeros.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.trim_zeros", + "numsharp_signatures": [ + "NumSharp.NDArray trim_zeros(NumSharp.NDArray filt, string trim = \"fb\", int? axis = null)", + "NumSharp.NDArray trim_zeros(NumSharp.NDArray filt, string trim, int[] axis)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.trim_zeros.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.trim_zeros.cs" + ], + "notes": "" + }, + { + "id": "numpy.triu", + "origin": "numpy", + "surface": "np", + "name": "triu", + "kind": "function", + "numpy_signature": "(m, k=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.triu.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.triu_indices", + "origin": "numpy", + "surface": "np", + "name": "triu_indices", + "kind": "function", + "numpy_signature": "(n, k=0, m=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.triu_indices.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.triu_indices_from", + "origin": "numpy", + "surface": "np", + "name": "triu_indices_from", + "kind": "function", + "numpy_signature": "(arr, k=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.triu_indices_from.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.True_", + "origin": "numpy", + "surface": "np", + "name": "True_", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.true_divide", + "origin": "numpy", + "surface": "np", + "name": "true_divide", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.true_divide.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.true_divide", + "numsharp_signatures": [ + "NumSharp.NDArray true_divide(NumSharp.NDArray x1, NumSharp.NDArray x2, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.math.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.math.cs" + ], + "notes": "" + }, + { + "id": "numpy.trunc", + "origin": "numpy", + "surface": "np", + "name": "trunc", + "kind": "ufunc", + "numpy_signature": "(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.trunc.html", + "in_default_scope": true, + "category": "Math", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.trunc", + "numsharp_signatures": [ + "NumSharp.NDArray trunc(NumSharp.NDArray x, NumSharp.NDArray out = null, NumSharp.NDArray where = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray trunc(NumSharp.NDArray x, NumSharp.NPTypeCode dtype)", + "NumSharp.NDArray trunc(NumSharp.NDArray x, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/np.trunc.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/np.trunc.cs" + ], + "notes": "" + }, + { + "id": "numpy.typecodes", + "origin": "numpy", + "surface": "np", + "name": "typecodes", + "kind": "constant", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Types & constants", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.typename", + "origin": "numpy", + "surface": "np", + "name": "typename", + "kind": "function", + "numpy_signature": "(char)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.typename.html", + "in_default_scope": true, + "category": "Text & formatting", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.typing", + "origin": "numpy", + "surface": "np", + "name": "typing", + "kind": "module", + "numpy_signature": "Signature unavailable from runtime introspection", + "documentation_url": "", + "in_default_scope": false, + "category": "Namespaces", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ubyte", + "origin": "numpy", + "surface": "np", + "name": "ubyte", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ubyte", + "numsharp_signatures": [ + "readonly System.Type ubyte" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ufunc", + "origin": "numpy", + "surface": "np", + "name": "ufunc", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.uint", + "origin": "numpy", + "surface": "np", + "name": "uint", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.uint", + "numsharp_signatures": [ + "readonly System.Type uint" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.uint16", + "origin": "numpy", + "surface": "np", + "name": "uint16", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.uint16", + "numsharp_signatures": [ + "readonly System.Type uint16" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.uint32", + "origin": "numpy", + "surface": "np", + "name": "uint32", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.uint32", + "numsharp_signatures": [ + "readonly System.Type uint32" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.uint64", + "origin": "numpy", + "surface": "np", + "name": "uint64", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.uint64", + "numsharp_signatures": [ + "readonly System.Type uint64" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.uint8", + "origin": "numpy", + "surface": "np", + "name": "uint8", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.uint8", + "numsharp_signatures": [ + "readonly System.Type uint8" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.uintc", + "origin": "numpy", + "surface": "np", + "name": "uintc", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.uintc", + "numsharp_signatures": [ + "readonly System.Type uintc" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.uintp", + "origin": "numpy", + "surface": "np", + "name": "uintp", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.uintp", + "numsharp_signatures": [ + "readonly System.Type uintp" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ulong", + "origin": "numpy", + "surface": "np", + "name": "ulong", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ulong", + "numsharp_signatures": [ + "readonly System.Type ulong" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.ulonglong", + "origin": "numpy", + "surface": "np", + "name": "ulonglong", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ulonglong", + "numsharp_signatures": [ + "readonly System.Type ulonglong" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.union1d", + "origin": "numpy", + "surface": "np", + "name": "union1d", + "kind": "function", + "numpy_signature": "(ar1, ar2)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.union1d.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.unique", + "origin": "numpy", + "surface": "np", + "name": "unique", + "kind": "function", + "numpy_signature": "(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True, sorted=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unique.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.unique", + "numsharp_signatures": [ + "NumSharp.NDArray unique(NumSharp.NDArray ar)", + "NumSharp.NDArray[] unique(NumSharp.NDArray ar, bool return_index, bool return_inverse = false, bool return_counts = false, int? axis = null, bool equal_nan = true)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.unique.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.unique.cs" + ], + "notes": "" + }, + { + "id": "numpy.unique_all", + "origin": "numpy", + "surface": "np", + "name": "unique_all", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unique_all.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.unique_counts", + "origin": "numpy", + "surface": "np", + "name": "unique_counts", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unique_counts.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.unique_inverse", + "origin": "numpy", + "surface": "np", + "name": "unique_inverse", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unique_inverse.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.unique_values", + "origin": "numpy", + "surface": "np", + "name": "unique_values", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unique_values.html", + "in_default_scope": true, + "category": "Set operations", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.unpackbits", + "origin": "numpy", + "surface": "np", + "name": "unpackbits", + "kind": "function", + "numpy_signature": "(a, /, axis=None, count=None, bitorder='big')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unpackbits.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.unravel_index", + "origin": "numpy", + "surface": "np", + "name": "unravel_index", + "kind": "function", + "numpy_signature": "(indices, shape, order='C')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.unravel_index", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray[] unravel_index(NumSharp.NDArray indices, int[] shape, char order = 'C')", + "long[] unravel_index(long index, int[] shape, char order = 'C')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.unravel_index.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.unravel_index.cs" + ], + "notes": "" + }, + { + "id": "numpy.unsignedinteger", + "origin": "numpy", + "surface": "np", + "name": "unsignedinteger", + "kind": "class", + "numpy_signature": "()", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.unstack", + "origin": "numpy", + "surface": "np", + "name": "unstack", + "kind": "function", + "numpy_signature": "(x, /, *, axis=0)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unstack.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.unstack", + "numsharp_signatures": [ + "NumSharp.NDArray[] unstack(NumSharp.NDArray x, int axis = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.unstack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.unstack.cs" + ], + "notes": "" + }, + { + "id": "numpy.unwrap", + "origin": "numpy", + "surface": "np", + "name": "unwrap", + "kind": "function", + "numpy_signature": "(p, discont=None, axis=-1, *, period=6.283185307179586)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.unwrap.html", + "in_default_scope": true, + "category": "Math", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.ushort", + "origin": "numpy", + "surface": "np", + "name": "ushort", + "kind": "class", + "numpy_signature": "(value=0, /)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.ushort", + "numsharp_signatures": [ + "readonly System.Type ushort" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "" + }, + { + "id": "numpy.vander", + "origin": "numpy", + "surface": "np", + "name": "vander", + "kind": "function", + "numpy_signature": "(x, N=None, increasing=False)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.vander.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.var", + "origin": "numpy", + "surface": "np", + "name": "var", + "kind": "function", + "numpy_signature": "(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.var.html", + "in_default_scope": true, + "category": "Reductions", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.var", + "numsharp_signatures": [ + "NumSharp.NDArray var(NumSharp.NDArray a, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)", + "NumSharp.NDArray var(NumSharp.NDArray a, int axis, NumSharp.NPTypeCode type, bool keepdims = false, int? ddof = null)", + "NumSharp.NDArray var(NumSharp.NDArray a, int axis, System.Type dtype, bool keepdims = false, int? ddof = null)", + "NumSharp.NDArray var(NumSharp.NDArray a, int axis, bool keepdims = false, int? ddof = null, NumSharp.NPTypeCode? dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.var.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.var.cs" + ], + "notes": "" + }, + { + "id": "numpy.vdot", + "origin": "numpy", + "surface": "np", + "name": "vdot", + "kind": "function", + "numpy_signature": "(a, b, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.vdot.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.vecdot", + "origin": "numpy", + "surface": "np", + "name": "vecdot", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.vecdot.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.vecmat", + "origin": "numpy", + "surface": "np", + "name": "vecmat", + "kind": "ufunc", + "numpy_signature": "(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.vecmat.html", + "in_default_scope": true, + "category": "Linear algebra", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.vectorize", + "origin": "numpy", + "surface": "np", + "name": "vectorize", + "kind": "class", + "numpy_signature": "(pyfunc=, otypes=None, doc=None, excluded=None, cache=False, signature=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.void", + "origin": "numpy", + "surface": "np", + "name": "void", + "kind": "class", + "numpy_signature": "(length_or_data, /, dtype=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Types", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.vsplit", + "origin": "numpy", + "surface": "np", + "name": "vsplit", + "kind": "function", + "numpy_signature": "(ary, indices_or_sections)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.vsplit.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.vsplit", + "numsharp_signatures": [ + "NumSharp.NDArray[] vsplit(NumSharp.NDArray ary, int indices_or_sections)", + "NumSharp.NDArray[] vsplit(NumSharp.NDArray ary, int[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.vsplit.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.vsplit.cs" + ], + "notes": "" + }, + { + "id": "numpy.vstack", + "origin": "numpy", + "surface": "np", + "name": "vstack", + "kind": "function", + "numpy_signature": "(tup, *, dtype=None, casting='same_kind')", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.vstack.html", + "in_default_scope": true, + "category": "Shape manipulation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.vstack", + "numsharp_signatures": [ + "NumSharp.NDArray vstack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.vstack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.vstack.cs" + ], + "notes": "" + }, + { + "id": "numpy.where", + "origin": "numpy", + "surface": "np", + "name": "where", + "kind": "function", + "numpy_signature": "(condition, x=None, y=None, /)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.where.html", + "in_default_scope": true, + "category": "Indexing & selection", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.where", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray[] where(NumSharp.NDArray condition)", + "NumSharp.NDArray where(NumSharp.NDArray condition, NumSharp.NDArray x, NumSharp.NDArray y)", + "NumSharp.NDArray where(NumSharp.NDArray condition, NumSharp.NDArray x, object y)", + "NumSharp.NDArray where(NumSharp.NDArray condition, object x, NumSharp.NDArray y)", + "NumSharp.NDArray where(NumSharp.NDArray condition, object x, object y)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.where.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.where.cs" + ], + "notes": "" + }, + { + "id": "numpy.zeros", + "origin": "numpy", + "surface": "np", + "name": "zeros", + "kind": "function", + "numpy_signature": "(shape, dtype=None, order='C', *, device=None, like=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.zeros.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.zeros", + "numsharp_signatures": [ + "NumSharp.NDArray zeros(NumSharp.Shape shape)", + "NumSharp.NDArray zeros(NumSharp.Shape shape, NumSharp.NPTypeCode typeCode)", + "NumSharp.NDArray zeros(NumSharp.Shape shape, System.Type dtype)", + "NumSharp.NDArray zeros(int shape)", + "NumSharp.NDArray zeros(int[] shape)", + "NumSharp.NDArray zeros(int[] shape)", + "NumSharp.NDArray zeros(long[] shape)", + "NumSharp.NDArray zeros(long[] shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.zeros.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.zeros.cs" + ], + "notes": "" + }, + { + "id": "numpy.zeros_like", + "origin": "numpy", + "surface": "np", + "name": "zeros_like", + "kind": "function", + "numpy_signature": "(a, dtype=None, order='K', subok=True, shape=None, *, device=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/generated/numpy.zeros_like.html", + "in_default_scope": true, + "category": "Array creation", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.np.zeros_like", + "numsharp_signatures": [ + "NumSharp.NDArray zeros_like(NumSharp.NDArray a, System.Type dtype = null)", + "NumSharp.NDArray zeros_like(NumSharp.NDArray a, System.Type dtype, char order)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.zeros_like.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.zeros_like.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.beta", + "origin": "numpy", + "surface": "random", + "name": "beta", + "kind": "function", + "numpy_signature": "(a, b, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.beta.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.beta", + "numsharp_signatures": [ + "NumSharp.NDArray beta(double a, double b)", + "NumSharp.NDArray beta(double a, double b, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.beta.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.beta.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.binomial", + "origin": "numpy", + "surface": "random", + "name": "binomial", + "kind": "function", + "numpy_signature": "(n, p, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.binomial.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.binomial", + "numsharp_signatures": [ + "NumSharp.NDArray binomial(int n, double p)", + "NumSharp.NDArray binomial(int n, double p, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.binomial.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.binomial.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.BitGenerator", + "origin": "numpy", + "surface": "random", + "name": "BitGenerator", + "kind": "class", + "numpy_signature": "(seed=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.bytes", + "origin": "numpy", + "surface": "random", + "name": "bytes", + "kind": "function", + "numpy_signature": "(length)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.bytes.html", + "in_default_scope": true, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.chisquare", + "origin": "numpy", + "surface": "random", + "name": "chisquare", + "kind": "function", + "numpy_signature": "(df, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.chisquare.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.chisquare", + "numsharp_signatures": [ + "NumSharp.NDArray chisquare(double df)", + "NumSharp.NDArray chisquare(double df, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.chisquare.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.chisquare.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.choice", + "origin": "numpy", + "surface": "random", + "name": "choice", + "kind": "function", + "numpy_signature": "(a, size=None, replace=True, p=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.choice.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.choice", + "numsharp_signatures": [ + "NumSharp.NDArray choice(NumSharp.NDArray a, NumSharp.Shape size = null, bool replace = true, double[] p = null)", + "NumSharp.NDArray choice(int a, NumSharp.Shape size = null, bool replace = true, double[] p = null)", + "NumSharp.NDArray choice(long a, NumSharp.Shape size = null, bool replace = true, double[] p = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.choice.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.choice.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.default_rng", + "origin": "numpy", + "surface": "random", + "name": "default_rng", + "kind": "function", + "numpy_signature": "(seed=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generator.html#numpy.random.default_rng", + "in_default_scope": true, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.dirichlet", + "origin": "numpy", + "surface": "random", + "name": "dirichlet", + "kind": "function", + "numpy_signature": "(alpha, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.dirichlet.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.dirichlet", + "numsharp_signatures": [ + "NumSharp.NDArray dirichlet(NumSharp.NDArray alpha, NumSharp.Shape? size = null)", + "NumSharp.NDArray dirichlet(double[] alpha, NumSharp.Shape? size = null)", + "NumSharp.NDArray dirichlet(double[] alpha, int size)", + "NumSharp.NDArray dirichlet(double[] alpha, int[] size)", + "NumSharp.NDArray dirichlet(double[] alpha, long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.dirichlet.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.dirichlet.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.exponential", + "origin": "numpy", + "surface": "random", + "name": "exponential", + "kind": "function", + "numpy_signature": "(scale=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.exponential.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.exponential", + "numsharp_signatures": [ + "NumSharp.NDArray exponential(double scale = 1)", + "NumSharp.NDArray exponential(double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.exponential.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.exponential.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.f", + "origin": "numpy", + "surface": "random", + "name": "f", + "kind": "function", + "numpy_signature": "(dfnum, dfden, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.f.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.f", + "numsharp_signatures": [ + "NumSharp.NDArray f(double dfnum, double dfden)", + "NumSharp.NDArray f(double dfnum, double dfden, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.f.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.f.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.gamma", + "origin": "numpy", + "surface": "random", + "name": "gamma", + "kind": "function", + "numpy_signature": "(shape, scale=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.gamma.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.gamma", + "numsharp_signatures": [ + "NumSharp.NDArray gamma(double shape, double scale = 1)", + "NumSharp.NDArray gamma(double shape, double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.gamma.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.gamma.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.Generator", + "origin": "numpy", + "surface": "random", + "name": "Generator", + "kind": "class", + "numpy_signature": "(bit_generator)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.geometric", + "origin": "numpy", + "surface": "random", + "name": "geometric", + "kind": "function", + "numpy_signature": "(p, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.geometric.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.geometric", + "numsharp_signatures": [ + "NumSharp.NDArray geometric(double p)", + "NumSharp.NDArray geometric(double p, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.geometric.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.geometric.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.get_state", + "origin": "numpy", + "surface": "random", + "name": "get_state", + "kind": "function", + "numpy_signature": "(legacy=True)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.get_state.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.get_state", + "numsharp_signatures": [ + "NumSharp.NativeRandomState get_state()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.gumbel", + "origin": "numpy", + "surface": "random", + "name": "gumbel", + "kind": "function", + "numpy_signature": "(loc=0.0, scale=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.gumbel.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.gumbel", + "numsharp_signatures": [ + "NumSharp.NDArray gumbel(double loc = 0, double scale = 1)", + "NumSharp.NDArray gumbel(double loc, double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.gumbel.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.gumbel.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.hypergeometric", + "origin": "numpy", + "surface": "random", + "name": "hypergeometric", + "kind": "function", + "numpy_signature": "(ngood, nbad, nsample, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.hypergeometric.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.hypergeometric", + "numsharp_signatures": [ + "NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample)", + "NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, NumSharp.Shape? size = null)", + "NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, int size)", + "NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, int[] size)", + "NumSharp.NDArray hypergeometric(long ngood, long nbad, long nsample, long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.hypergeometric.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.hypergeometric.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.laplace", + "origin": "numpy", + "surface": "random", + "name": "laplace", + "kind": "function", + "numpy_signature": "(loc=0.0, scale=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.laplace.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.laplace", + "numsharp_signatures": [ + "NumSharp.NDArray laplace(double loc = 0, double scale = 1)", + "NumSharp.NDArray laplace(double loc, double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.laplace.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.laplace.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.logistic", + "origin": "numpy", + "surface": "random", + "name": "logistic", + "kind": "function", + "numpy_signature": "(loc=0.0, scale=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.logistic.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.logistic", + "numsharp_signatures": [ + "NumSharp.NDArray logistic(double loc = 0, double scale = 1)", + "NumSharp.NDArray logistic(double loc, double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.logistic.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.logistic.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.lognormal", + "origin": "numpy", + "surface": "random", + "name": "lognormal", + "kind": "function", + "numpy_signature": "(mean=0.0, sigma=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.lognormal.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.lognormal", + "numsharp_signatures": [ + "NumSharp.NDArray lognormal(double mean = 0, double sigma = 1)", + "NumSharp.NDArray lognormal(double mean, double sigma, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.lognormal.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.lognormal.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.logseries", + "origin": "numpy", + "surface": "random", + "name": "logseries", + "kind": "function", + "numpy_signature": "(p, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.logseries.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.logseries", + "numsharp_signatures": [ + "NumSharp.NDArray logseries(double p, NumSharp.Shape size)", + "NumSharp.NDArray logseries(double p, NumSharp.Shape? size = null)", + "NumSharp.NDArray logseries(double p, int size)", + "NumSharp.NDArray logseries(double p, int[] size)", + "NumSharp.NDArray logseries(double p, long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.logseries.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.logseries.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.MT19937", + "origin": "numpy", + "surface": "random", + "name": "MT19937", + "kind": "class", + "numpy_signature": "(seed=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.multinomial", + "origin": "numpy", + "surface": "random", + "name": "multinomial", + "kind": "function", + "numpy_signature": "(n, pvals, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.multinomial.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.multinomial", + "numsharp_signatures": [ + "NumSharp.NDArray multinomial(int n, double[] pvals, NumSharp.Shape? size = null)", + "NumSharp.NDArray multinomial(int n, double[] pvals, int size)", + "NumSharp.NDArray multinomial(int n, double[] pvals, int[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.multinomial.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.multinomial.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.multivariate_normal", + "origin": "numpy", + "surface": "random", + "name": "multivariate_normal", + "kind": "function", + "numpy_signature": "(mean, cov, size=None, check_valid='warn', tol=1e-08)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.multivariate_normal.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.multivariate_normal", + "numsharp_signatures": [ + "NumSharp.NDArray multivariate_normal(NumSharp.NDArray mean, NumSharp.NDArray cov, NumSharp.Shape? size = null, string check_valid = \"warn\", double tol = 1E-08)", + "NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, NumSharp.Shape? size = null, string check_valid = \"warn\", double tol = 1E-08)", + "NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, int size, string check_valid = \"warn\", double tol = 1E-08)", + "NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, int[] size)", + "NumSharp.NDArray multivariate_normal(double[] mean, double[] cov, long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.multivariate_normal.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.multivariate_normal.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.negative_binomial", + "origin": "numpy", + "surface": "random", + "name": "negative_binomial", + "kind": "function", + "numpy_signature": "(n, p, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.negative_binomial.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.negative_binomial", + "numsharp_signatures": [ + "NumSharp.NDArray negative_binomial(double n, double p)", + "NumSharp.NDArray negative_binomial(double n, double p, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.negative_binomial.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.negative_binomial.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.noncentral_chisquare", + "origin": "numpy", + "surface": "random", + "name": "noncentral_chisquare", + "kind": "function", + "numpy_signature": "(df, nonc, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.noncentral_chisquare.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.noncentral_chisquare", + "numsharp_signatures": [ + "NumSharp.NDArray noncentral_chisquare(double df, double nonc)", + "NumSharp.NDArray noncentral_chisquare(double df, double nonc, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.noncentral_chisquare.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.noncentral_chisquare.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.noncentral_f", + "origin": "numpy", + "surface": "random", + "name": "noncentral_f", + "kind": "function", + "numpy_signature": "(dfnum, dfden, nonc, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.noncentral_f.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.noncentral_f", + "numsharp_signatures": [ + "NumSharp.NDArray noncentral_f(double dfnum, double dfden, double nonc)", + "NumSharp.NDArray noncentral_f(double dfnum, double dfden, double nonc, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.noncentral_f.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.noncentral_f.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.normal", + "origin": "numpy", + "surface": "random", + "name": "normal", + "kind": "function", + "numpy_signature": "(loc=0.0, scale=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.normal.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.normal", + "numsharp_signatures": [ + "NumSharp.NDArray normal(double loc = 0, double scale = 1)", + "NumSharp.NDArray normal(double loc, double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.randn.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randn.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.pareto", + "origin": "numpy", + "surface": "random", + "name": "pareto", + "kind": "function", + "numpy_signature": "(a, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.pareto.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.pareto", + "numsharp_signatures": [ + "NumSharp.NDArray pareto(double a)", + "NumSharp.NDArray pareto(double a, NumSharp.Shape size)", + "NumSharp.NDArray pareto(double a, int size)", + "NumSharp.NDArray pareto(double a, int[] size)", + "NumSharp.NDArray pareto(double a, long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.pareto.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.pareto.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.PCG64", + "origin": "numpy", + "surface": "random", + "name": "PCG64", + "kind": "class", + "numpy_signature": "(seed=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.PCG64DXSM", + "origin": "numpy", + "surface": "random", + "name": "PCG64DXSM", + "kind": "class", + "numpy_signature": "(seed=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.permutation", + "origin": "numpy", + "surface": "random", + "name": "permutation", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.permutation.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.permutation", + "numsharp_signatures": [ + "NumSharp.NDArray permutation(NumSharp.NDArray x)", + "NumSharp.NDArray permutation(int x)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.permutation.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.permutation.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.Philox", + "origin": "numpy", + "surface": "random", + "name": "Philox", + "kind": "class", + "numpy_signature": "(seed=None, counter=None, key=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.poisson", + "origin": "numpy", + "surface": "random", + "name": "poisson", + "kind": "function", + "numpy_signature": "(lam=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.poisson.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.poisson", + "numsharp_signatures": [ + "NumSharp.NDArray poisson(double lam = 1)", + "NumSharp.NDArray poisson(double lam, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.poisson.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.poisson.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.power", + "origin": "numpy", + "surface": "random", + "name": "power", + "kind": "function", + "numpy_signature": "(a, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.power.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.power", + "numsharp_signatures": [ + "NumSharp.NDArray power(double a)", + "NumSharp.NDArray power(double a, NumSharp.Shape size)", + "NumSharp.NDArray power(double a, int size)", + "NumSharp.NDArray power(double a, int[] size)", + "NumSharp.NDArray power(double a, long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.power.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.power.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.rand", + "origin": "numpy", + "surface": "random", + "name": "rand", + "kind": "function", + "numpy_signature": "(*args)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.rand", + "numsharp_signatures": [ + "NumSharp.NDArray rand(NumSharp.Shape shape)", + "NumSharp.NDArray rand(params long[] shape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.randint", + "origin": "numpy", + "surface": "random", + "name": "randint", + "kind": "function", + "numpy_signature": "(low, high=None, size=None, dtype=)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.randint.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.randint", + "numsharp_signatures": [ + "NumSharp.NDArray randint(long low, long high = -1, NumSharp.Shape size = null, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.randint.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randint.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.randn", + "origin": "numpy", + "surface": "random", + "name": "randn", + "kind": "function", + "numpy_signature": "(*args)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.randn.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.randn", + "numsharp_signatures": [ + "NumSharp.NDArray randn(params long[] shape)", + "T randn()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.randn.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randn.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.random", + "origin": "numpy", + "surface": "random", + "name": "random", + "kind": "function", + "numpy_signature": "(size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.random.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.random", + "numsharp_signatures": [ + "NumSharp.NDArray random(params long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.random_integers", + "origin": "numpy", + "surface": "random", + "name": "random_integers", + "kind": "function", + "numpy_signature": "(low, high=None, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.random_integers.html", + "in_default_scope": true, + "category": "Random", + "availability": "alias", + "support": "partial", + "status": "partial", + "numsharp_target": "NumSharp.NumPyRandom.randint", + "numsharp_signatures": [ + "NumSharp.NDArray randint(long low, long high = -1, NumSharp.Shape size = null, System.Type dtype = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.randint.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randint.cs" + ], + "notes": "Use randint and adjust the upper bound; deprecated random_integers includes the high endpoint. The available randint alternative has an exclusive upper bound, while random_integers historically used an inclusive upper bound." + }, + { + "id": "numpy.random.random_sample", + "origin": "numpy", + "surface": "random", + "name": "random_sample", + "kind": "function", + "numpy_signature": "(size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.random_sample.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.random_sample", + "numsharp_signatures": [ + "NumSharp.NDArray random_sample(params long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.RandomState", + "origin": "numpy", + "surface": "random", + "name": "RandomState", + "kind": "class", + "numpy_signature": "(seed=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.RandomState", + "numsharp_signatures": [ + "NumSharp.NumPyRandom RandomState()", + "NumSharp.NumPyRandom RandomState(NumSharp.NativeRandomState state)", + "NumSharp.NumPyRandom RandomState(int seed)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.ranf", + "origin": "numpy", + "surface": "random", + "name": "ranf", + "kind": "function", + "numpy_signature": "(*args, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.ranf.html", + "in_default_scope": true, + "category": "Random", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.random_sample", + "numsharp_signatures": [ + "NumSharp.NDArray random_sample(params long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "notes": "NumPy documents ranf as an alias of random_sample." + }, + { + "id": "numpy.random.rayleigh", + "origin": "numpy", + "surface": "random", + "name": "rayleigh", + "kind": "function", + "numpy_signature": "(scale=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.rayleigh.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.rayleigh", + "numsharp_signatures": [ + "NumSharp.NDArray rayleigh(double scale = 1)", + "NumSharp.NDArray rayleigh(double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.rayleigh.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rayleigh.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.sample", + "origin": "numpy", + "surface": "random", + "name": "sample", + "kind": "function", + "numpy_signature": "(*args, **kwargs)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.sample.html", + "in_default_scope": true, + "category": "Random", + "availability": "alias", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.random_sample", + "numsharp_signatures": [ + "NumSharp.NDArray random_sample(params long[] size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.rand.cs" + ], + "notes": "NumPy documents sample as an alias of random_sample." + }, + { + "id": "numpy.random.seed", + "origin": "numpy", + "surface": "random", + "name": "seed", + "kind": "function", + "numpy_signature": "(seed=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.seed.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.seed", + "numsharp_signatures": [ + "void seed(int seed)", + "void seed(long seed)", + "void seed(uint seed)", + "void seed(uint[] seed)", + "void seed(ulong seed)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.SeedSequence", + "origin": "numpy", + "surface": "random", + "name": "SeedSequence", + "kind": "class", + "numpy_signature": "(entropy=None, *, spawn_key=(), pool_size=4, n_children_spawned=0)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.set_state", + "origin": "numpy", + "surface": "random", + "name": "set_state", + "kind": "function", + "numpy_signature": "(state)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.set_state.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.set_state", + "numsharp_signatures": [ + "void set_state(NumSharp.NativeRandomState state)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.SFC64", + "origin": "numpy", + "surface": "random", + "name": "SFC64", + "kind": "class", + "numpy_signature": "(seed=None)", + "documentation_url": "", + "in_default_scope": false, + "category": "Random", + "availability": "missing", + "support": "missing", + "status": "missing", + "numsharp_target": null, + "numsharp_signatures": [], + "numsharp_obsolete": false, + "numsharp_source_paths": [], + "numsharp_source_urls": [], + "notes": "" + }, + { + "id": "numpy.random.shuffle", + "origin": "numpy", + "surface": "random", + "name": "shuffle", + "kind": "function", + "numpy_signature": "(x)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.shuffle.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.shuffle", + "numsharp_signatures": [ + "void shuffle(NumSharp.NDArray x)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.shuffle.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.shuffle.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.standard_cauchy", + "origin": "numpy", + "surface": "random", + "name": "standard_cauchy", + "kind": "function", + "numpy_signature": "(size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_cauchy.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.standard_cauchy", + "numsharp_signatures": [ + "NumSharp.NDArray standard_cauchy()", + "NumSharp.NDArray standard_cauchy(NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.standard_cauchy.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_cauchy.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.standard_exponential", + "origin": "numpy", + "surface": "random", + "name": "standard_exponential", + "kind": "function", + "numpy_signature": "(size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_exponential.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.standard_exponential", + "numsharp_signatures": [ + "NumSharp.NDArray standard_exponential()", + "NumSharp.NDArray standard_exponential(NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.standard_exponential.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_exponential.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.standard_gamma", + "origin": "numpy", + "surface": "random", + "name": "standard_gamma", + "kind": "function", + "numpy_signature": "(shape, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_gamma.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.standard_gamma", + "numsharp_signatures": [ + "NumSharp.NDArray standard_gamma(double shape)", + "NumSharp.NDArray standard_gamma(double shape, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.standard_gamma.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_gamma.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.standard_normal", + "origin": "numpy", + "surface": "random", + "name": "standard_normal", + "kind": "function", + "numpy_signature": "(size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_normal.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.standard_normal", + "numsharp_signatures": [ + "NumSharp.NDArray standard_normal()", + "NumSharp.NDArray standard_normal(NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.randn.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.randn.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.standard_t", + "origin": "numpy", + "surface": "random", + "name": "standard_t", + "kind": "function", + "numpy_signature": "(df, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.standard_t.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.standard_t", + "numsharp_signatures": [ + "NumSharp.NDArray standard_t(double df)", + "NumSharp.NDArray standard_t(double df, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.standard_t.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.standard_t.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.triangular", + "origin": "numpy", + "surface": "random", + "name": "triangular", + "kind": "function", + "numpy_signature": "(left, mode, right, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.triangular.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.triangular", + "numsharp_signatures": [ + "NumSharp.NDArray triangular(double left, double mode, double right)", + "NumSharp.NDArray triangular(double left, double mode, double right, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.triangular.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.triangular.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.uniform", + "origin": "numpy", + "surface": "random", + "name": "uniform", + "kind": "function", + "numpy_signature": "(low=0.0, high=1.0, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.uniform.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.uniform", + "numsharp_signatures": [ + "NumSharp.NDArray uniform(NumSharp.NDArray low, NumSharp.NDArray high, System.Type dtype = null)", + "NumSharp.NDArray uniform(double low = 0, double high = 1)", + "NumSharp.NDArray uniform(double low, double high, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.uniform.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.uniform.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.vonmises", + "origin": "numpy", + "surface": "random", + "name": "vonmises", + "kind": "function", + "numpy_signature": "(mu, kappa, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.vonmises.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.vonmises", + "numsharp_signatures": [ + "NumSharp.NDArray vonmises(double mu, double kappa)", + "NumSharp.NDArray vonmises(double mu, double kappa, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.vonmises.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.vonmises.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.wald", + "origin": "numpy", + "surface": "random", + "name": "wald", + "kind": "function", + "numpy_signature": "(mean, scale, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.wald.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.wald", + "numsharp_signatures": [ + "NumSharp.NDArray wald(double mean, double scale)", + "NumSharp.NDArray wald(double mean, double scale, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.wald.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.wald.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.weibull", + "origin": "numpy", + "surface": "random", + "name": "weibull", + "kind": "function", + "numpy_signature": "(a, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.weibull.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.weibull", + "numsharp_signatures": [ + "NumSharp.NDArray weibull(double a)", + "NumSharp.NDArray weibull(double a, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.weibull.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.weibull.cs" + ], + "notes": "" + }, + { + "id": "numpy.random.zipf", + "origin": "numpy", + "surface": "random", + "name": "zipf", + "kind": "function", + "numpy_signature": "(a, size=None)", + "documentation_url": "https://numpy.org/doc/stable/reference/random/generated/numpy.random.zipf.html", + "in_default_scope": true, + "category": "Random", + "availability": "exact", + "support": "declared", + "status": "available", + "numsharp_target": "NumSharp.NumPyRandom.zipf", + "numsharp_signatures": [ + "NumSharp.NDArray zipf(double a)", + "NumSharp.NDArray zipf(double a, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.zipf.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.zipf.cs" + ], + "notes": "" + }, + { + "id": "numsharp.ndarray.amax", + "origin": "numsharp", + "surface": "ndarray", + "name": "amax", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.amax", + "numsharp_signatures": [ + "NumSharp.NDArray amax(System.Type dtype = null)", + "NumSharp.NDArray amax(int axis, bool keepdims = false, System.Type dtype = null)", + "T amax()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.amax.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amax.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.amin", + "origin": "numsharp", + "surface": "ndarray", + "name": "amin", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.amin", + "numsharp_signatures": [ + "NumSharp.NDArray amin(System.Type dtype = null)", + "NumSharp.NDArray amin(int axis, bool keepdims = false, System.Type dtype = null)", + "T amin()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/NDArray.amin.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/NDArray.amin.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.array_equal", + "origin": "numsharp", + "surface": "ndarray", + "name": "array_equal", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.array_equal", + "numsharp_signatures": [ + "bool array_equal(NumSharp.NDArray rhs)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.AsGeneric", + "origin": "numsharp", + "surface": "ndarray", + "name": "AsGeneric", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.AsGeneric", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray AsGeneric()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.AsOrMakeGeneric", + "origin": "numsharp", + "surface": "ndarray", + "name": "AsOrMakeGeneric", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.AsOrMakeGeneric", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray AsOrMakeGeneric()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.Clone", + "origin": "numsharp", + "surface": "ndarray", + "name": "Clone", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.Clone", + "numsharp_signatures": [ + "NumSharp.NDArray Clone()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.CloneData", + "origin": "numsharp", + "surface": "ndarray", + "name": "CloneData", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.CloneData", + "numsharp_signatures": [ + "NumSharp.Backends.Unmanaged.ArraySlice CloneData()", + "NumSharp.Backends.Unmanaged.IArraySlice CloneData()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.Contains", + "origin": "numsharp", + "surface": "ndarray", + "name": "Contains", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.Contains", + "numsharp_signatures": [ + "bool Contains(object value)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.convolve", + "origin": "numsharp", + "surface": "ndarray", + "name": "convolve", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.convolve", + "numsharp_signatures": [ + "NumSharp.NDArray convolve(NumSharp.NDArray v, string mode = \"full\")" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/NdArray.Convolve.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NdArray.Convolve.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.CopyTo", + "origin": "numsharp", + "surface": "ndarray", + "name": "CopyTo", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.CopyTo", + "numsharp_signatures": [ + "void CopyTo(NumSharp.Backends.Unmanaged.IMemoryBlock slice)", + "void CopyTo(NumSharp.Backends.Unmanaged.IMemoryBlock block)", + "void CopyTo(System.IntPtr ptr)", + "void CopyTo(System.Void* address)", + "void CopyTo(T* address)", + "void CopyTo(T[] array)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.CopyTo.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.CopyTo.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.delete", + "origin": "numsharp", + "surface": "ndarray", + "name": "delete", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.delete", + "numsharp_signatures": [ + "NumSharp.NDArray delete(System.Collections.IEnumerable indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NdArray.delete.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NdArray.delete.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.Dispose", + "origin": "numsharp", + "surface": "ndarray", + "name": "Dispose", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.Dispose", + "numsharp_signatures": [ + "void Dispose()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.dstack", + "origin": "numsharp", + "surface": "ndarray", + "name": "dstack", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.dstack", + "numsharp_signatures": [ + "NumSharp.NDArray dstack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.DStack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.DStack.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.Equals", + "origin": "numsharp", + "surface": "ndarray", + "name": "Equals", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.Equals", + "numsharp_signatures": [ + "bool Equals(object obj)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetAtIndex", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetAtIndex", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetAtIndex", + "numsharp_signatures": [ + "T GetAtIndex(long index)", + "object GetAtIndex(long index)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetBoolean", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetBoolean", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetBoolean", + "numsharp_signatures": [ + "bool GetBoolean(int[] indices)", + "bool GetBoolean(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetByte", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetByte", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetByte", + "numsharp_signatures": [ + "byte GetByte(int[] indices)", + "byte GetByte(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetChar", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetChar", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetChar", + "numsharp_signatures": [ + "char GetChar(int[] indices)", + "char GetChar(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetComplex", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetComplex", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetComplex", + "numsharp_signatures": [ + "System.Numerics.Complex GetComplex(int[] indices)", + "System.Numerics.Complex GetComplex(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetData", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetData", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetData", + "numsharp_signatures": [ + "NumSharp.Backends.Unmanaged.ArraySlice GetData()", + "NumSharp.Backends.Unmanaged.IArraySlice GetData()", + "NumSharp.NDArray GetData(int[] indices)", + "NumSharp.NDArray GetData(long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetDecimal", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetDecimal", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetDecimal", + "numsharp_signatures": [ + "decimal GetDecimal(int[] indices)", + "decimal GetDecimal(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetDouble", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetDouble", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetDouble", + "numsharp_signatures": [ + "double GetDouble(int[] indices)", + "double GetDouble(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetEnumerator", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetEnumerator", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetEnumerator", + "numsharp_signatures": [ + "System.Collections.IEnumerator GetEnumerator()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetHalf", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetHalf", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetHalf", + "numsharp_signatures": [ + "System.Half GetHalf(int[] indices)", + "System.Half GetHalf(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetHashCode", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetHashCode", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetHashCode", + "numsharp_signatures": [ + "int GetHashCode()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetIndices", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetIndices", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetIndices", + "numsharp_signatures": [ + "NumSharp.NDArray GetIndices(NumSharp.NDArray out, NumSharp.NDArray[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Getter.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetInt16", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetInt16", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetInt16", + "numsharp_signatures": [ + "short GetInt16(int[] indices)", + "short GetInt16(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetInt32", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetInt32", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetInt32", + "numsharp_signatures": [ + "int GetInt32(int[] indices)", + "int GetInt32(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetInt64", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetInt64", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetInt64", + "numsharp_signatures": [ + "long GetInt64(int[] indices)", + "long GetInt64(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetNDArrays", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetNDArrays", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetNDArrays", + "numsharp_signatures": [ + "NumSharp.NDArray[] GetNDArrays(int axis = 0)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetSByte", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetSByte", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetSByte", + "numsharp_signatures": [ + "sbyte GetSByte(int[] indices)", + "sbyte GetSByte(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetSingle", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetSingle", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetSingle", + "numsharp_signatures": [ + "float GetSingle(int[] indices)", + "float GetSingle(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetString", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetString", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetString", + "numsharp_signatures": [ + "string GetString(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetStringAt", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetStringAt", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetStringAt", + "numsharp_signatures": [ + "string GetStringAt(long offset)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetUInt16", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetUInt16", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetUInt16", + "numsharp_signatures": [ + "ushort GetUInt16(int[] indices)", + "ushort GetUInt16(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetUInt32", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetUInt32", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetUInt32", + "numsharp_signatures": [ + "uint GetUInt32(int[] indices)", + "uint GetUInt32(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetUInt64", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetUInt64", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetUInt64", + "numsharp_signatures": [ + "ulong GetUInt64(int[] indices)", + "ulong GetUInt64(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.GetValue", + "origin": "numsharp", + "surface": "ndarray", + "name": "GetValue", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.GetValue", + "numsharp_signatures": [ + "T GetValue(int[] indices)", + "T GetValue(params long[] indices)", + "object GetValue(int[] indices)", + "object GetValue(params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.hstack", + "origin": "numsharp", + "surface": "ndarray", + "name": "hstack", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.hstack", + "numsharp_signatures": [ + "NumSharp.NDArray hstack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.HStack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.HStack.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.IsDisposed", + "origin": "numsharp", + "surface": "ndarray", + "name": "IsDisposed", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.IsDisposed", + "numsharp_signatures": [ + "bool IsDisposed { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.Item", + "origin": "numsharp", + "surface": "ndarray", + "name": "Item", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.Item", + "numsharp_signatures": [ + "NumSharp.NDArray Item[NumSharp.Generic.NDArray mask] { get; set; }", + "NumSharp.NDArray Item[System.Int64* dims, int ndims] { get; set; }", + "NumSharp.NDArray Item[params NumSharp.Generic.NDArray[] selection] { get; set; }", + "NumSharp.NDArray Item[params NumSharp.Slice[] slice] { get; set; }", + "NumSharp.NDArray Item[params object[] indicesObjects] { get; set; }", + "NumSharp.NDArray Item[string slice] { get; set; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Container.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.itemset", + "origin": "numsharp", + "surface": "ndarray", + "name": "itemset", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.itemset", + "numsharp_signatures": [ + "void itemset(NumSharp.Shape shape, object val)", + "void itemset(int[] shape, T val)", + "void itemset(int[] shape, object val)", + "void itemset(ref NumSharp.Shape shape, object val)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.itemset.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.itemset.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.MakeGeneric", + "origin": "numsharp", + "surface": "ndarray", + "name": "MakeGeneric", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.MakeGeneric", + "numsharp_signatures": [ + "NumSharp.Generic.NDArray MakeGeneric()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.MakeGeneric.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.mgrid", + "origin": "numsharp", + "surface": "ndarray", + "name": "mgrid", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.mgrid", + "numsharp_signatures": [ + "System.ValueTuple mgrid(NumSharp.NDArray rhs)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.Mgrid.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.Mgrid.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.negate", + "origin": "numsharp", + "surface": "ndarray", + "name": "negate", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.negate", + "numsharp_signatures": [ + "NumSharp.NDArray negate()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/NDArray.negate.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.negate.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.negative", + "origin": "numsharp", + "surface": "ndarray", + "name": "negative", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.negative", + "numsharp_signatures": [ + "NumSharp.NDArray negative()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/NDArray.negative.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.negative.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.Normalize", + "origin": "numsharp", + "surface": "ndarray", + "name": "Normalize", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.Normalize", + "numsharp_signatures": [ + "void Normalize()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Extensions/NdArray.Normalize.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Extensions/NdArray.Normalize.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.order", + "origin": "numsharp", + "surface": "ndarray", + "name": "order", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.order", + "numsharp_signatures": [ + "char order { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.positive", + "origin": "numsharp", + "surface": "ndarray", + "name": "positive", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.positive", + "numsharp_signatures": [ + "NumSharp.NDArray positive()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Math/NDArray.positive.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Math/NDArray.positive.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.ReplaceData", + "origin": "numsharp", + "surface": "ndarray", + "name": "ReplaceData", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.ReplaceData", + "numsharp_signatures": [ + "void ReplaceData(NumSharp.Backends.Unmanaged.IArraySlice values)", + "void ReplaceData(NumSharp.Backends.Unmanaged.IArraySlice values, System.Type dtype)", + "void ReplaceData(NumSharp.NDArray nd)", + "void ReplaceData(System.Array values)", + "void ReplaceData(System.Array values, NumSharp.NPTypeCode typeCode)", + "void ReplaceData(System.Array values, System.Type dtype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.reshape_unsafe", + "origin": "numsharp", + "surface": "ndarray", + "name": "reshape_unsafe", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.reshape_unsafe", + "numsharp_signatures": [ + "NumSharp.NDArray reshape_unsafe(NumSharp.Shape newshape)", + "NumSharp.NDArray reshape_unsafe(int[] shape)", + "NumSharp.NDArray reshape_unsafe(params long[] shape)", + "NumSharp.NDArray reshape_unsafe(ref NumSharp.Shape newshape)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.ReShape.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.ReShape.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.roll", + "origin": "numsharp", + "surface": "ndarray", + "name": "roll", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.roll", + "numsharp_signatures": [ + "NumSharp.NDArray roll(int shift)", + "NumSharp.NDArray roll(int shift, int axis)", + "NumSharp.NDArray roll(long shift)", + "NumSharp.NDArray roll(long shift, int axis)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.roll.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.roll.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetAtIndex", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetAtIndex", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetAtIndex", + "numsharp_signatures": [ + "void SetAtIndex(T value, long index)", + "void SetAtIndex(object obj, long index)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetBoolean", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetBoolean", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetBoolean", + "numsharp_signatures": [ + "void SetBoolean(bool value, int[] indices)", + "void SetBoolean(bool value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetByte", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetByte", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetByte", + "numsharp_signatures": [ + "void SetByte(byte value, int[] indices)", + "void SetByte(byte value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetChar", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetChar", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetChar", + "numsharp_signatures": [ + "void SetChar(char value, int[] indices)", + "void SetChar(char value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetComplex", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetComplex", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetComplex", + "numsharp_signatures": [ + "void SetComplex(System.Numerics.Complex value, int[] indices)", + "void SetComplex(System.Numerics.Complex value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetData", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetData", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetData", + "numsharp_signatures": [ + "void SetData(NumSharp.Backends.Unmanaged.IArraySlice value, int[] indices)", + "void SetData(NumSharp.Backends.Unmanaged.IArraySlice value, params long[] indices)", + "void SetData(NumSharp.NDArray value, int[] indices)", + "void SetData(NumSharp.NDArray value, params long[] indices)", + "void SetData(object value, int[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetDecimal", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetDecimal", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetDecimal", + "numsharp_signatures": [ + "void SetDecimal(decimal value, int[] indices)", + "void SetDecimal(decimal value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetDouble", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetDouble", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetDouble", + "numsharp_signatures": [ + "void SetDouble(double value, int[] indices)", + "void SetDouble(double value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetHalf", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetHalf", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetHalf", + "numsharp_signatures": [ + "void SetHalf(System.Half value, int[] indices)", + "void SetHalf(System.Half value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetIndices", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetIndices", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetIndices", + "numsharp_signatures": [ + "void SetIndices(NumSharp.NDArray values, NumSharp.NDArray[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Selection/NDArray.Indexing.Selection.Setter.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetInt16", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetInt16", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetInt16", + "numsharp_signatures": [ + "void SetInt16(short value, int[] indices)", + "void SetInt16(short value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetInt32", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetInt32", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetInt32", + "numsharp_signatures": [ + "void SetInt32(int value, int[] indices)", + "void SetInt32(int value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetInt64", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetInt64", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetInt64", + "numsharp_signatures": [ + "void SetInt64(long value, int[] indices)", + "void SetInt64(long value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetSByte", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetSByte", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetSByte", + "numsharp_signatures": [ + "void SetSByte(sbyte value, int[] indices)", + "void SetSByte(sbyte value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetSingle", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetSingle", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetSingle", + "numsharp_signatures": [ + "void SetSingle(float value, int[] indices)", + "void SetSingle(float value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetString", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetString", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetString", + "numsharp_signatures": [ + "void SetString(string value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetStringAt", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetStringAt", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetStringAt", + "numsharp_signatures": [ + "void SetStringAt(string value, long offset)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.String.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetUInt16", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetUInt16", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetUInt16", + "numsharp_signatures": [ + "void SetUInt16(ushort value, int[] indices)", + "void SetUInt16(ushort value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetUInt32", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetUInt32", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetUInt32", + "numsharp_signatures": [ + "void SetUInt32(uint value, int[] indices)", + "void SetUInt32(uint value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetUInt64", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetUInt64", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetUInt64", + "numsharp_signatures": [ + "void SetUInt64(ulong value, int[] indices)", + "void SetUInt64(ulong value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.SetValue", + "origin": "numsharp", + "surface": "ndarray", + "name": "SetValue", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.SetValue", + "numsharp_signatures": [ + "void SetValue(T value, int[] indices)", + "void SetValue(T value, params long[] indices)", + "void SetValue(object value, int[] indices)", + "void SetValue(object value, params long[] indices)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.TensorEngine", + "origin": "numsharp", + "surface": "ndarray", + "name": "TensorEngine", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.TensorEngine", + "numsharp_signatures": [ + "NumSharp.TensorEngine TensorEngine { get; set; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.ToArray", + "origin": "numsharp", + "surface": "ndarray", + "name": "ToArray", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.ToArray", + "numsharp_signatures": [ + "T[] ToArray()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.ToJaggedArray", + "origin": "numsharp", + "surface": "ndarray", + "name": "ToJaggedArray", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.ToJaggedArray", + "numsharp_signatures": [ + "System.Array ToJaggedArray()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Casting/NdArrayToJaggedArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArrayToJaggedArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.ToMuliDimArray", + "origin": "numsharp", + "surface": "ndarray", + "name": "ToMuliDimArray", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.ToMuliDimArray", + "numsharp_signatures": [ + "System.Array ToMuliDimArray()" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArrayToMultiDimArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.ToString", + "origin": "numsharp", + "surface": "ndarray", + "name": "ToString", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.ToString", + "numsharp_signatures": [ + "string ToString()", + "string ToString(bool flat)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Casting/NdArray.ToString.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Casting/NdArray.ToString.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.typecode", + "origin": "numsharp", + "surface": "ndarray", + "name": "typecode", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.typecode", + "numsharp_signatures": [ + "NumSharp.NPTypeCode typecode { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.unique", + "origin": "numsharp", + "surface": "ndarray", + "name": "unique", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.unique", + "numsharp_signatures": [ + "NumSharp.NDArray unique()", + "NumSharp.NDArray[] unique(bool return_index, bool return_inverse = false, bool return_counts = false, int? axis = null, bool equal_nan = true)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/NDArray.unique.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/NDArray.unique.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.Unsafe", + "origin": "numsharp", + "surface": "ndarray", + "name": "Unsafe", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.Unsafe", + "numsharp_signatures": [ + "NumSharp.NDArray+_Unsafe Unsafe { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Backends/NDArray.Unmanaged.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Backends/NDArray.Unmanaged.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.ndarray.vstack", + "origin": "numsharp", + "surface": "ndarray", + "name": "vstack", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NDArray.vstack", + "numsharp_signatures": [ + "NumSharp.NDArray vstack(params NumSharp.NDArray[] tup)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/NdArray.VStack.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/NdArray.VStack.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.are_broadcastable", + "origin": "numsharp", + "surface": "np", + "name": "are_broadcastable", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.are_broadcastable", + "numsharp_signatures": [ + "bool are_broadcastable(NumSharp.NDArray lhs, NumSharp.NDArray rhs)", + "bool are_broadcastable(long[] shape1, long[] shape2)", + "bool are_broadcastable(params NumSharp.NDArray[] ndArrays)", + "bool are_broadcastable(params NumSharp.Shape[] shapes)", + "bool are_broadcastable(params int[][] shapes)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Creation/np.are_broadcastable.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Creation/np.are_broadcastable.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.asscalar", + "origin": "numsharp", + "surface": "np", + "name": "asscalar", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.asscalar", + "numsharp_signatures": [ + "T asscalar(NumSharp.Backends.Unmanaged.ArraySlice arr)", + "T asscalar(NumSharp.Backends.Unmanaged.IArraySlice arr)", + "T asscalar(NumSharp.NDArray nd)", + "T asscalar(System.Array arr)", + "object asscalar(NumSharp.NDArray nd)", + "object asscalar(System.Array arr)" + ], + "numsharp_obsolete": true, + "numsharp_source_paths": [ + "src/NumSharp.Core/Manipulation/np.asscalar.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Manipulation/np.asscalar.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.average_returned", + "origin": "numsharp", + "surface": "np", + "name": "average_returned", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.average_returned", + "numsharp_signatures": [ + "System.ValueTuple average_returned(NumSharp.NDArray a, int? axis = null, NumSharp.NDArray weights = null, bool keepdims = false)", + "System.ValueTuple average_returned(NumSharp.NDArray a, int[] axis, NumSharp.NDArray weights = null, bool keepdims = false)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Statistics/np.average.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Statistics/np.average.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.BackendEngine", + "origin": "numsharp", + "surface": "np", + "name": "BackendEngine", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.BackendEngine", + "numsharp_signatures": [ + "NumSharp.BackendType BackendEngine { get; set; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.bool8", + "origin": "numsharp", + "surface": "np", + "name": "bool8", + "kind": "field", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.bool8", + "numsharp_signatures": [ + "readonly System.Type bool8" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.chars", + "origin": "numsharp", + "surface": "np", + "name": "chars", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.chars", + "numsharp_signatures": [ + "System.Type chars { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.common_type_code", + "origin": "numsharp", + "surface": "np", + "name": "common_type_code", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.common_type_code", + "numsharp_signatures": [ + "NumSharp.NPTypeCode common_type_code(params NumSharp.NDArray[] arrays)", + "NumSharp.NPTypeCode common_type_code(params NumSharp.NPTypeCode[] types)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.common_type.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.common_type.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.complex_", + "origin": "numsharp", + "surface": "np", + "name": "complex_", + "kind": "field", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.complex_", + "numsharp_signatures": [ + "readonly System.Type complex_" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.decimal", + "origin": "numsharp", + "surface": "np", + "name": "decimal", + "kind": "field", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.decimal", + "numsharp_signatures": [ + "readonly System.Type decimal" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.evaluate", + "origin": "numsharp", + "surface": "np", + "name": "evaluate", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.evaluate", + "numsharp_signatures": [ + "NumSharp.NDArray evaluate(NumSharp.Backends.Iteration.NDExpr expr, NumSharp.NDArray out = null)", + "NumSharp.NDArray evaluate(NumSharp.Backends.Iteration.NDExpr expr, NumSharp.NDArray[] operands, NumSharp.NDArray out = null)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.evaluate.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.evaluate.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.find_common_type", + "origin": "numsharp", + "surface": "np", + "name": "find_common_type", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.find_common_type", + "numsharp_signatures": [ + "NumSharp.NPTypeCode find_common_type(NumSharp.NPTypeCode[] array_types, NumSharp.NPTypeCode[] scalar_types)", + "NumSharp.NPTypeCode find_common_type(NumSharp.NPTypeCode[] array_types, System.Type[] scalar_types)", + "NumSharp.NPTypeCode find_common_type(System.Type[] array_types)", + "NumSharp.NPTypeCode find_common_type(System.Type[] array_types, NumSharp.NPTypeCode[] scalar_types)", + "NumSharp.NPTypeCode find_common_type(System.Type[] array_types, System.Type[] scalar_types)", + "NumSharp.NPTypeCode find_common_type(params string[] involvedTypes)", + "NumSharp.NPTypeCode find_common_type(string[] array_types, string[] scalar_types)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.find_common_type.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.find_common_type.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.float_", + "origin": "numsharp", + "surface": "np", + "name": "float_", + "kind": "field", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.float_", + "numsharp_signatures": [ + "readonly System.Type float_" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.indices_sparse", + "origin": "numsharp", + "surface": "np", + "name": "indices_sparse", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.indices_sparse", + "numsharp_signatures": [ + "NumSharp.NDArray[] indices_sparse(int[] dimensions, NumSharp.NPTypeCode dtype = NumSharp.NPTypeCode.Int64)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Indexing/np.indices.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Indexing/np.indices.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.Inf", + "origin": "numsharp", + "surface": "np", + "name": "Inf", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.Inf", + "numsharp_signatures": [ + "double Inf { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.Infinity", + "origin": "numsharp", + "surface": "np", + "name": "Infinity", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.Infinity", + "numsharp_signatures": [ + "double Infinity { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.infinity", + "origin": "numsharp", + "surface": "np", + "name": "infinity", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.infinity", + "numsharp_signatures": [ + "double infinity { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.infty", + "origin": "numsharp", + "surface": "np", + "name": "infty", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.infty", + "numsharp_signatures": [ + "double infty { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.int0", + "origin": "numsharp", + "surface": "np", + "name": "int0", + "kind": "field", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.int0", + "numsharp_signatures": [ + "readonly System.Type int0" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.issctype", + "origin": "numsharp", + "surface": "np", + "name": "issctype", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.issctype", + "numsharp_signatures": [ + "bool issctype(object rep)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.issubsctype", + "origin": "numsharp", + "surface": "np", + "name": "issubsctype", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.issubsctype", + "numsharp_signatures": [ + "bool issubsctype(NumSharp.NPTypeCode arg1, NumSharp.NPTypeCode arg2)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.load_npy", + "origin": "numsharp", + "surface": "np", + "name": "load_npy", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.load_npy", + "numsharp_signatures": [ + "NumSharp.NDArray load_npy(System.IO.Stream file, bool allow_pickle = false, long max_header_size = 10000)", + "NumSharp.NDArray load_npy(byte[] bytes, bool allow_pickle = false, long max_header_size = 10000)", + "NumSharp.NDArray load_npy(string file, bool allow_pickle = false, long max_header_size = 10000)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.load.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.load.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.load_npz", + "origin": "numsharp", + "surface": "np", + "name": "load_npz", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.load_npz", + "numsharp_signatures": [ + "NumSharp.IO.NpzFile load_npz(System.IO.Stream file, bool own_stream = false, bool allow_pickle = false, long max_header_size = 10000)", + "NumSharp.IO.NpzFile load_npz(byte[] bytes, bool allow_pickle = false, long max_header_size = 10000)", + "NumSharp.IO.NpzFile load_npz(string file, bool allow_pickle = false, long max_header_size = 10000)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.load.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.load.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.maximum_sctype", + "origin": "numsharp", + "surface": "np", + "name": "maximum_sctype", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.maximum_sctype", + "numsharp_signatures": [ + "NumSharp.NPTypeCode maximum_sctype(NumSharp.NPTypeCode t)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.multithreading", + "origin": "numsharp", + "surface": "np", + "name": "multithreading", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.multithreading", + "numsharp_signatures": [ + "void multithreading(bool enabled, int max_threads = 8)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.multithreading.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.multithreading.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.NAN", + "origin": "numsharp", + "surface": "np", + "name": "NAN", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.NAN", + "numsharp_signatures": [ + "double NAN { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.NaN", + "origin": "numsharp", + "surface": "np", + "name": "NaN", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.NaN", + "numsharp_signatures": [ + "double NaN { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.ndarray", + "origin": "numsharp", + "surface": "np", + "name": "ndarray", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.ndarray", + "numsharp_signatures": [ + "NumSharp.NDArray ndarray(NumSharp.Shape shape, System.Type dtype = null, System.Array buffer = null, char order = 'F')" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.array_manipulation.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.array_manipulation.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.NINF", + "origin": "numsharp", + "surface": "np", + "name": "NINF", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.NINF", + "numsharp_signatures": [ + "double NINF { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.PINF", + "origin": "numsharp", + "surface": "np", + "name": "PINF", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.PINF", + "numsharp_signatures": [ + "double PINF { get; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.save_version", + "origin": "numsharp", + "surface": "np", + "name": "save_version", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.save_version", + "numsharp_signatures": [ + "void save_version(System.IO.Stream file, NumSharp.NDArray arr, NumSharp.IO.NpyFormat+FormatVersion? version, bool allow_pickle = true)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.save.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.save.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.sbyte", + "origin": "numsharp", + "surface": "np", + "name": "sbyte", + "kind": "field", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.sbyte", + "numsharp_signatures": [ + "readonly System.Type sbyte" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.sctype2char", + "origin": "numsharp", + "surface": "np", + "name": "sctype2char", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.sctype2char", + "numsharp_signatures": [ + "char sctype2char(NumSharp.NPTypeCode sctype)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/Logic/np.type_checks.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.np.uint0", + "origin": "numsharp", + "surface": "np", + "name": "uint0", + "kind": "field", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.np.uint0", + "numsharp_signatures": [ + "readonly System.Type uint0" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/APIs/np.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/APIs/np.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.random.bernoulli", + "origin": "numsharp", + "surface": "random", + "name": "bernoulli", + "kind": "method", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NumPyRandom.bernoulli", + "numsharp_signatures": [ + "NumSharp.NDArray bernoulli(double p)", + "NumSharp.NDArray bernoulli(double p, NumSharp.Shape size)" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.bernoulli.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.bernoulli.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + }, + { + "id": "numsharp.random.Seed", + "origin": "numsharp", + "surface": "random", + "name": "Seed", + "kind": "property", + "numpy_signature": "", + "documentation_url": "", + "in_default_scope": false, + "category": "NumSharp-only APIs", + "availability": "extension", + "support": "extension", + "status": "extension", + "numsharp_target": "NumSharp.NumPyRandom.Seed", + "numsharp_signatures": [ + "int Seed { get; set; }" + ], + "numsharp_obsolete": false, + "numsharp_source_paths": [ + "src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "numsharp_source_urls": [ + "https://github.com/SciSharp/NumSharp/blob/master/src/NumSharp.Core/RandomSampling/np.random.cs" + ], + "notes": "NumSharp-only public API with no matching export on the compared NumPy surface." + } + ] +} diff --git a/coverage/generated/manifest.json b/coverage/generated/manifest.json new file mode 100644 index 000000000..31cc6d535 --- /dev/null +++ b/coverage/generated/manifest.json @@ -0,0 +1,349 @@ +{ + "schema_version": 1, + "generator": "coverage/generate_coverage.py", + "generator_version": "1.1.0", + "numpy_version": "2.4.2", + "numsharp_assembly_version": "0.60.0.0", + "artifact_files": [ + "coverage.json", + "coverage.csv", + "summary.md", + "manifest.json" + ], + "source_surfaces": [ + "numpy", + "numpy.ndarray", + "numpy.random", + "numpy.linalg", + "numpy.fft" + ], + "numsharp_source_base_url": "https://github.com/SciSharp/NumSharp/blob/master/", + "summary": { + "default_scope": { + "total": 560, + "available": 338, + "partial": 3, + "unsupported": 0, + "missing": 219, + "exact": 301, + "alias": 40, + "coverage_percent": 60.4, + "addressed_percent": 60.9 + }, + "by_surface": { + "fft": { + "total": 18, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 18, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "linalg": { + "total": 31, + "available": 6, + "partial": 0, + "unsupported": 0, + "missing": 25, + "exact": 0, + "alias": 6, + "coverage_percent": 19.4, + "addressed_percent": 19.4 + }, + "ndarray": { + "total": 70, + "available": 50, + "partial": 1, + "unsupported": 0, + "missing": 19, + "exact": 35, + "alias": 16, + "coverage_percent": 71.4, + "addressed_percent": 72.9 + }, + "np": { + "total": 390, + "available": 234, + "partial": 1, + "unsupported": 0, + "missing": 155, + "exact": 220, + "alias": 15, + "coverage_percent": 60.0, + "addressed_percent": 60.3 + }, + "random": { + "total": 51, + "available": 48, + "partial": 1, + "unsupported": 0, + "missing": 2, + "exact": 46, + "alias": 3, + "coverage_percent": 94.1, + "addressed_percent": 96.1 + } + }, + "by_category": { + "Array attributes": { + "total": 17, + "available": 10, + "partial": 1, + "unsupported": 0, + "missing": 6, + "exact": 9, + "alias": 2, + "coverage_percent": 58.8, + "addressed_percent": 64.7 + }, + "Array creation": { + "total": 37, + "available": 24, + "partial": 0, + "unsupported": 0, + "missing": 13, + "exact": 24, + "alias": 0, + "coverage_percent": 64.9, + "addressed_percent": 64.9 + }, + "Array metadata & memory": { + "total": 5, + "available": 1, + "partial": 0, + "unsupported": 0, + "missing": 4, + "exact": 1, + "alias": 0, + "coverage_percent": 20.0, + "addressed_percent": 20.0 + }, + "Array methods": { + "total": 34, + "available": 23, + "partial": 0, + "unsupported": 0, + "missing": 11, + "exact": 14, + "alias": 9, + "coverage_percent": 67.6, + "addressed_percent": 67.6 + }, + "Date & time": { + "total": 6, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 6, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Dtype & promotion": { + "total": 9, + "available": 9, + "partial": 0, + "unsupported": 0, + "missing": 0, + "exact": 8, + "alias": 1, + "coverage_percent": 100.0, + "addressed_percent": 100.0 + }, + "Floating-point handling": { + "total": 7, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 7, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Fourier transforms": { + "total": 18, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 18, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Indexing & selection": { + "total": 22, + "available": 9, + "partial": 0, + "unsupported": 0, + "missing": 13, + "exact": 9, + "alias": 0, + "coverage_percent": 40.9, + "addressed_percent": 40.9 + }, + "Input & output": { + "total": 5, + "available": 4, + "partial": 0, + "unsupported": 0, + "missing": 1, + "exact": 4, + "alias": 0, + "coverage_percent": 80.0, + "addressed_percent": 80.0 + }, + "Linear algebra": { + "total": 43, + "available": 7, + "partial": 0, + "unsupported": 0, + "missing": 36, + "exact": 1, + "alias": 6, + "coverage_percent": 16.3, + "addressed_percent": 16.3 + }, + "Logic & comparison": { + "total": 29, + "available": 25, + "partial": 0, + "unsupported": 0, + "missing": 4, + "exact": 25, + "alias": 0, + "coverage_percent": 86.2, + "addressed_percent": 86.2 + }, + "Math": { + "total": 112, + "available": 69, + "partial": 0, + "unsupported": 0, + "missing": 43, + "exact": 59, + "alias": 10, + "coverage_percent": 61.6, + "addressed_percent": 61.6 + }, + "Polynomials": { + "total": 10, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 10, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Random": { + "total": 51, + "available": 48, + "partial": 1, + "unsupported": 0, + "missing": 2, + "exact": 46, + "alias": 3, + "coverage_percent": 94.1, + "addressed_percent": 96.1 + }, + "Reductions": { + "total": 50, + "available": 46, + "partial": 0, + "unsupported": 0, + "missing": 4, + "exact": 41, + "alias": 5, + "coverage_percent": 92.0, + "addressed_percent": 92.0 + }, + "Runtime & diagnostics": { + "total": 5, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 5, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Set operations": { + "total": 10, + "available": 1, + "partial": 0, + "unsupported": 0, + "missing": 9, + "exact": 1, + "alias": 0, + "coverage_percent": 10.0, + "addressed_percent": 10.0 + }, + "Shape manipulation": { + "total": 49, + "available": 44, + "partial": 1, + "unsupported": 0, + "missing": 4, + "exact": 43, + "alias": 2, + "coverage_percent": 89.8, + "addressed_percent": 91.8 + }, + "Sorting & searching": { + "total": 16, + "available": 10, + "partial": 0, + "unsupported": 0, + "missing": 6, + "exact": 8, + "alias": 2, + "coverage_percent": 62.5, + "addressed_percent": 62.5 + }, + "Statistics & histograms": { + "total": 9, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 9, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + }, + "Text & formatting": { + "total": 11, + "available": 8, + "partial": 0, + "unsupported": 0, + "missing": 3, + "exact": 8, + "alias": 0, + "coverage_percent": 72.7, + "addressed_percent": 72.7 + }, + "Window functions": { + "total": 5, + "available": 0, + "partial": 0, + "unsupported": 0, + "missing": 5, + "exact": 0, + "alias": 0, + "coverage_percent": 0.0, + "addressed_percent": 0.0 + } + }, + "all_numpy_exports": 677, + "numsharp_extensions": 117, + "catalog_rows": 794 + } +} diff --git a/coverage/generated/summary.md b/coverage/generated/summary.md new file mode 100644 index 000000000..642cded61 --- /dev/null +++ b/coverage/generated/summary.md @@ -0,0 +1,74 @@ +# NumPy ↔ NumSharp API coverage + +Compared with NumPy **2.4.2** using NumSharp assembly **0.60.0.0**. + +Headline API availability: **60.4%** (338 of 560 default-scope APIs). Including partial mappings, **60.9%** are addressed. + +| Surface | Available | Partial | Unsupported | Missing | Total | Coverage | +|---|---:|---:|---:|---:|---:|---:| +| np.fft.* | 0 | 0 | 0 | 18 | 18 | 0.0% | +| np.linalg.* | 6 | 0 | 0 | 25 | 31 | 19.4% | +| ndarray.* | 50 | 1 | 0 | 19 | 70 | 71.4% | +| np.* | 234 | 1 | 0 | 155 | 390 | 60.0% | +| np.random.* | 48 | 1 | 0 | 2 | 51 | 94.1% | + +> Availability is based on the compiled public API. It is not a blanket behavioral-parity claim; dtype, layout, signature, and edge-case parity require differential tests. + +## Highest-priority gaps + +| API | Surface | Status | Category | +|---|---|---|---| +| [`ndarray.data`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.data.html) | ndarray | partial | Array attributes | +| [`np.shape`](https://numpy.org/doc/stable/reference/generated/numpy.shape.html) | np | partial | Shape manipulation | +| [`np.random.random_integers`](https://numpy.org/doc/stable/reference/random/generated/numpy.random.random_integers.html) | random | partial | Random | +| [`np.fft.fft`](https://numpy.org/doc/stable/reference/generated/numpy.fft.fft.html) | fft | missing | Fourier transforms | +| [`np.fft.fft2`](https://numpy.org/doc/stable/reference/generated/numpy.fft.fft2.html) | fft | missing | Fourier transforms | +| [`np.fft.fftfreq`](https://numpy.org/doc/stable/reference/generated/numpy.fft.fftfreq.html) | fft | missing | Fourier transforms | +| [`np.fft.fftn`](https://numpy.org/doc/stable/reference/generated/numpy.fft.fftn.html) | fft | missing | Fourier transforms | +| [`np.fft.fftshift`](https://numpy.org/doc/stable/reference/generated/numpy.fft.fftshift.html) | fft | missing | Fourier transforms | +| [`np.fft.hfft`](https://numpy.org/doc/stable/reference/generated/numpy.fft.hfft.html) | fft | missing | Fourier transforms | +| [`np.fft.ifft`](https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft.html) | fft | missing | Fourier transforms | +| [`np.fft.ifft2`](https://numpy.org/doc/stable/reference/generated/numpy.fft.ifft2.html) | fft | missing | Fourier transforms | +| [`np.fft.ifftn`](https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftn.html) | fft | missing | Fourier transforms | +| [`np.fft.ifftshift`](https://numpy.org/doc/stable/reference/generated/numpy.fft.ifftshift.html) | fft | missing | Fourier transforms | +| [`np.fft.ihfft`](https://numpy.org/doc/stable/reference/generated/numpy.fft.ihfft.html) | fft | missing | Fourier transforms | +| [`np.fft.irfft`](https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft.html) | fft | missing | Fourier transforms | +| [`np.fft.irfft2`](https://numpy.org/doc/stable/reference/generated/numpy.fft.irfft2.html) | fft | missing | Fourier transforms | +| [`np.fft.irfftn`](https://numpy.org/doc/stable/reference/generated/numpy.fft.irfftn.html) | fft | missing | Fourier transforms | +| [`np.fft.rfft`](https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft.html) | fft | missing | Fourier transforms | +| [`np.fft.rfft2`](https://numpy.org/doc/stable/reference/generated/numpy.fft.rfft2.html) | fft | missing | Fourier transforms | +| [`np.fft.rfftfreq`](https://numpy.org/doc/stable/reference/generated/numpy.fft.rfftfreq.html) | fft | missing | Fourier transforms | +| [`np.fft.rfftn`](https://numpy.org/doc/stable/reference/generated/numpy.fft.rfftn.html) | fft | missing | Fourier transforms | +| [`np.linalg.cholesky`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.cholesky.html) | linalg | missing | Linear algebra | +| [`np.linalg.cond`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.cond.html) | linalg | missing | Linear algebra | +| [`np.linalg.cross`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.cross.html) | linalg | missing | Linear algebra | +| [`np.linalg.det`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.det.html) | linalg | missing | Linear algebra | +| [`np.linalg.eig`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html) | linalg | missing | Linear algebra | +| [`np.linalg.eigh`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigh.html) | linalg | missing | Linear algebra | +| [`np.linalg.eigvals`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigvals.html) | linalg | missing | Linear algebra | +| [`np.linalg.eigvalsh`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigvalsh.html) | linalg | missing | Linear algebra | +| [`np.linalg.inv`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.inv.html) | linalg | missing | Linear algebra | +| [`np.linalg.lstsq`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.lstsq.html) | linalg | missing | Linear algebra | +| [`np.linalg.matrix_norm`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_norm.html) | linalg | missing | Linear algebra | +| [`np.linalg.matrix_rank`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_rank.html) | linalg | missing | Linear algebra | +| [`np.linalg.multi_dot`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.multi_dot.html) | linalg | missing | Linear algebra | +| [`np.linalg.norm`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html) | linalg | missing | Linear algebra | +| [`np.linalg.pinv`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.pinv.html) | linalg | missing | Linear algebra | +| [`np.linalg.qr`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.qr.html) | linalg | missing | Linear algebra | +| [`np.linalg.slogdet`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.slogdet.html) | linalg | missing | Linear algebra | +| [`np.linalg.solve`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html) | linalg | missing | Linear algebra | +| [`np.linalg.svd`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.svd.html) | linalg | missing | Linear algebra | +| [`np.linalg.svdvals`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.svdvals.html) | linalg | missing | Linear algebra | +| [`np.linalg.tensordot`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensordot.html) | linalg | missing | Linear algebra | +| [`np.linalg.tensorinv`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensorinv.html) | linalg | missing | Linear algebra | +| [`np.linalg.tensorsolve`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.tensorsolve.html) | linalg | missing | Linear algebra | +| [`np.linalg.vecdot`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.vecdot.html) | linalg | missing | Linear algebra | +| [`np.linalg.vector_norm`](https://numpy.org/doc/stable/reference/generated/numpy.linalg.vector_norm.html) | linalg | missing | Linear algebra | +| [`ndarray.argpartition`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.argpartition.html) | ndarray | missing | Sorting & searching | +| [`ndarray.byteswap`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.byteswap.html) | ndarray | missing | Array methods | +| [`ndarray.choose`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.choose.html) | ndarray | missing | Array methods | +| [`ndarray.conj`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.conj.html) | ndarray | missing | Array methods | + +## Counting rules + +The default scope is NumPy top-level callables, ndarray public methods/properties, and callables in numpy.random, numpy.linalg, and numpy.fft. Types, constants, modules, and NumSharp-only APIs remain searchable in the JSON artifact but do not affect the headline percentage. diff --git a/coverage/overrides.json b/coverage/overrides.json new file mode 100644 index 000000000..eb3a09f46 --- /dev/null +++ b/coverage/overrides.json @@ -0,0 +1,115 @@ +{ + "schema_version": 1, + "aliases": { + "numpy.acos": { + "target": "NumSharp.np.arccos", + "notes": "NumSharp exposes the canonical NumPy name arccos." + }, + "numpy.asin": { + "target": "NumSharp.np.arcsin", + "notes": "NumSharp exposes the canonical NumPy name arcsin." + }, + "numpy.atan": { + "target": "NumSharp.np.arctan", + "notes": "NumSharp exposes the canonical NumPy name arctan." + }, + "numpy.atan2": { + "target": "NumSharp.np.arctan2", + "notes": "NumSharp exposes the canonical NumPy name arctan2." + }, + "numpy.astype": { + "target": "NumSharp.NDArray.astype", + "notes": "The NumPy 2.x top-level helper is available as the NDArray instance method." + }, + "numpy.bitwise_invert": { + "target": "NumSharp.np.invert", + "notes": "NumSharp exposes the ufunc alias invert." + }, + "numpy.bitwise_left_shift": { + "target": "NumSharp.np.left_shift", + "notes": "NumSharp exposes the ufunc alias left_shift." + }, + "numpy.bitwise_right_shift": { + "target": "NumSharp.np.right_shift", + "notes": "NumSharp exposes the ufunc alias right_shift." + }, + "numpy.cumulative_prod": { + "target": "NumSharp.np.cumprod", + "notes": "NumSharp exposes the established cumprod spelling." + }, + "numpy.cumulative_sum": { + "target": "NumSharp.np.cumsum", + "notes": "NumSharp exposes the established cumsum spelling." + }, + "numpy.pow": { + "target": "NumSharp.np.power", + "notes": "NumSharp exposes the ufunc name power." + }, + "numpy.remainder": { + "target": "NumSharp.np.mod", + "notes": "NumSharp exposes the equivalent ufunc name mod." + }, + "numpy.round": { + "target": "NumSharp.np.round_", + "notes": "C# uses round_ to avoid a naming collision while preserving NumPy round semantics." + }, + "numpy.row_stack": { + "target": "NumSharp.np.vstack", + "notes": "NumPy documents row_stack as an alias of vstack." + }, + "numpy.random": { + "target": "NumSharp.np.random", + "notes": "NumSharp exposes random through np.random." + }, + "numpy.ndarray.itemsize": { + "target": "NumSharp.NDArray.dtypesize", + "notes": "The element size is exposed as dtypesize in NumSharp." + }, + "numpy.ndarray.data": { + "target": "NumSharp.NDArray.Data", + "notes": "NumSharp exposes typed unmanaged data through the generic Data() method rather than NumPy's buffer-view property." + }, + "numpy.ndarray.round": { + "target": "NumSharp.np.round_", + "notes": "Use the static np.round_ API; NumSharp does not expose ndarray.round as an instance member." + }, + "numpy.random.ranf": { + "target": "NumSharp.NumPyRandom.random_sample", + "notes": "NumPy documents ranf as an alias of random_sample." + }, + "numpy.random.sample": { + "target": "NumSharp.NumPyRandom.random_sample", + "notes": "NumPy documents sample as an alias of random_sample." + }, + "numpy.random.random_integers": { + "target": "NumSharp.NumPyRandom.randint", + "notes": "Use randint and adjust the upper bound; deprecated random_integers includes the high endpoint." + }, + "numpy.shape": { + "target": "NumSharp.NDArray.Shape", + "notes": "NumSharp exposes shape as an NDArray Shape property rather than the top-level NumPy tuple-returning helper." + }, + "numpy.linalg.matrix_power": { + "target": "NumSharp.NDArray.matrix_power", + "notes": "Matrix power is available as an NDArray instance method rather than under an linalg namespace." + } + }, + "support": { + "numpy.ndarray.data": { + "status": "partial", + "notes": "Data() returns a typed NumSharp ArraySlice and is not NumPy's Python buffer object." + }, + "numpy.random.random_integers": { + "status": "partial", + "notes": "The available randint alternative has an exclusive upper bound, while random_integers historically used an inclusive upper bound." + }, + "numpy.shape": { + "status": "partial", + "notes": "NDArray.Shape is a NumSharp Shape value, not the tuple returned by numpy.shape." + }, + "numpy.complex64": { + "status": "unsupported", + "notes": "The public compatibility symbol exists, but NumSharp does not implement a Complex64 storage dtype." + } + } +} diff --git a/docs/website-src/docfx.json b/docs/website-src/docfx.json index 5e452a468..951556567 100644 --- a/docs/website-src/docfx.json +++ b/docs/website-src/docfx.json @@ -44,6 +44,11 @@ "src": "../../benchmark/history/latest", "files": ["benchmark-report.json"], "dest": "docs/data" + }, + { + "src": "../../coverage/generated", + "files": ["coverage.json", "manifest.json"], + "dest": "docs/data" } ], "output": "../website", diff --git a/docs/website-src/docs/coverage-support-dashboard.md b/docs/website-src/docs/coverage-support-dashboard.md new file mode 100644 index 000000000..8f90829e2 --- /dev/null +++ b/docs/website-src/docs/coverage-support-dashboard.md @@ -0,0 +1,851 @@ +# NumPy API Coverage & Support + + + + + +
+
+
NumPy 2.x parity · compiled API inventory
+

See the supported surface. Find the next gap.

+

Explore every public NumPy API in scope, its NumSharp equivalent, known limitations, C# overloads, and the math behind the coverage score. The page is generated from the same artifact published by CI.

+
+
+ +
Loading the NumPy ↔ NumSharp coverage artifact…
+ + + +
+ + + + diff --git a/docs/website-src/docs/toc.yml b/docs/website-src/docs/toc.yml index bd250a93e..20db4a1a5 100644 --- a/docs/website-src/docs/toc.yml +++ b/docs/website-src/docs/toc.yml @@ -12,6 +12,8 @@ href: buffering.md - name: NumPy Compliance & Compatibility href: compliance.md +- name: NumPy API Coverage & Support + href: coverage-support-dashboard.md - name: Array API Standard href: array-api-standard.md - name: IL Generation diff --git a/docs/website-src/images/coverage-support-capability-map.png b/docs/website-src/images/coverage-support-capability-map.png new file mode 100644 index 0000000000000000000000000000000000000000..1cd550a3134e51f9e2646f2584546a3d4becf008 GIT binary patch literal 50603 zcmeFZXIPWly6=q@6(=|+XjBj^D5wY`ARv%TMZ^jsDj+2S3L>2Vp`@q?C@l)oOB7I4 znn)**s0aZmks2UCgoK2e5CVaa_9o1=&pLarwa#^}z4yD{FYgD)mFIcJc*eL#yT|`G z?mWM4VgB2;z1yUuq<*_}@%#-bsr5}#QX6h=*(|D#bfQ-D7 zTc(?M;UzFJ$bPT+-qxxMpZoJv_l8y~yKEglKpD|EQrLvK(;qxg>AQOugBleszoYsW z)|F9owSQxzy2dxJi+@5lK6kcy;&*+1v*-mf59rXhG?6vqP%wRFq@b{HRKOp5yvP7L z22J;d_SM$ak(pdDg3&!8sfK~OC>A09lrqp)5LZshApF1e!`)f|IX7aNffmlHWTFv# zC$=7i`@NF<0J{Vh<#Llmt41B5J<3Q-D7cDMj`SKudV28&^l@bVJOSCu=O_~1k=98` zeVN{OTLH|w%+^9M8)yU}O(g@(CpeZ3tnw@~T#Vbl?mL}WEL3AnV!3B0Eavsnjt-{2*{ai(he)5;lNE~;%vSw~X zu8s~0!Guo6Gxd=R6qX){n<h+1#vp6Goiqhd~T~BeN}9A7@tDR7A=PLY95Qh ziS5lq{uB%YIg*P4{U@csr+Drqc4wx55^SZ!F&s+eu);fV0vvK!AWjIveQciUX6hol z;rcvFA&Rdx7l~ic8eKuKh2%h2RoB%#vNyu4d9e`JQ_r?>1r3$;;I>QxwZ{BGB-qj% z?g4NGQzIZcUFB_+lKQk$Z0}P3FW=}~M)j?;nSG+}ArU{CriNr!Tm8;Sk{k8O**YY< ziG~6V!_7>c*wC|GoN~(yvPw)Z%V*Y7$Vj3^s38B~e*@dLM@3RmnaiT)AqGg7DH^qD z2C7_FKrTsx5~>Bu7`T91DtynKE)+LSQ8+(>Da}h_dWckzUHtrg1-J)7%J%_T`~noM zi#*|~N|Hl#vGPQm2wJvqcZ9wSNPtn%!|m~DgF7`-guf!>pzv4lD3UPKl<`H}m$GjA zTk(rUqdU(Y2Ai%lsOT|q0$(WEkik!4lAu?k*IQ!?`Cyz;J?#xxB%C*)q4~??ImR@i zfQv&cIc4^%Z%97}tmMx{yr9yB`oO1k~ow9}p1*m0`o1Q@XCe zq+)?AFSZI#TimHOM$%VS%#o`jui?jxQ*elC-UQYY*Tv_6Ij+^mZy?Jt;XKPxA*Y-S_ES8Fhodm}*sr}_6#t-5>oEPWdQ1eQ55uGP|J%Fy5TdwmBw=^N3!P)* zkV10`o+SdR=XRi`BG$9Da4I6bXID})$^0IMh1;?geo5S`Tfqp>NWuv&6{54;U2u`+38k_9jPY+K8&Ex zCNTvSk@}E{*T_r2 z8g*sdAKHsdHP51f3u+)5~o;>g(G2&;IC3rzt)GYl&NL7=kRW@ zBLT?T+OWA=S{H%u0+|pkPthJnD|={yLwC!(WTp70vQpXm>872rSt{^OPNln5J^N>= z$b!vV*w;IsN~&XWgeO<5!6-qrN*tM;y#AvAe_)pRAz>43ITOqUA$0|)^A5at8b~-r zKCQCUG(w&eb|t)dP!ThZB6}jNm*{!88_51^N)8Hbpw}!+2YONTDQcxqMHlx+{Md>N zGza`?=GM`e*v>0{!@h;uBA#U;XlAq2m;To5mIBc8v)eB$z=_Il3H|6# zUwNIovitKUTBHJhXN(Fzip9S(;45|-YMv=`7nA19IieYN^rdauMW`$_LvX<8Vy(tm zE7;|)=WDjMb_FJ9Tcgoe!OSXQcZfcOLMiQ_Uehv`>3GqXT&iw5-=%ZVY}K4F&( z55Vewn!8)dkJXxe;b;*RQ&>0oZM8KtiCxXy=NdEqwm~ww7Op@Wp#hRPi9-04y~|8n z>X%CrGyjMA{P2O%(}u_Z zVZ@p{q2YMbnMbWpfmNr8%PW<2f~yuW0lwI?DS4s`EF^Yh>tjtq1gRjB$+8Q3;up)v zmmdb{2oW5_&d+@Goq|BIt1b}kbDK;ePlQ_-q{V_$5uzDdtmSUfu)1Ms0Ak6I@J3y1 zWA~X41bCOA@3|+A|B(GaBm$4@`~ns};qzVCP1r5J$ymB7n$y)|Nc8sH5Dgj>5B)Zd zUH|WMkO2=fnSU%p<9o)-F`oRTvPVw6H?5RnVq63;Bt4vD=Ffx1;#S&P|JOSs6~R8r zA(JojUuVdZkIJ_1d@IPN_A_R-397;bo=}vys7oA8pMv8qOE!j4<5gr4v5}4$?++@l zMed}MIy^-Ivz|4+@L2}Xj5izTd+;;qr{Gj9H!aJ?5Vx8|zpk)B>QVV&(a#9YceL%1 z_I~;X8nnPNgEYZIGrnFF);1xQ8pwmQhIbVUfUDR@Uf|BA&mAik{xBPd>dI@J59Fxn zJj5YwA6F66xQ*LKH>MZGj2Bj8M}}*IOhWnR!WNThmHML(a>9E<81GB;^~p6O4%d{c zjYo~4bOm^p)yZJFk&wJv2tD~5@|}J2B&nmLL3G$OR4@QaCzg(c3_nOEa(L=?&v?OS z!s4KyHZ!QmAFn;DgVf3ulpHp{?k6xxd5h0ov|#z!=-Ui%n%=RNp1;4Yi=K&uzKGy_ z4C#g5BDokIJsD97nYB|eC#CU+BFilWrz_eW{RS@>0P8|J?Pe|fjXWY`F`5s(2kJM; zS4~|sV^xx3om2}y0+}{971Z#-xw!^Y=0!hPKB2O~ob=;}M7rPOHZaA45AWM#HL@&SqHQX%~DIrRj+(!%Ui3aU_4YMCE7{!6Ab z!EF3{woCc@gl)|$p6gjewI_5S0Fc~8Jl1QoGq)626YC-<&)a`1vZSvd|2k@$(53+8 zIY9g#dObl%R5OnC;ORvoeyx7GG{1_^HEN^aGoXo0x-dpC_a2x96Q4(c#j(pm{JnZE*p6=3chi8wO z{{WHb<6s%%GGn_~@JC~l_8HNtt*<^Is5FVgGMvKe)s*i{fanH0zJ#6_usLZHsGR73 ziVnYHZ~;HCY}UbCDU`ZkRYa)m0trH3j5>O}*$sF12dPF?e)YXoMG&v&1m1V9Ao)4M z_~SyaubNTSK`iAcsjc(u{WCJbhz@OQN}{3;`;M!!y-?E!=EbTX&R(_&7UXDT(a67! z3_jzG)oRWd0>I^q!H3E{&C)i(m1@~3p7N+99^GKs@CnJt$ybx>Iz= z(y?%-Zs4T0X^l3n8LZ)h^aNXGQeJF^D_@Jp7V+wz~8=n1|x2fvA zy6lo!4Mshox<@ovD+G)LfWc`q*8DR98TgboigX?K%6;^M#Xc@mA$+vV(bq@zu@zJ< z@zaMnGr|l!Xl!>?11}T?^uftsf*x0EX;2_xI72Sw>as~t)*T;AI${r?B~az#mKn_q zR%q9z%42o6(7FB=nlI8_t>M?2kA_=x(-U2{p^5m^*+Q)y!i+0;a)ebRX>XDL`Y01;@K@pbF&P`61Mc%j%|E0nX>)GwD7b zz8%a!PY1by#7I(kHE6nN}=2Qr%giBxlP;tHS>fWls#Z`Hq9wWel44PpX=u|A6L_ojI zwTR5k(mU_?E(|ONyLYl)eRBM4Ia5}n(p96{JKP#)$KmhgU8%~fKW)sM@@#N*%f?rL zDK+1TJ6uWA!{JP!)eZp%AR=AtW{$;Rj4-XskBFB# z3$kqBB?Yrq3Ixl};B(T|-_=b2sFp~9>w`+?Vig1M>9gU} z1~OHdbE%a(Ho1Do_feaU*G>K~)0^WlR>n6$@nJgYQOAY-gSc+4)NLH7Q*G%-54(zyO95u>*H?`E2Afg?Oh1pB@i*oV$ajhOAtUSaKXsPGldY-$KtEjWjFEDLN{E1)lwU zE|HWX`*Emh6g8T&1cR|U9PS?Co}8YG#(zL(8h1XKOE@LihQGSADNJfed;lDL2 z>%3W%ETe)#jX~8jd4qKH7QMrPD;8T2^eHM56%CZ$Y78{T7a$n7O!ya6+8VW6q zwNknH*yNT1ps2A+xTLKRcfa1zqy*1i1UPvKi3DJhg3W-kAu0g4WSC>^puqf=CR~4B zL{uw^^*OCNQZ?IJg0|*)SHA_YSnm7!9aZqy3W7VpfTzdBQ^eCzG3v1ILku@K+Ygo` zlGFS?GB827Qg?E?Y&$8EPziG1rEWr-BYgC0&5?)u_u~~#C77d=TG4sL0vY>|F(PTt zz0udRIjHKv1Uo;kIcUt1=e_WB;9XGO{@bLDISO7cDC@X3n2_UsV8oITGSOK! z1U*&S&Zf+m4@BpCpQ;)QS;bi!XGebU{33LHhxb?==&t>oDSbA4DQpA?+B^omVg{S* zc9q|@tQ}r-mOM;8$|!*fD-Wv2s1Y(#cKMzmaaq=alL<%bkH~>$U>1&mzN#qV6!0(+ z$3LS)K$-UQY+)9QHPh&sm&}|WpvC!lSM;SA4X@}dkRj?Y`7mS7N+EV6zXG&=>Rb=p z3&Ot5?+mKGKKW}S>GHQhP^z%M5aGQ$aq(Qi24l`)M8lb?_DI;YK{0#=OVf;d5Qlni-3R>3l;w z1-ES}j3A5|hG}^w2jiMTd`pT;APtQclNd%#IZf_F=C4wJTN#h9>y3iE#zG?JdLT+S z*wg*(+2iSmNgx$}`{|yn^ayKszg>&d29Ao33CbPiJ=wT2FkBx`OVNBC!0S`#vUD(A z1P0(UW)Hy*eIV{Eeo#E0qi>45c53yV3UPt>+TW0-IxK=gY3T=-vi5>6xDYJ=_>TuWp z@l~9*f6^w6@&{iZvl=%A%Fc*Q9s2P^QH^W;i2y9MzLncU@AWh?D`S`JRO&VVSY!L} z#GQKoGf!95_tb3Ze6TOYD1PC0W3u+>W<$#WET_SA*xuht3Hj6zR*_WEs3CaSm+sKp zX@Sg~(#t5y|Go>oGKF@`JSW)#oit^f{{h;=@1a_hl#^wMel`1>8&Z0StkE29}N%9SOny>koM9N><#3#vpWFT zl`9=GS}flu8z8D`iGbF4s(CW7!)t&$K?Lngtx9Cwu9&|VaZf$v23;wojAe# zHiciO6ivMrP@qyR&eu*-r9_xmVzCu&dYQ;{mokX^r#C%J1iK$m7HFL$**{H2heJv0 z-WRAs6`H3Awumr2a}o>Bz3$_bBXgfVtInuSb6+V*T}|!?i|dt@y!gAwgKi^_Xd- z`7H38Aj=UWEW{!M+Kw)Jq^PB9!x-IGKRg^B1QT}aKcQonu0l`82-Is$r#xmTj)#QRn$s%<#idtVoBiYY&y0}YLJsunkHWbC;Ac!TJxPq*)z z_cI&zE(eJsKVPu&THb1CZN}1kFMxz;{}vd_*s;P`|3Yrb=MBMe|7A(Dx|7_1GeaQa z0GPkIr+a6IyqSM}%QU)`o}z@kkg}_3XF#dX&8A2=87<=n#UUYkv0SB7gA=`XKueIW z%z+@PwT8Wd95Wy2#fTDtDz+Y>VK7^d$UoGOBFh}Wtyr{Zj%jMDcB*VMCib@0{%8+{y_EH7RIM{>km#6o7sko~QpwJ9}h!UooVO zPCPYpQ5Q2h=Xs( z!~A2$4Q#^p^_m6jKlWszY^Bn(rNFjAJ%Q!wxK4Zz!Pxdw39YAxI0b>p|&pnje8Bi7{NAK2JAO{rji$4<#;YJ&meLlt&4 zMbvRCN@NB@_w8KQkBui*jBheQ#2b+Q;($Y{3rq2i4KRL=3G0UC$9$jCyS|XDr7=gOZliTEb{BbGM2vI-a}+l~_z}4c zGKW7{~iuI^&amWLIS@1XC_&5fU!`vz{$T*Xqi zOXh|f*ihe&JXbp8AumaA>GMl0up?e*2=^MmRuULxs+9f_{lLX@4`By;?z?|hzYWa{ zqvsHY>lE7B{mp^+xtZ+~{q?%8V|R8|5dg2pPWP_vF+m&B?!{l@<=auRIe7JNpb#TN z?1{afcNWKoHT2raDkwA+{3x(3QSYpu8JYrY3wIex(oPF}b1zXE`smcAv6{)|cbY&q zaI|Y20JzUj09mm8V_;G568cDUHT>EF49EvKt~#0?@10s!Ogd=0vo&HYbwe;|FUak3 z_0)uTqH{c$uJXnoI1{R#SUd1B)zTAfP54d5&t*Cx$>}HCtgO;9docgn4TJsn5T#(m zZFGBFoSDtwMBf9b8#l{7^&R9Snh?m-*~I@|7Si8RfxGP%q*6~j8o`Pn9UC{~@Ja^;-+a07ReQsZ4ja{oitl|;++ zjcmcLOnxbVey)QbfhIT8>9OOrX8J23$Dl7Ue&VSS-XNDFTc-JBj%ir=HE`tUXalfb zrs3ZEhB;j@u%}k3fuqi?0P`Te4XG!t_rNx-X5E9hQtz0!Et!K-7LO0g9dxY9)&Ce) zb~VOb@WJxu>FQrO&cKc!kJHjZ*gFz&(}%hXyLsJ-l(bpjI$+eM;zeg+*ee=>C@m<5 zJMJM^)^MW1n_5+7R;Tn%?JAD2O6Y;TL&DGbvMaa>GCQ04@rp*Q^H3lPP-RJjR z6v2i&XlCcOZeR=TJzi73#KB{qRGC{T38TC?X&B;^H+A*ZMnf9~bcf@3?AikN%m_W@ zunXVm{<)!F({+%j82d`o7DCKYCDy5*=EEdcAcQu9jT7a27a1o-Zk?Odxc78O-^5oyO)+@uC8~L6rx@NtQb`Gob(1 zS5(G0plRb?z}mvUc1g1ItUY!05<}C?YP-Y9|D^Abr@s00m%kj2zr2*3#9=Fi4T``1 zayb6-QYrs`~=@9(hrq?scnw$k*eN_8En@==aFZdJ&P{jSMi*aA~V{=a;valV0W8h#+mQ zm{#POz3<=ugJ)Io=GQEf?-~z$?`S%x%o7q+07Ng{H4IM}VUO=0y)`mbG6MH@23W_KQHr=zaHT;yMmE{Pw7=GM=hqq1RB+)ze;nq?U+Zd!X|!o&bqL7b~g zG0yOB*)G-InXYyhuVD+JIg7?7HlBn6Th9wiw(BcTBwLo*T5Z3J{QrLH`Jd`y#Z}@% zPtA%Q*+!+ha*-%7W@I>&LNcl@Q7irMb_7~2Sfgk4DOG!nS1+?O7zOm&LnraG&+d6S zVOSvxE0bXmc08%0kIHInLGVIPhWcpkkT`Li zgML|F@~)6Adx&cwt^(Pv?S5L~(_$hH(_drfS3#ML&x=}(9o;ORvgd1Dx=ogX!pK>6t1ZIJb7;+;_ zeILHs&p8K|W$#f4D^c->UG_|RUbeNC*qWk5o}<-nz;klNCO&B9ujppymE3x_@Ok1> zO`VrRm{S59jiDX+(DJAqQDFQQhSSpn`<4}v8+VUzYuT3}dIQW)T9n=ODhDpt+%M}} zcw@QjZsN{?1SsWy;RZwKm0(Zih3L}keVNpAuM+QGY0=Y}H~qRZha8y6B6>M()kJiw zP?SRONA#;?B&)J!g$>X?%z26c71jeLbRgK6g~8>+2B_6~6@B!SZJOC5sO&DP&amYf zMlf09_Jt0Z>|*_vYjZlrWY!blAaZ8-0_n%n+ckwk_jq0pH|vb_?b}BJ($bM*8OGus z#@$ChfPh!f6pNJJ?YUa6ylm+0z9cTL&my`XVd6pAm-(Tx>Bp~|vOI0QQoV+6K>^jp zGhekg8alO}Nw-eKn8l2b$-d%@*d$eLaQzx{erNs-qO~tr}_vl_C`M#CuAqx4)L;<`DG#Mv`NATksOiZx%)%S zN0n_(R(abNm&vZC?91e`D-Rk9l&u)=FupPZDTw=gBlQe#~BOjw;sQWSI1otz$ zXy=l%BOa1BadnsFO>#ILF86zX&|7xnoV(iRd~Hs~2}ZK3xk3{CG;|g}E*=)yZf=36 z(9MP?H_aIvZXX&j^LHc3v%`&T!q9AX&kyH}ueyrgX4&UKdBG2ra?hRIi*H9P4p95& z5|Y1q$wtiGhkU}HNe3gBLhaFs!;W8a4G^j2MjjufVxFi}=pDIHL7vQZS+40qjp;Q) z9)iYZl7viKXToNz`{MoS+F2u8SEVBF_Jnv!?(IK<9iL7Kw+o(an=treCb(k?=f9$Vtoc5F-h)@-0YC|>l(?^$>vq86TCWps{ZDQu z68MrzYfDEHwGs(|q}GGSK12LOu;!*HJ;v04ZBbmt+KBHm+||rt_8?7;V4A{mwUQu;f%IUJtzkO>G!r!Ftw^s%Y61ytw)VY=lO3;rk~-rotI$~g2NN;lPs+NA zw%;*~iyeIQBeU~47Tf6vg)XM$AhO$!N+yOfb)lKEi4~PTw(be~pV zDu)!ORWWz|c^IKJu_#KAr9KYRwAniy{Hx zYbba>+KSv>tEVTuOrX!hf`@hJtv}rZ&!A0`lRb&Iv|Su9Nq8vT8!KAX^SF@Ye`dX; zBWajkC|EFT0hcb=l?9}skai?#aQwSAmEiwJ9Wb~oN^ z$QdjnJbZO<;v zg$2W3qN4>-o4y?6Zm-U^JGs^~ru{GDO^`XVdApkDjV&hB9|ATQ$FDYyViheI_l_y+pp|=K1;lMP@(DltXF_7*5ZbO`ztS{KllA7 zy|?3T{lFUCbYOT8Y}7XO#|d$z~Sv_-*2pU|#+(%fF|Mvj=XESaI$J z(w~lr<=xDSVnDPMu4+ilixz zwHByr#!P^B9OWW5KWhA^H_`n)sC5RKlA$Wq`+o#C|CL?rKjBIkd4(oleWpkf9a1F* z3P%Xwn*x7HY{WZ+4-y={oHSyKm=9i1s!+>lgZk>(oJsY~N5wlm&^%nq91i*F1trXA z$)P~=t1E;Wr`6_S+K=iS4@MX1s6-8N950r`Ts^kNBdSg6n7T}u5{L4s{l&{UPn}+O zhN7h^L9PVYV|?-+dxADvNP$oxm&VQ@oje7!QvH$DDti@k>pfXvnw*OeW_5Fwvn=t2 zWf{z>=$k-je<4%mwOq3~6HyQzm%EZ**K}%o<_FAv>d@R1MXf5M8xBxZHEA+tf+H&C z+?PyhSE##2y0bVW!@FXgW&a2+oTbmPyiipP)*zXMokEW&4hOHB1CWK+X1G)x$MBSQ znDNlm>dBzvtp&C<>Ws#POKhPuDce9<@Xf-iUKVrG zVp!lk6?t=Jmm@p-)6Qu}-teZ}r;)~`W$a?sf_TR7te`td_Qw7HMVWUkzA&p^W#@9 zBur(xR%o3aY~pARZ2D}*+A%Jdi5U~gc|ZBa8u4c-s*Q$^JULpbJsQseM2$HHee#AN zjmEw!3vu9AjnK)5<0x-v@B#hRK8B7)Oav$$WoAUKdgmNi z%fY$pB-Rb;xP`ZeX-YrSknn5w;=w||n3cmudMq_I)6&Ge3Ev?in(XSNpWMJ%g%0qE zp#V5dE!L&{Ld#A8bFRN@%utXV@28T!RNZjoDgK@Bor&tHhS4;NGq$!>g`K!sdM?h4 zb#rq;jy1`mpZLEhkXoC;?>*0rV$KtzL%%}D$yexYKJwdnQ9U-~ z*>mA$_~+_9PY-R6JA(H%LFV2qz5>7svmgA?nLVGE9jHh-SZG>=3-6oeI0LJtCFAoC zv4Edeop{*jIL0BLt-rjo;?OPkhVK8VW|8!HS8pJQb1=DTMm3ZP5MB*VDmw=kn(4Pv zdd+JAr_kw@YN6gRHDYHVt|LT+!7UvfNSG-Rs$T3Gl$%&ME=UU*p=w_w18?KWU|+YY z^u@fDFdbZpJ+ao+=+@u45cqvU?5LOvjR$R?`;M{R3ByQLM;KJhseQm2z1y~7rf^5y zq%8UQjO&$Ak1F_8G!b=J&`a9#Ehy$>ajGmBtQ!5b&wG2=%emNll+J)~=a=|KOxpz` zt+nd4ej6;O-7i(`;TAnzR8lEd869f{OLq$jP))TuC0eElbwD*&9k|KaYiClqX4U!X z*cNVksmVj&3>R&0lL)sYAhS!$)VDL99>I5Y4a%Sz+UTDe?ke_ce@9LEZyWvdUh`Rz z@!*m0hA!UD=`v~>9&1NzakV$Kf_;R=i2dW|P}8Y>=>}f?-`lWk#Up;79(8Wi9z?A8 zUm#sLA(Y3T0xJ|WoptybC4;CJZ*D!vNzk`lY1xIE@9WfM8`C!Szed_=RZq&|ls=J| zjL<>)cgM*+5|8C@Vx*->3G<2iVD7-nWUGwdJr$>BF0=~c@rg=@@yg4GpzW7H{u{$y z>U}1)!5k0Pk^&#IkD?BeXMt?Z*>1%v%{+mUE(|2*Ped9AHg ztdbH@h$`UwJzlG7$2Av9?$1jbl9lc2$z15GDI@CQ2xEWEmWc#j*6gm9l^JB+P$ObT14?R(dyIAVGnT) zkHxT6q`#|yvTIxd#yx6dqY(7H7pu@$yBA%@-;mScctTrnw`&hiuX>M;R<#g}9 z%6*pF0m|=$DJ~4&_cOhX-$-3%feZROd8M|yc^YfNr^`d1!)R*0*j-Hvr`30Ad~&l- zGAS(<&;wHJxA)AvfDfb&JM-tKXwC<}?dqjnA-a z&hRR6W(gDdo%Nc~#uI}HSlM`e4Pk!MAO3(MOQt~lMr*@rQoy*6k%<6AV2f8i6R=RG#Q>SUN zn${M;gVmE3?YMbBcoAlQ|9agPg{CkSBM;dnJ(pJuFkPeeh$=BbxA3;}$)IarLnWs( zG{@TAkK2VWQv9{|(hjwI)Ca%n5Wz+p=fsB!ziMsyNV&R@IhU7AUd(uflWq652Kj=0 z&j(zSA!PbHS%?F#&L6I|f2R)INy*!NH&!xB|LwpC{>AZ%qJxZkaqE9KxVZ*^ikN97 z2WG#l``;eYYl3?BD4thns+qhT0Auua;u%>WHO-l+_@~%wXLdNB+Ra~riqX8&a z->kX&f8J;L?>-Cj-|SNT|Hb>KG*CSAX_>HW*fyXn`E0i2VlZqb5W@(4@X0P0TP890O{?a>Ab{s*)nS@mBz9$>j6Xr z5~+1Wka_N{OA0mb?_t~OQ@N!&W49#wq07-{N27l4mgzBkF&;wxHXspwUMOr(Xf%K( zK8DMGAsf@J(dui)~Fzqt{7<|3078ba!h#1LT-H3Z2eNF2E{Smlg zLw~H~-^@8dZuT$B&j<1W`LS`J*3Cr#Wa4k)9Jp$OQc7$3fYj1|70dolv625cwq-9n4p&-Hg+RuX_esfcxw&NEb>|bP_ykPGGe3B!?yd z$6DP_Vcm8Wvor`}HKl&akrd@D)Ec>9*dt12Z4IyLJV2SAx@`(Bk%n(s(AJaH4+b9( zpX((lL+%3eygQWIj=qviKp{07-olsr^5xH*<$&tWTwC->?*;CPqeXyKGV#J!xuIZr9eagnX4ES5Me|c-CmrJgjyx7PB}&*C zY&5^=K+BT#GGVv0r((IQ>*6(bw8<;EH}G|Tcz|;$5Dqfr8gX>g2EI09UtUO$E7dN& z1EEZ{IG3o8I%e@W+{m{`K}b$t1}U!k>B~{JA%aV#l{khO&~ko;WBW z5V4O(QZxS6mewlBF#qffx%-9{ou=VsRSdU1Vgv!NpR^#DcZlnG_D!`nq3a(1=9s>T zZ1!+&rXtkUt0GZpT9}W&XL35hoT2ot)XMc3{y=O+j_+}a@0#r<23!Rx2~*#V2aV9Y zj<0$&9kM0apu!@9uvn8QOlRkw1M>9sbnpS<|v`mRwh)dN@hPVHmXcTZx(Af-v3!*h0XTRVXfa z;1;=e_x8_XnA14F_fYR(*`;%?Y{B}o>c1ffby9JqThXK?>jd9AF?g6l{2O@C^#xM6 zZ}EX@pq%@LN`wgm6t&E`sL?Pxn>@xHT&iAl;38g{FI_wFs9}C33Qa0oh%;3ypLD~I zlud4f%I3M2>%4S`rs_Fjh7H?M*J`}UdiOmf9my^#&SF9*pKw;q$a0maK<_b>)_*~O zt%3BjVkz_BKS4I{y@YpGs@%&Gu|XzEp$AvR&oT<-Bk?rah{6d*9?jihl`8Uo4anxjdI=s zbmnZ$;D!>f$8YbHVh2PU{q_VZUZQ&$yexNAYjqd@@QOp0_khk2w6O=Uju7ec7lY8P zs{f>v+i*M?)|*i^I6WZoT%zR-dx8>S3FJosWKfZ2G_){E`k(f0_H*Qh$GnQ!P zrVF)DD~)^6H=ehhc!)i;Ny#EWH8jy-PJVI+cjL4qkG>ZASu=l2Z21AOTMBt034}a= z1e8!?JHFH=W?ghr)lXDuwVHyyru{uAr2Mj#Mm}W0U5m>6+NyFn1$p+o(8EM3G*P}a zmU>|UQq=SUwtnJoNTX5`^~X#B93*@79Etk&e$zFh!Tfw{9CrkxoJquz5#-^ za4t9=ww@=pS=hcqXz87QQ5zvYR{YZ!;cse1KMu9BrG8vYP_;}v-kOTQZv1<_N6pG+ z=LhNFhswx>I}1u;VZTHb%-ftPhCpl7LsbHSZakNN@GC?WoTwwHkro3CNe8O*1uh?p znJ`ieh`j@n74s*%DQLd9zT3rwiU{Oth*?2w$HIL#?1oKBXfb-C37QoD9h_=IH@qM( z^q@8v$o>;PR>n6m;IaY#GMYt9hL8Y@e;Li9_3RZ4wBd{MKMi%UoSDK)DXpDx`%4fI zN3HzBS;hbAxj&3p1FQymAy&(gSL;Rn6Etyr#%CTkqPmB8>+^Tu$53_yEiV`*h85Fv zSwC^mN*Yoew30|qpv=((90N(Fv+eWY*%Ne^C%t#Bor=+ZNyzs;VV*(vJlQ^H#t!y>Nzg>E0SxhqUV?9B zZ`#%7L#B`VFGJh)0aYt^?eRlZD4g2EJo&z!t&X@ z8*U<1%qs|+3RK9?DMoI;yv5v`cd}|-1MA!$KdbmF*Pwvn370|}MtjPfES|AzO~7kuhBw@xhpb~OoM z&FRApC4|v43rAD5V&bpcpfzGQ20I$N+G@=^iDU1FgbGDXI_%Dyn}Bt@)834Fw_*Q$ zwI)1?YwrD_W}exaWES$0a61{615~_!(|NG;|6%XEqngV1c5g#;P%Iz;X%+-*6zK%Q zSP%M~Z+DLMQ@4Kp+uN0)!$25?VqD0g@27J8|aB zocEox*17Av_ujMCJ%71e=w|O^x8L`9p3fsYD88ukj@4Y#zaR6toPK4*b_kLvz?v~= znw*t0GAKTbx?N-F<4Zk;v|%59{=K|)IzYr`_VB6>$DFEC0_WDcF)f4|U)ssaz$*!3 zLDKnY9!sZX`am@*b7Z#%70tanLC7@71Y*VxY%8i9U@AYkd-_S@sG(-vwq=igRAFqR z4DT)HvhkQ&aM9$ zFIU(^{fr~`;?GrU5B6E;{1(A_m(|!!X}rnfr{E97HF$8yhs zExV{?up`OnMWy`mlOZzl43d=_Wubt&X7zF_{1w&iT^0&VsZ=yAKEj=*7Hw=@k>do| zh{VD2agGwUTd|=t_M+4F4?C#zt1LiCZfcfGP`IqS$58!7gn(R^*|WawX=?=vFT-$m zYvjW~Z$aG$6i1*vjJ{1*?Y-lKE-eNA(yIEFmT)jJ4bg>A$uh&=@eJ>SDjFz^`#tt= z*_@ULO@@~>Dhtk3)VRrpI$!c4^5X{QG*L%_+NmA7aJIis)|s9Mccji1)tz5&fHciu z_LnCXS-c7x>B4y~U6f5Mse2u-_X4RHN8f2id7z?B(bWDO8ly4R4IiTAXou_LJE-QtdA)YvI26pVgc<7F5gptAeoh*# z2A5Vz7$GmGub+aon-48&oG#Z8`idTEvop9fjqHQDFNSZQ&m2t(eMIVP@|*p@KX`Jq ztVL|zixb}DEp7C}7WaTBHzn+Z>u`41f-`40F<$uDTA$TRvTE5`%%rrf?q=d?P|` z(O(0ez)U@P7Swcv6}Of({}bcrbpV`03mKVi*q*|=E01hX7CB{kZ}K9io^rcwU zBdYmCx%=Aytyr8}R{K4FZPrp0hX`IToX;6M9#aU(zd~Jt&%k^)^4{lDQd^uCL(R|@ zFkAkCK}{!{Svl@m5uR2}Fmj=V+f4zk=cm=V=Tj zkFEzUl;9H{r-CG@oxK66>!k>NdnTcWy&Jzirz|+>cJaW`OC8Y5)W9`=7F5_CWCxW; zzZrgLjYGXXouu0888RisbHBIkYqADyaq%_RR1((SJFA1)z`MizCXs;buNY5hCH{Pe z_ez8Bn%&S1e*oM%4)-&VHXC@4eoGmt1VcCBh$HL@gE-&}uEFq9el|E@WzlRoN zs`RJq?O+pBv?)|zgV4X0)cva!%0D|d{R_j#f7FS;R44w4tkVC>p*SF(toPOI(yZfr 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≫=+u^8{!mQn{omb8ed*dk)6IS%Uzo4xqnb` zx7}X=&CNemY^yzuUpNPR&x+j7kNE`pde4yTeFuIK*5{p)(l*-rHrTYM#3`3;MbSUT zL1R0usV3EN#wV&B8qE^<=o*3&PuTFWWoMOW;KOUEH+eVrn@XuE)qIu859zdYVe3ML z!-y&SC-mtTE*wxC9BSt=s9)_*5JGAQg`WFF3X)J?X$>05Pf~C_;vAuDQYxQwOJe*M ztf0U}V@+pKL1Wm8(05ps6pj+U2(6YpY~SQO%elhfd;6m0Fk26Q^y9a*K`lHcFT%#P zk^QwH#YnY_#4^}hUVM*_{eI;AY-x7>!S|-eaDKrr&a?G0`}6iFn@gS_4NWm}`aT># zK|N;D8&LX%$^C?dagpGoPmw6Hzw~%T*_5G33mR^b z|9os!pJy>wI!3vpynU2LLVJ4|Z}?^e#%jHAIMqE(Q;K7njboU@T={*L(LF+rMyYi2 z2iDx~x4p4LHg`C3+K$YQ1TzcHMi)41eTK(q_NLUL{hhxt?)WiPFkGp7;&UNU1Xj^i zs<^w-MpuEjDvy_{e3(w}Bq?#ibRpWgb0)q*>M}Qbh$BJap>v}7#p#Q8CGSXitHII} zYxS;|8cr!=>ca&bWCe_D38I4ghp8IQ+N@Z3ewaKaC4NqT*hgOGCl8<_lesO=tjj)F z54LrIVt)~07@v~Ff_mah>s$9Xb)4;nR)s1)^UR-$3yl|VSQcBRIyPLQvcc0B(w26s zbR9eK+4EY{OuE&}I=n?dtmyR8vz#xPMbgu@s^qxLxEP`+G%NOa3lT{drueqN0A2!1iaFCi$n$4f?KZK+Wq>m>!%ykW2BsPo9Qt9n?^ z3D(8SkIK38-c-2A3KBgP*eZXo3wVXg@nm@QS@lTyAkj(IrDk&Yh^PMOjf{ zX>F|a5Vda498GLofLYlT?;cbF?F-kycL20|<1j7Po|*K=7kmdgo?4bA7DZScb)%Uf zcz*YhRMwr*h4)M^&Yq`hTbkFnqv7W3;Y1FNRq&wi$#`rctMjV8pDyuDT=^i?nLoOc=w7R77QTnqArUV*$rr^EXB6Moi{C6xQ zfHpx#oOgEViZ@-k0_vhjeVS?r?U^eeKD#DRs%R1W&aA9k>O04kS0o@v%yY!n-ibGg z_LJYs4oh7ZhH`!1JebR`=4jeD)D0&Nu}IzDZg_1}ItD>D-k^=V#Bxm?<>p3Udq)C) z)Nq$3(xiA+g5%;73K?oEEEdE{<`d+po0TPc+;Y2am|Ngg{*k@~YgyJU9lXUco%tAh zcj0?`ik{s~srmJjuE`nFDfn$;%m*x)${HYc&c$V224UJy+F1WP@lVj6x$`q|WiJsD zx$lptD@Y__y%uO4%io!o|8qSLPEvZy>HnUv1i(g6HTEM5x&Dc@xXl49IRTc4Dlymt zGFPX$QJ}06sf78jJSAv!@MoSXa+c!%gD#)+&WHuE!JqaYNyi6>U;KP|nOG5M;ws^`5b4aE?QO literal 0 HcmV?d00001 diff --git a/docs/website-src/toc.yml b/docs/website-src/toc.yml index 41296bebe..d6af048d4 100644 --- a/docs/website-src/toc.yml +++ b/docs/website-src/toc.yml @@ -5,5 +5,7 @@ href: api/ - name: Benchmarks href: docs/benchmarks-dashboard.md +- name: NumPy API Coverage & Support + href: docs/coverage-support-dashboard.md - name: Source Code href: https://github.com/SciSharp/NumSharp diff --git a/tools/NumSharp.ApiInventory/NumSharp.ApiInventory.csproj b/tools/NumSharp.ApiInventory/NumSharp.ApiInventory.csproj new file mode 100644 index 000000000..3286dc7b3 --- /dev/null +++ b/tools/NumSharp.ApiInventory/NumSharp.ApiInventory.csproj @@ -0,0 +1,14 @@ + + + + Exe + net8.0 + enable + enable + + + + + + + diff --git a/tools/NumSharp.ApiInventory/Program.cs b/tools/NumSharp.ApiInventory/Program.cs new file mode 100644 index 000000000..9ff32f3b3 --- /dev/null +++ b/tools/NumSharp.ApiInventory/Program.cs @@ -0,0 +1,168 @@ +using System.Globalization; +using System.Reflection; +using System.Text.Json; +using System.Text.Json.Serialization; +using NumSharp; + +var inventory = new ApiInventory( + SchemaVersion: 1, + AssemblyVersion: typeof(np).Assembly.GetName().Version?.ToString() ?? "unknown", + Np: InspectType(typeof(np), BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly), + NdArray: InspectType(typeof(NDArray), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + Random: InspectType(typeof(NumPyRandom), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + +Console.WriteLine(JsonSerializer.Serialize(inventory, new JsonSerializerOptions +{ + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + WriteIndented = true, + DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull +})); + +static TypeInventory InspectType(Type type, BindingFlags flags) +{ + var methods = type.GetMethods(flags) + .Where(method => !method.IsSpecialName) + .GroupBy(method => method.Name, StringComparer.Ordinal) + .Select(group => new ApiMember( + group.Key, + "method", + group.Select(FormatMethod).OrderBy(value => value, StringComparer.Ordinal).ToArray(), + group.All(IsObsolete))) + .OrderBy(member => member.Name, StringComparer.Ordinal) + .ToArray(); + + var properties = type.GetProperties(flags) + .GroupBy(property => property.Name, StringComparer.Ordinal) + .Select(group => new ApiMember( + group.Key, + "property", + group.Select(FormatProperty).OrderBy(value => value, StringComparer.Ordinal).ToArray(), + group.All(IsObsolete))) + .OrderBy(member => member.Name, StringComparer.Ordinal) + .ToArray(); + + var fields = type.GetFields(flags) + .GroupBy(field => field.Name, StringComparer.Ordinal) + .Select(group => new ApiMember( + group.Key, + "field", + group.Select(FormatField).OrderBy(value => value, StringComparer.Ordinal).ToArray(), + group.All(IsObsolete))) + .OrderBy(member => member.Name, StringComparer.Ordinal) + .ToArray(); + + return new TypeInventory(type.FullName ?? type.Name, methods, properties, fields); +} + +static bool IsObsolete(MemberInfo member) => member.GetCustomAttribute() is not null; + +static string FormatMethod(MethodInfo method) +{ + var parameters = string.Join(", ", method.GetParameters().Select(FormatParameter)); + return $"{FriendlyType(method.ReturnType)} {method.Name}({parameters})"; +} + +static string FormatProperty(PropertyInfo property) +{ + var access = property.CanRead && property.CanWrite ? "get; set;" : property.CanRead ? "get;" : "set;"; + var indexes = property.GetIndexParameters(); + return indexes.Length == 0 + ? $"{FriendlyType(property.PropertyType)} {property.Name} {{ {access} }}" + : $"{FriendlyType(property.PropertyType)} {property.Name}[{string.Join(", ", indexes.Select(FormatParameter))}] {{ {access} }}"; +} + +static string FormatField(FieldInfo field) +{ + var modifier = field.IsLiteral ? "const " : field.IsInitOnly ? "readonly " : string.Empty; + return $"{modifier}{FriendlyType(field.FieldType)} {field.Name}"; +} + +static string FormatParameter(ParameterInfo parameter) +{ + var prefix = parameter.GetCustomAttribute() is not null + ? "params " + : parameter.IsOut + ? "out " + : parameter.ParameterType.IsByRef + ? "ref " + : string.Empty; + var type = FriendlyType(parameter.ParameterType.IsByRef + ? parameter.ParameterType.GetElementType()! + : parameter.ParameterType); + var optional = parameter.HasDefaultValue ? $" = {FormatDefault(parameter.DefaultValue)}" : string.Empty; + return $"{prefix}{type} {parameter.Name}{optional}"; +} + +static string FormatDefault(object? value) +{ + if (value is null || value == DBNull.Value || value == Missing.Value) + return "null"; + if (value is string text) + return JsonSerializer.Serialize(text); + if (value is char character) + return $"'{character}'"; + if (value is bool boolean) + return boolean ? "true" : "false"; + if (value.GetType().IsEnum) + return $"{FriendlyType(value.GetType())}.{value}"; + return Convert.ToString(value, CultureInfo.InvariantCulture) ?? "null"; +} + +static string FriendlyType(Type type) +{ + if (type.IsArray) + return $"{FriendlyType(type.GetElementType()!)}[]"; + if (type.IsGenericParameter) + return type.Name; + + var nullable = Nullable.GetUnderlyingType(type); + if (nullable is not null) + return $"{FriendlyType(nullable)}?"; + + var aliases = new Dictionary + { + [typeof(void)] = "void", + [typeof(bool)] = "bool", + [typeof(byte)] = "byte", + [typeof(sbyte)] = "sbyte", + [typeof(short)] = "short", + [typeof(ushort)] = "ushort", + [typeof(int)] = "int", + [typeof(uint)] = "uint", + [typeof(long)] = "long", + [typeof(ulong)] = "ulong", + [typeof(float)] = "float", + [typeof(double)] = "double", + [typeof(decimal)] = "decimal", + [typeof(char)] = "char", + [typeof(string)] = "string", + [typeof(object)] = "object" + }; + if (aliases.TryGetValue(type, out var alias)) + return alias; + + if (!type.IsGenericType) + return type.FullName ?? type.Name; + + var name = (type.GetGenericTypeDefinition().FullName ?? type.Name).Split('`')[0]; + return $"{name}<{string.Join(", ", type.GetGenericArguments().Select(FriendlyType))}>"; +} + +internal sealed record ApiInventory( + int SchemaVersion, + string AssemblyVersion, + TypeInventory Np, + TypeInventory NdArray, + TypeInventory Random); + +internal sealed record TypeInventory( + string Type, + ApiMember[] Methods, + ApiMember[] Properties, + ApiMember[] Fields); + +internal sealed record ApiMember( + string Name, + string Kind, + string[] Signatures, + bool Obsolete); From a062ca60a6e266b938b25bfcf3accff7a92ea7dc Mon Sep 17 00:00:00 2001 From: Eli Belash Date: Mon, 20 Jul 2026 21:35:16 +0300 Subject: [PATCH 2/3] Fix coverage inventory generation on clean CI runners --- coverage/generate_coverage.py | 19 +++++++++++++++++-- coverage/generated/coverage.json | 2 +- coverage/generated/manifest.json | 2 +- 3 files changed, 19 insertions(+), 4 deletions(-) diff --git a/coverage/generate_coverage.py b/coverage/generate_coverage.py index be5bba822..6d1eef2b9 100644 --- a/coverage/generate_coverage.py +++ b/coverage/generate_coverage.py @@ -19,7 +19,7 @@ ROOT = Path(__file__).resolve().parents[1] PINNED_NUMPY_VERSION = "2.4.2" -GENERATOR_VERSION = "1.1.0" +GENERATOR_VERSION = "1.1.1" OUTPUT_FILES = ("coverage.json", "coverage.csv", "summary.md", "manifest.json") NUMSHARP_SOURCE_BASE_URL = "https://github.com/SciSharp/NumSharp/blob/master/" @@ -125,7 +125,22 @@ def load_numpy() -> Any: def load_numsharp_inventory() -> dict[str, Any]: project = ROOT / "tools" / "NumSharp.ApiInventory" / "NumSharp.ApiInventory.csproj" - command = ["dotnet", "run", "--project", str(project), "--configuration", "Release"] + build_command = [ + "dotnet", "build", str(project), "--configuration", "Release", "--framework", "net8.0", + "--nologo", "--verbosity", "quiet", + ] + build = subprocess.run(build_command, cwd=ROOT, check=False, text=True, capture_output=True) + if build.returncode: + sys.stderr.write(build.stdout) + sys.stderr.write(build.stderr) + raise SystemExit("Failed to build the NumSharp API inventory tool.") + + # Build output contains compiler warnings on stdout on clean Linux runners. Run + # the already-built tool separately so stdout is guaranteed to be JSON only. + command = [ + "dotnet", "run", "--project", str(project), "--configuration", "Release", + "--framework", "net8.0", "--no-build", "--no-restore", + ] completed = subprocess.run(command, cwd=ROOT, check=False, text=True, capture_output=True) if completed.returncode: sys.stderr.write(completed.stdout) diff --git a/coverage/generated/coverage.json b/coverage/generated/coverage.json index c93a3e661..f0bf70f72 100644 --- a/coverage/generated/coverage.json +++ b/coverage/generated/coverage.json @@ -1,6 +1,6 @@ { "schema_version": 1, - "generator_version": "1.1.0", + "generator_version": "1.1.1", "numpy_version": "2.4.2", "numsharp_assembly_version": "0.60.0.0", "methodology": { diff --git a/coverage/generated/manifest.json b/coverage/generated/manifest.json index 31cc6d535..f5078dd99 100644 --- a/coverage/generated/manifest.json +++ b/coverage/generated/manifest.json @@ -1,7 +1,7 @@ { "schema_version": 1, "generator": "coverage/generate_coverage.py", - "generator_version": "1.1.0", + "generator_version": "1.1.1", "numpy_version": "2.4.2", "numsharp_assembly_version": "0.60.0.0", "artifact_files": [ From b2798f1089bf6faa641e2cb1b5db59f8ec766f97 Mon Sep 17 00:00:00 2001 From: Eli Belash Date: Mon, 20 Jul 2026 21:44:00 +0300 Subject: [PATCH 3/3] Make coverage artifact portable across platforms --- coverage/README.md | 2 ++ coverage/generate_coverage.py | 8 ++++++-- coverage/generated/coverage.json | 2 +- coverage/generated/manifest.json | 2 +- 4 files changed, 10 insertions(+), 4 deletions(-) diff --git a/coverage/README.md b/coverage/README.md index aad57c88c..cba5be67c 100644 --- a/coverage/README.md +++ b/coverage/README.md @@ -24,6 +24,8 @@ CI generates a fresh copy under `artifacts/numpy-numsharp-coverage/`, validates The default denominator includes NumPy top-level callables, `ndarray` methods and properties, and callables from `numpy.random`, `numpy.linalg`, and `numpy.fft`. NumPy types, constants, and modules are catalogued but do not affect the headline percentage. NumSharp-only APIs are catalogued separately and also do not affect it. +Platform-conditional extended-precision aliases (`float96`, `float128`, `complex192`, and `complex256`) are excluded so the artifact is byte-identical across Windows and Linux. NumPy's portable `longdouble` and `clongdouble` names remain catalogued. + - **Exact** — the corresponding NumSharp surface has the same public member name. - **Alias** — a reviewed or mechanically safe C# equivalent exists under another name or surface. - **Partial** — an API exists, but the reviewed mapping has a known semantic limitation. diff --git a/coverage/generate_coverage.py b/coverage/generate_coverage.py index 6d1eef2b9..de6819999 100644 --- a/coverage/generate_coverage.py +++ b/coverage/generate_coverage.py @@ -19,12 +19,13 @@ ROOT = Path(__file__).resolve().parents[1] PINNED_NUMPY_VERSION = "2.4.2" -GENERATOR_VERSION = "1.1.1" +GENERATOR_VERSION = "1.1.2" OUTPUT_FILES = ("coverage.json", "coverage.csv", "summary.md", "manifest.json") NUMSHARP_SOURCE_BASE_URL = "https://github.com/SciSharp/NumSharp/blob/master/" CALLABLE_KINDS = {"function", "ufunc", "callable", "method"} VALID_SUPPORT = {"declared", "partial", "unsupported", "missing", "extension"} +PLATFORM_SPECIFIC_NUMPY_EXPORTS = {"float96", "float128", "complex192", "complex256"} CREATION = { "arange", "array", "asanyarray", "asarray", "asarray_chkfinite", "ascontiguousarray", @@ -342,7 +343,10 @@ def member_maps(inventory: dict[str, Any]) -> tuple[dict[str, dict[str, Any]], d def public_exports(np: Any) -> list[dict[str, Any]]: exports: list[dict[str, Any]] = [] - for name in sorted(set(np.__all__)): + # NumPy conditionally exports extended-precision aliases according to the C + # platform. Compare the portable public surface so Windows and Linux produce + # the same checked-in artifact; longdouble/clongdouble remain represented. + for name in sorted(set(np.__all__) - PLATFORM_SPECIFIC_NUMPY_EXPORTS): if not hasattr(np, name): continue obj = getattr(np, name) diff --git a/coverage/generated/coverage.json b/coverage/generated/coverage.json index f0bf70f72..328e561e7 100644 --- a/coverage/generated/coverage.json +++ b/coverage/generated/coverage.json @@ -1,6 +1,6 @@ { "schema_version": 1, - "generator_version": "1.1.1", + "generator_version": "1.1.2", "numpy_version": "2.4.2", "numsharp_assembly_version": "0.60.0.0", "methodology": { diff --git a/coverage/generated/manifest.json b/coverage/generated/manifest.json index f5078dd99..2d0e36186 100644 --- a/coverage/generated/manifest.json +++ b/coverage/generated/manifest.json @@ -1,7 +1,7 @@ { "schema_version": 1, "generator": "coverage/generate_coverage.py", - "generator_version": "1.1.1", + "generator_version": "1.1.2", "numpy_version": "2.4.2", "numsharp_assembly_version": "0.60.0.0", "artifact_files": [