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..cba5be67c --- /dev/null +++ b/coverage/README.md @@ -0,0 +1,36 @@ +# 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. + +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. +- **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..de6819999 --- /dev/null +++ b/coverage/generate_coverage.py @@ -0,0 +1,702 @@ +#!/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.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", + "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" + 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) + 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]] = [] + + # 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) + 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..328e561e7 --- /dev/null +++ b/coverage/generated/coverage.json @@ -0,0 +1,19979 @@ +{ + "schema_version": 1, + "generator_version": "1.1.2", + "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..2d0e36186 --- /dev/null +++ b/coverage/generated/manifest.json @@ -0,0 +1,349 @@ +{ + "schema_version": 1, + "generator": "coverage/generate_coverage.py", + "generator_version": "1.1.2", + "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 000000000..1cd550a31 Binary files /dev/null and b/docs/website-src/images/coverage-support-capability-map.png differ diff --git a/docs/website-src/images/coverage-support-surface-scoreboard.png b/docs/website-src/images/coverage-support-surface-scoreboard.png new file mode 100644 index 000000000..3fc3359eb Binary files /dev/null and b/docs/website-src/images/coverage-support-surface-scoreboard.png differ 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);