Cargo.toml

[package]

name = "ndarray"
version = "0.17.2"
edition = "2021"
# Matches `rust-toolchain.toml` (1.97.1) and CI's `MSRV` / `BLAS_MSRV` env, which
# are ALREADY 1.97.1. This said 1.95 until 2026-08-05 — a declared MSRV that
# nothing tested, because no CI job builds at 1.95. Consumers read this field:
# tesseract-rs path-deps both ndarray and lance-graph-contract, and a 1.95 build
# of the contract crate happens to still succeed today — a coincidence, not a
# guarantee, and exactly what an untested MSRV declaration buys. Declare what is
# actually verified.
rust-version = "1.99.0"
authors = [
  "Ulrik Sverdrup \"bluss\"",
  "Jim Turner"
]
license = "MIT OR Apache-2.0"
readme = "README-crates.io.md"

repository = "https://github.com/rust-ndarray/ndarray"
documentation = "https://docs.rs/ndarray/"

description = "An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting."

keywords = ["array", "data-structure", "multidimensional", "matrix", "blas"]
categories = ["data-structures", "science"]

include = [
    "/src/**/*.rs",
    "LICENSE-MIT",
    "LICENSE-APACHE",
    "RELEASES.md",
    "README.rst",
    "README-quick-start.md"
]
resolver = "2"

[lib]
name = "ndarray"
bench = false
test = true

[[example]]
name = "ocr_benchmark"
required-features = ["std"]

[[example]]
name = "bf16_rne_exhaustive"
required-features = ["std"]

[[example]]
name = "cpu_guard_probe"
required-features = ["std"]

[[example]]
name = "splat3d_flex"
required-features = ["splat3d"]

# AMX examples import `ndarray::simd` / `ndarray::hpc`, both `#[cfg(feature =
# "std")]`, so they must be skipped in `--no-default-features` CI jobs.
[[example]]
name = "hex_trie_vs_gemm_probe"
required-features = ["std"]

[[example]]
name = "ternlog_amortization_probe"
required-features = ["std"]

[[example]]
name = "ternlog_fold_probe"
required-features = ["std"]

[[example]]
name = "key16_match_probe"
required-features = ["std"]

[[example]]
name = "perm_field_probe"
required-features = ["std"]

[[example]]
name = "ternlog_popcnt_gap_probe"
required-features = ["std"]

[[example]]
name = "r2il_column_scan_probe"
required-features = ["std"]

[[example]]
name = "ternlogq_tail_descent_probe"
required-features = ["std"]

[[example]]
name = "mask_algebra_tail_probe"
required-features = ["std"]

[[example]]
name = "narrow_bitop_codegen_probe"
required-features = ["std"]

[[example]]
name = "ternlogq_sparse_reapply_probe"
required-features = ["std"]

[[example]]
name = "hex_tenant_mq_probe"
required-features = ["std"]

[[example]]
name = "ternlog_codegen_probe"
required-features = ["std"]

[[example]]
name = "amx_realization_report"
required-features = ["std"]

[[example]]
name = "amx_gemm_bench"
required-features = ["std"]

[[example]]
name = "amx_probe"
required-features = ["std"]

[[example]]
name = "bounded_power_sums_bench"
required-features = ["std"]

[[example]]
name = "amx_rb_probe"
required-features = ["std"]

# Morton cascade probe imports `ndarray::simd` (std-gated).
[[example]]
name = "morton_cascade_probe"
required-features = ["std"]

# 1BRC-on-substrate probe: Morton group-by + AMX BF16 tile-GEMM mean path
# (imports `ndarray::simd` + `ndarray::hpc`, both std-gated).
[[example]]
name = "onebrc_cascade_probe"
required-features = ["std"]

[[example]]
name = "golden_helix_probe"
required-features = ["std"]

[[example]]
name = "edge_residue_probe"
required-features = ["std"]

[[example]]
name = "edge_codec_compare"
required-features = ["std"]

[[example]]
name = "codec_mode_histogram"
required-features = ["codec"]

# W1a-#9 masking-primitive codegen probe imports `ndarray::simd` (std-gated).
[[example]]
name = "psd_bit_exactness"
required-features = ["pillar", "std"]

[[example]]
name = "psd_jitter_sweep"
required-features = ["pillar", "std"]

[[example]]
name = "psd_f32_vs_f64_probe"
required-features = ["pillar", "std"]

[[example]]
name = "w1a9_codegen_probe"
required-features = ["std"]

[[example]]
name = "mc_via_shader"
required-features = ["codec"]

[[example]]
name = "residue_upscale"
required-features = ["codec"]

[[example]]
name = "motion_transform_noop"
required-features = ["codec"]

[[example]]
name = "gridlake_field_tile"
required-features = ["std"]

[[example]]
name = "subpel_tap_tile"
required-features = ["std"]

[[example]]
name = "entropy_ladder_probe"
required-features = ["std"]

[[example]]
name = "instrument_mtmm_probe"
required-features = ["std"]

[[example]]
name = "signature_pde_bench"
required-features = ["std"]

[[example]]
name = "randomized_signature_bench"
required-features = ["std"]

[[example]]
name = "cakes_grail_probe"
required-features = ["std"]

[[example]]
name = "helix_orthogonality_probe"
required-features = ["std"]

[[example]]
name = "helix_bitdepth_probe"
required-features = ["std"]

[[example]]
name = "morton_perturbation_probe"
required-features = ["std"]

[[example]]
name = "rolling_floor_probe"
required-features = ["std"]

[[example]]
name = "hdr_rolling_floor_bench"
required-features = ["std"]

[[example]]
name = "codec_overlap_probe"
required-features = ["std"]

[[example]]
name = "campq_cascade_probe"
required-features = ["std"]

[dependencies]
num-integer = { workspace = true }
num-traits = { workspace = true }
num-complex = { workspace = true }

approx = { workspace = true, optional = true }
rayon = { version = "1.10.0", optional = true }

# Use via the `blas` crate feature
cblas-sys = { workspace = true, optional = true }
libc = { version = "0.2.82", optional = true }

matrixmultiply = { version = "0.3.2", default-features = false, features=["cgemm"] }

# =====================================================================
# blake3 — NO LONGER A DEPENDENCY. Do not re-add it.
# =====================================================================
#
# BLAKE3 now lives in-tree at `src/hpc/blake3.rs`, as a **portable-only
# transcription of the BLAKE3 reference implementation -- no SIMD, no
# unsafe**. See that module's own header. It is the serial path every
# conformant implementation reduces to at `simd_degree() == 1`, which
# suffices here because ndarray's usage is entirely single-input.
#
# The external crate was removed because even with `default-features =
# false, features = ["pure"]` it carried its own SSE2/SSE4.1/AVX2
# intrinsics -- a second SIMD surface beside `ndarray::simd`, which is
# exactly what the matryoshka pattern exists to prevent. The old comment
# block here said "Tracked, not done here"; this is it being done.
#
# It also breaks a cycle. `ndarray -> blake3` meant blake3 could never be
# built ON `ndarray::simd` without cargo seeing `ndarray -> blake3 ->
# ndarray`. Dropping the dep is what makes an ndarray-backed BLAKE3
# possible -- NOT here (this module is portable), but for a future
# SIMD-backed implementation and for the AdaWorldAPI/BLAKE3 fork.
#
# Separately: blake3 carried `cc` as an unconditional build-dependency, and
# the `pure` feature existed only to stop that `cc` from compiling the
# bundled C/ASM (operator directive 2026-07-28, "I don't want any ffi with
# c"). In-tree there is no C to opt out of, and `cc` is no longer pulled on
# blake3's account. Dropping blake3 also removed `constant_time_eq`,
# `arrayref` and `arrayvec` from the lockfile.
#
# Cost, measured: 1.25-1.39x across the input sizes this crate actually
# hashes (16 B word 1.34-1.39x, 256 B 1.25-1.29x, 2 KB 1.30x), rising to
# 4.7-4.9x at 64 KB where upstream's `hash_many` has no in-tree counterpart.
# Every call site here sits in the small-input band, not the 64 KB one. Full
# table, methodology and the attribution of the gap:
# `.claude/knowledge/blake3-in-tree-measured.md`.
#
# The A/B bench under `.claude/knowledge/blake3-ab-bench/` compared the two
# implementations and is, by its own design note, unbuildable from this commit
# onward — there is no longer a second implementation to compare against.
#
# Call sites live under `pub mod hpc;` (gated on `feature = "std"` in lib.rs),
# so the nostd matrix is untouched: `blake3` and its `constant_time_eq`
# dependency are both gone from Cargo.lock entirely.

# p64 + fractal — specialized convergence / manifold math. Gated behind
# `hpc-extras` since they pull in a dep tree burn-ndarray doesn't need.
p64 = { path = "crates/p64", optional = true }
fractal = { path = "crates/fractal", default-features = false, optional = true }

serde = { version = "1.0", optional = true, default-features = false, features = ["alloc"] }
rawpointer = { version = "0.2" }

# paste — identifier concatenation in macro_rules! expansions.
# Required by `blocked_grid_struct!` to generate {Name}L1Block / {Name}L1BlockMut
# view types. Already present in the workspace lockfile (via crates/burn).
paste = "1"


# Cranelift JIT (optional, behind "jit-native" feature)
# For AVX-512 VPOPCNTDQ/VNNI/VPTERNLOG/BITALG support, use the patched fork:
#   cranelift-codegen = { git = "https://github.com/AdaWorldAPI/wasmtime.git", branch = "main", optional = true }
cranelift-codegen = { version = "0.116", optional = true }
cranelift-jit = { version = "0.116", optional = true }
cranelift-module = { version = "0.116", optional = true }
cranelift-frontend = { version = "0.116", optional = true }
target-lexicon = { version = "0.13", optional = true }

[dev-dependencies]
defmac = "0.2"
quickcheck = { workspace = true }
approx = { workspace = true, default-features = true }
itertools = { workspace = true }
ndarray-gen = { workspace = true }
criterion = { version = "0.5", features = ["html_reports"] }

[[bench]]
name = "append"
harness = false

[[bench]]
name = "bench1"
harness = false

[[bench]]
name = "chunks"
harness = false

[[bench]]
name = "construct"
harness = false

[[bench]]
name = "gemv_gemm"
harness = false

[[bench]]
name = "higher-order"
harness = false

[[bench]]
name = "iter"
harness = false

[[bench]]
name = "numeric"
harness = false

[[bench]]
name = "par_rayon"
harness = false
required-features = ["rayon"]

[[bench]]
name = "reserve"
harness = false

[[bench]]
name = "to_shape"
harness = false

[[bench]]
name = "zip"
harness = false

[[bench]]
name = "splat3d_bench"
harness = false
required-features = ["splat3d"]

[features]
default = ["std", "hpc-extras"]

# Enable blas usage
# See README for more instructions
blas = ["dep:cblas-sys", "dep:libc"]

serde = ["dep:serde"]

std = ["num-traits/std", "matrixmultiply/std"]
rayon = ["dep:rayon", "std"]

# Portable-SIMD backend (NIGHTLY ONLY). Routes `crate::simd::*` types
# through `core::simd::*` instead of the architecture-specific intrinsics
# in `simd_avx512.rs` / `simd_avx2.rs` / `simd_neon.rs`. The point is
# miri compatibility: miri can execute `core::simd` semantics but treats
# `_mm*_*` intrinsics as opaque. With this feature on, miri-run tests
# exercise the actual SIMD code paths in consumer code (`hpc/byte_scan`,
# `hpc/framebuffer`, etc.) and catch UB that the intrinsics backend hides.
#
# Requires `cargo +nightly` because `src/simd_nightly.rs` is gated on
# `#![feature(portable_simd)]` (Rust unstable issue #86656). The default
# build (stable 1.95) does NOT touch this; the existing intrinsics
# cfg-dispatch in `simd.rs` remains the production path.
nightly-simd = ["std"]

# Runtime SIMD dispatch — release-binary distribution path. Compiles all
# x86_64 backends into one artifact and selects per-op kernels via
# `LazyLock<fn>` trampolines that read `simd_caps()` on first call. The
# `crate::simd_runtime::*` module becomes reachable under this feature;
# the existing compile-time `crate::simd::*` / `crate::simd_ops::*`
# cascade is unchanged (additive). Use case: shipping one binary that
# adapts across heterogeneous deployment silicon (AVX-512 server +
# AVX2-only laptop) from the same artifact.
#
# Mutually exclusive with `nightly-simd` (the portable-SIMD polyfill
# replaces the architecture-specific intrinsics that the runtime
# trampolines select between; they can't coexist coherently).
#
# Per-call overhead: ~2-3 ns indirect-call through a static fn pointer
# (LazyLock fires once at first call, every subsequent call is a
# pointer deref). Invisible against any SIMD op's actual work.
#
# See `.claude/knowledge/simd-dispatch-architecture.md` § 7.1 / Phase 5
# for the design rationale.
runtime-dispatch = ["std"]

# HPC extras: p64 palette/NARS bridge + fractal manifold.
# These pull in a non-trivial dependency tree; downstream crates such as
# burn-ndarray that only need the core array layer can disable this with
# `default-features = false` (and re-enable `std` explicitly if needed).
hpc-extras = ["std", "dep:p64", "dep:fractal", "fractal/std"]

matrixmultiply-threading = ["matrixmultiply/threading"]

# JITSON: JSON parser + validator + template + scan pipeline (no Cranelift)
jitson = []

# JIT native compilation via Cranelift (jitson_cranelift module)
jit-native = ["jitson", "dep:cranelift-codegen", "dep:cranelift-jit", "dep:cranelift-module", "dep:cranelift-frontend", "dep:target-lexicon"]


# HPC backend feature gates (mutually exclusive)
native = ["std"]
intel-mkl = ["std"]
openblas = ["std"]

# linalg: middle-layer MatN carrier + Mat2/3/4 + Spd2/Spd3 SPD-cone (PR-X10 A1)
linalg = []

# pillar: Pillar-6 through Pillar-11 SPD-cascade certification probes (PR-X11).
# Depends on linalg for Spd2/Spd3 types consumed by B1-B7 pillar workers.
pillar = ["linalg", "splat3d"]

# ogit_bridge: zero-dep RDF 1.1 Turtle parser for the OGIT ontology TTL files.
# Provides TurtleLexer, TurtleParser, Triple, TripleNode, TurtleError.
# No external dependencies — pure-Rust, no unsafe.
ogit_bridge = []

# splat3d: CPU-SIMD 3D Gaussian Splatting forward renderer
# (`src/hpc/splat3d/*`). Pure SIMD, no GPU, no wgpu, reuses the
# existing `crate::simd` polyfill (F32x16 via AVX-512 / AVX2 / NEON
# / scalar dispatch). Gated because the module pulls in the Smith-1961
# 3×3 SPD eigendecomp + EWA-sandwich projection kernels; downstream
# consumers (medvol, lance-graph-render) opt in. f32 hot path; the
# Pillar-7 probe certifying the math sibling lives in
# `lance-graph/crates/jc/src/ewa_sandwich_3d.rs`.
splat3d = ["std"]

# PR-X12 cognitive codec — x265-shaped skip/merge/delta/escape mode classes
# over BlockedGrid CTUs. A1 (this crate) ships only the CTU carrier +
# quad-tree partition; the entropy coder + RDO loop land in later workers.
codec = ["std"]

# no_std polyfill for `static LazyLock` in `src/simd.rs` (sprint A12).
# Pulls in `portable-atomic` with the `critical-section` impl plus the
# `critical-section` runtime so we can build a once-cell-style cache for
# the SIMD tier without `std::sync::LazyLock`. The unconditional
# `portable-atomic` dependency below is itself optional, gated on this
# feature; the target-specific block keeps the un-optional copy alive on
# platforms that need it for atomic-pointer fallback.
portable-atomic-critical-section = [
    "dep:portable-atomic",
    "dep:critical-section",
    "portable-atomic/critical-section",
]


[dependencies.portable-atomic]
version = "1"
optional = true
default-features = false

[dependencies.critical-section]
version = "1"
optional = true

[target.'cfg(not(target_has_atomic = "ptr"))'.dependencies]
portable-atomic = { version = "1.6.0" }
portable-atomic-util = { version = "0.2.0", features = [ "alloc" ] }

[workspace]
members = [
    "ndarray-rand",
    "crates/*",
]
exclude = [
    "crates/burn",
    "crates/wasm-simd-parity",
    "crates/neon-simd-parity",
    "crates/simd-masking-parity",
    # Cross-repo: its dev-dep is a PATH into a lance-graph sibling checkout.
    # In-workspace, a missing sibling would fail resolution for EVERY member.
    "crates/sigker-parity",
    "vendor/chacha20",
]
default-members = [
    ".",
    "ndarray-rand",
    "crates/ndarray-gen",
    "crates/numeric-tests",
    "crates/serialization-tests",
    # exclude blas-tests and blas-mock-tests that activate "blas" feature
]

[workspace.dependencies]
ndarray = { version = "0.17", path = ".", default-features = false }
ndarray-rand = { path = "ndarray-rand" }
ndarray-gen = { path = "crates/ndarray-gen" }

num-integer = { version = "0.1.39", default-features = false }
num-traits = { version = "0.2", default-features = false }
num-complex = { version = "0.4", default-features = false }
approx = { version = "0.5", default-features = false }
quickcheck = { version = "1.0", default-features = false }
rand = { version = "0.9.0", features = ["small_rng"] }
rand_distr = { version = "0.5.0" }
itertools = { version = "0.13.0", default-features = false, features = ["use_std"] }
cblas-sys = { version = "0.1.4", default-features = false }

[profile.bench]
debug = true

# The codegen-witness profile (`scripts/codegen-witness.sh`): optimized so LLVM
# actually performs the vectorization the SIMD realization matrix certifies,
# with no debuginfo and no LTO so it stays a TINY build of one example, not a
# release build of the crate. The semantic arms of the matrix run at opt-level
# 0 instead — bits are proven cheaply there, machine code is proven here.
[profile.ci-codegen]
inherits = "release"
opt-level = 3
debug = 0
lto = false
incremental = false
panic = "abort"

[profile.test.package.numeric-tests]
opt-level = 2
[profile.test.package.blas-tests]
opt-level = 2

# Config for cargo-release
[package.metadata.release]
tag-name = "{{version}}"

# Config specific to docs.rs
[package.metadata.docs.rs]
features = ["approx", "serde", "rayon"]
# Define the configuration attribute `docsrs`
rustdoc-args = ["--cfg", "docsrs"]

# ── ChaCha20 matryoshka (AdaWorldAPI fork) ──────────────────────────────────
# Fold the AVX-512/ndarray::simd-accelerated `chacha20` fork over the registry
# crate. This transitively accelerates the `encryption` crate's XChaCha20-Poly1305
# keystream (chacha20poly1305 -> chacha20) with zero change to the AEAD, on any
# x86_64+avx512f build (the workspace's `target-cpu=x86-64-v4`). Non-x86 builds of
# the fork fall through to RustCrypto's own backends and never pull ndarray.
# NOTE: a "Patch `chacha20` was not used in the crate graph" note appears on
# scoped builds that don't pull `encryption` (e.g. `-p ndarray`); it is benign —
# the patch is exercised by `cargo test -p encryption` and the full workspace.
[patch.crates-io]
chacha20 = { path = "vendor/chacha20" }

# Debug info OFF for dev and test builds — the single biggest lever on build
# cost. Measured across this fleet 2026-08-22: 22 GB / ~40 min with debug info
# vs 4.4 GB / ~10 min without, on the same tree. `[profile.test]` inherits from
# `dev`, so this one entry covers `cargo build` and `cargo test` alike.
#
# It belongs in the manifest rather than in each session's environment: carried
# as `CARGO_PROFILE_*` env vars it only helps a session that remembers, and a
# fresh clone or a CI runner gets the expensive build. lance-graph (#962) and
# MedCare-rs already set this default.
#
# Given up: line numbers in panic backtraces. `debug = "line-tables-only"`
# restores them cheaply when a debugging session needs them — a deliberate
# temporary edit, not a reason to keep the default expensive.
[profile.dev]
debug = 0