ndplex 0.1.0__tar.gz

ndplex-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+build/
+dist/
+*.egg-info/

ndplex-0.1.0/ATTRIBUTION.md

@@ -0,0 +1,58 @@
+## Attribution & References
+
+### Provenance
+
+This repository contains work of three kinds. They are kept apart so that credit, and responsibility for errors, lands in the right place.
+
+**A. Original work: Ted Teske (2019–2024), sole author**
+
+- The n-Dimensional m-Plex ("ndplex") array: a generic Pascal's array of any dimension, as an `np.ndarray` subclass with user-defined edges, node-generating function (`func`) and argument locations (`arg_locs`, including the `None`-means-on-the-edge convention).
+- `diag`, the general line or cross-section through the array (loc, one or more moves, optional sums), and `as_tri`, the array as a triangle, tetrahedron or n-simplex.
+- `oeis` (row-by-row OEIS lookup), `diag_as_hist` (weighted histograms with a normal overlay) and `plot_ndplex` (the array or triangle with highlighted diagonals).
+- All of `ndplex_array.ipynb`: the examples and the observations in them, including the simplex/duplex/triplex triangles, the binomial-to-normal histograms, Fibonacci and Narayana's cows from steep diagonals, the slope table, the moving-cost and rental-rate model, and the explorations with primes.
+
+**B. Collaborative work: Ted Teske with Claude (Anthropic), 2026**
+
+- *Phase 1 audit* (`docs/phase1_audit.md`): running the notebook against current libraries; the findings on import side effects, the ndarray subclass, integer overflow (where it starts, why residues modulo powers of 2 survive it, and that part of the Fibonacci-mod-7 heatmap is overflow), arg_locs that wrap around the array, diag trimming genuine zeros, and oeis hiding network errors; the proposed 0.1.0 API.
+- *Phase 1 regression suite* (`tests/`): the notebook's printed results pinned as tests, the property checks (binomial, multinomial, Lucas's theorem, digital roots), the known-issue tests, the offline OEIS stub and primes sieve, and the mutation check (`tests/mutation_check.py`).
+- *Phase 2 package* (`src/ndplex`, `pyproject.toml`, `docs/phase2_package.md`): the package layout and lazy loading of `oeis`; the fixes for the Phase 1 findings (no import side effects, a single overflow warning naming the first overflowed node, exact `dtype=object` sums, derived arrays that keep working and pickle, zero padding for `arg_locs` outside the array, `diag` ending by geometry rather than at the first trailing zeros, argument checks, and `oeis` over https with failures reported and a `quiet` mode). The class's design, its node-generation loop, the edge-filling rotation, the `diag` move arithmetic and `as_tri` as a series of cross-sections (with its 2-D and 3-D moves) are Ted's, kept from the notebook (tier A). The `as_tri` moves for 4-D and up were changed in review so that layers are left-justified in every dimension (Ted's choice between the two layouts; the finding and the new move rule were made with Claude).
+- *Phase 2 tests*: the suite moved to the package, the known-issue tests rewritten to the fixed behaviour, the new package, overflow, pickling and `oeis` tests, the differential check against the notebook code, and the mutation check adapted to the package.
+- *Phase 3 tests and CI* (`.github/workflows/tests.yml`, `tests/test_platform.py`, `docs/phase3_ci.md`): the CI matrix (adapted from Ted's bounded-lognorm), the finding that overflow in narrow integer dtypes went unreported on NumPy < 2 and its fix (C12), and the platform tests.
+- *Phase 4 packaging and release* (`.github/workflows/publish.yml`, `README.md`, `CITATION.cff`, `tests/test_readme.py`, `docs/phase4_release.md`): the publish workflow (adapted from Ted's bounded-lognorm), the README rewritten as the package's documentation with its examples run as tests, the citation metadata, and the release procedure. The choice of Green (2015) as a general source, the Zenodo and CITATION decisions, and the release itself are Ted's.
+
+**C. Third-party work, cited below**
+
+Attribution suggestion, not a rule: the usual convention in published work is that an AI system is not listed as an author, since authorship carries accountability an AI cannot hold. The conventional form is to claim the work as your own and acknowledge AI assistance, e.g. *"The test suite and audit were developed with assistance from Claude (Anthropic)."*
+
+### References
+
+**General source.** Ted cites Thomas M. Green's *The Simplex, Duplex and Pascal's Triangles* (2015; reference 10 below) as a general source for ndplex. The book covers Pascal's triangle and its relatives, simplexes, duplexes and higher-dimensional extensions, and recurrent sequences such as Fibonacci.
+
+**Code adapted in the notebook's library cell (not in the package)**
+
+1. `trim_trailing_zeros` (inside `diag`) is adapted from an answer to "Trim trailing zeros of a numpy array along each axis", Stack Overflow question 55917328. https://stackoverflow.com/questions/55917328
+2. The query inside `oeis` is adapted from Andrew Walker's `oeis` package. https://github.com/AndrewWalker/oeis — its `setup.py` declares a BSD license; the repository has no LICENSE file (checked November 2026).
+
+*Both are kept here as history. The package does not contain either (decision D9): `diag` now ends where its moves leave the array (`_trim_outside` in `src/ndplex/_core.py`, written from scratch for the change in behaviour) and `oeis`'s request is written from scratch with the standard library. The notebook (`ndplex_array.ipynb`) still contains the originals.*
+
+**Code and data used only in the notebook's examples**
+
+3. `sum_digits`, from Andreas K.'s answer to Stack Overflow question 48817036. https://stackoverflow.com/questions/48817036
+4. `primesfrom2to`, from an answer to Stack Overflow question 2068372. https://stackoverflow.com/questions/2068372
+5. The first 1000 primes, downloaded from a GitHub gist by cblanc. https://gist.github.com/cblanc/46ebbba6f42f61e60666
+
+**Mathematics and sources cited in the notebook**
+
+6. The On-Line Encyclopedia of Integer Sequences (OEIS). https://oeis.org — the source of the sequence names `oeis()` prints; its text output format is described at https://oeis.org/eishelp1.html.
+7. Pascal's triangle and the bell curve. AMS Feature Column. http://www.ams.org/publicoutreach/feature-column/fcarc-normal
+8. Pascal's triangle modulo n (Sierpinski's gasket). http://orion.math.iastate.edu/reu/oldREU/modupasc.htm
+9. Hypercube; Simplex. Wikipedia. https://en.wikipedia.org/wiki/Hypercube, https://en.wikipedia.org/wiki/Simplex
+10. Green, Thomas M. *The Simplex, Duplex and Pascal's Triangles: Relatives of Pascal's Triangle, with Excursions Into Hyperspace*. CreateSpace Independent Publishing Platform, 2015. 176 pp. ISBN 9781514677094. https://books.google.com/books/about/The_Simplex_Duplex_and_Pascal_s_Triangle.html?id=P0cDswEACAAJ (also cited in the notebook, via https://www.amazon.com/Simplex-Duplex-Pascals-Triangles-Excursions/dp/1514677091). **A general source for the project** (see the note above), not only for the notebook section that cites it.
+11. Narayana's cows sequence, OEIS A000930 (https://oeis.org/A000930), and the paper linked from the notebook (JIM 96 proceedings). http://jim.afim-asso.org/jim96/actes/Allouche.ps
+
+**Used in the Phase 1 tests**
+
+12. Lucas's theorem (a binomial coefficient modulo a prime, from base-p digits); for p = 2 it gives: C(i + j, i) is odd exactly when i AND j = 0. https://en.wikipedia.org/wiki/Lucas%27s_theorem
+13. The multinomial theorem: the nodes of layer r of the d-dimensional default ndplex sum to d^r.
+
+*Links in the notebook have not yet been checked; a link audit is planned with the examples notebook (Phase 5).*

ndplex-0.1.0/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project are documented here. The project follows [Semantic Versioning](https://semver.org/); while the version is 0.x, minor releases may change the API.
+
+## 0.1.0 (2026-11-06)
+
+First release, and the first version as a package. Before this, ndplex was the first code cell of `ndplex_array.ipynb` (Ted Teske, 2019–2024). The notebook's results are kept except where a change is listed below; each change is documented, with migration notes, in `docs/phase2_package.md`, `docs/phase3_ci.md` and `docs/phase4_release.md`.
+
+- **Package layout.** `src/ndplex`: the `ndplex` class (`_core.py`) and `oeis` (`_oeis.py`). `from ndplex import ndplex, oeis` works as before. `import ndplex` needs only NumPy (≥ 1.23.5); `oeis` uses the standard library and is loaded on first use.
+- **Plotting is left out.** `plot_ndplex` and `diag_as_hist` are not in the package; importing them raises an `ImportError` that points to the notebook in the repository, which has the original versions (Phase 4, C13; an examples notebook with working copies is planned).
+- **No import side effects.** Importing no longer silences warnings or restyles matplotlib.
+- **Overflow is reported.** If any node overflows the dtype, construction issues one `RuntimeWarning` naming the first node that did. Values are unchanged. `dtype=object` is exact, now including sums in `diag` and `as_tri` past 2^63.
+- **Overflow is reported for every integer dtype, on every NumPy version** (Phase 3, `docs/phase3_ci.md`, C12). On NumPy < 2, overflow in int8, int16, int32 and unsigned arrays went unreported. An integer from `func` that does not fit the dtype is now wrapped and reported, where it used to wrap silently (NumPy < 2) or raise `OverflowError` (NumPy 2, or a Python int beyond int64).
+- **CI.** Tests run on Linux (Python 3.10–3.15), macOS and Windows, on NumPy 1.23.5 and the latest NumPy.
+- **Derived arrays keep working.** `diag` works on slices, arithmetic results, copies and unpickled arrays. Reductions (`sum`, `max`, ...) return plain scalars. Pickling keeps `edges`, `func` and `arg_locs` (a `func` that cannot be pickled comes back as `None`).
+- **`arg_locs` outside the array read 0** instead of wrapping around to the far side. Positive offsets raise `ValueError`. The default is `arg_locs=None`.
+- **`diag` ends where the moves leave the array**, so genuine trailing zeros are kept and all-zero lines return zeros instead of raising `IndexError`.
+- **`as_tri` layers are left-justified in every dimension.** 2-D and 3-D are unchanged; from 4-D up the notebook's layers were sheared. Values and sums are unchanged.
+- **Arguments.** NumPy integer `edges` accepted; bad arguments raise `ValueError` with a message; the default dtype is `np.int64` on every platform; the default `func` is the builtin `sum`.
+- **`oeis`.** https and a timeout; requests name ndplex in their User-Agent header, because oeis.org now refuses Python's default one (C14); network or format failures print `lookup failed (...)` instead of `no match`; `quiet=True` returns the results instead of printing.
+- **Release.** Published to PyPI with Trusted Publishing (`.github/workflows/publish.yml`). The README is now the package's own documentation, and its examples run as tests. `CITATION.cff` added.

ndplex-0.1.0/CITATION.cff

@@ -0,0 +1,42 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it using the metadata from this file."
+type: software
+title: "ndplex: the n-Dimensional m-Plex array, a generic Pascal's array for NumPy"
+abstract: >-
+  A generic Pascal's array of any dimension, as a NumPy array subclass: by
+  default Pascal's rectangle, cube or hypercube, with user-defined edges,
+  node-generating function and argument locations. Includes lines and
+  cross-sections through the array (diag), the array as a triangle,
+  tetrahedron or n-simplex (as_tri), and row-by-row lookup in the On-Line
+  Encyclopedia of Integer Sequences (oeis).
+authors:
+  - family-names: Teske
+    given-names: Ted
+version: 0.1.0
+license: MIT
+# The Zenodo concept DOI and the version DOIs are added after the first
+# Zenodo-archived release (0.1.0).
+repository-code: "https://github.com/tedteske/ndplex"
+url: "https://pypi.org/project/ndplex/"
+keywords:
+  - Pascal's triangle
+  - Pascal's array
+  - combinatorics
+  - binomial coefficients
+  - multinomial coefficients
+  - simplex
+  - integer sequences
+  - OEIS
+  - NumPy
+references:
+  - type: book
+    title: "The Simplex, Duplex and Pascal's Triangles: Relatives of Pascal's Triangle, with Excursions Into Hyperspace"
+    authors:
+      - family-names: Green
+        given-names: Thomas M.
+    year: 2015
+    publisher:
+      name: CreateSpace Independent Publishing Platform
+    isbn: "9781514677094"
+    pages: 176
+    notes: "A general source for ndplex."

ndplex-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Ted Teske
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ndplex-0.1.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: ndplex
+Version: 0.1.0
+Summary: The n-Dimensional m-Plex array: a generic Pascal's array (rectangle, cube or higher) with user-defined edges and node-generating function.
+Project-URL: Homepage, https://github.com/tedteske/ndplex
+Project-URL: Source, https://github.com/tedteske/ndplex
+Project-URL: Issues, https://github.com/tedteske/ndplex/issues
+Project-URL: Changelog, https://github.com/tedteske/ndplex/blob/master/CHANGELOG.md
+Author: Ted Teske
+License-Expression: MIT
+License-File: LICENSE
+Keywords: binomial,combinatorics,integer sequences,multinomial,numpy,oeis,pascal's array,pascal's triangle,simplex
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.23.5
+Description-Content-Type: text/markdown
+
+# ndplex
+
+**The n-Dimensional m-Plex array: a generic Pascal's array for NumPy.**
+
+`ndplex` builds Pascal's rectangle, cube or hypercube as a NumPy array, and lets you change everything that defines it: the values on its edges, the rule that generates each interior node, and which neighbours that rule reads. It can then cut lines and cross-sections through the array, show the array as a triangle, tetrahedron or n-simplex, and look its rows up in the [On-Line Encyclopedia of Integer Sequences](https://oeis.org).
+
+## Install
+
+```
+pip install ndplex
+```
+
+In Google Colab, run `!pip install ndplex` in a cell. ndplex needs Python 3.10 or later and NumPy 1.23.5 or later, nothing else. `oeis` needs a network connection when it is called.
+
+## Quick start
+
+By default, `ndplex(n)` is Pascal's rectangle: ones on the top and left edges, and every other node the sum of the node above it and the node to its left.
+
+```pycon
+>>> from ndplex import ndplex
+>>> p = ndplex(6)
+>>> print(p)
+[[  1   1   1   1   1   1]
+ [  1   2   3   4   5   6]
+ [  1   3   6  10  15  21]
+ [  1   4  10  20  35  56]
+ [  1   5  15  35  70 126]
+ [  1   6  21  56 126 252]]
+```
+
+`as_tri` shows the same array as Pascal's triangle, justified left, or returns the sum of each row.
+
+```pycon
+>>> print(p.as_tri())
+[[ 1  0  0  0  0  0]
+ [ 1  1  0  0  0  0]
+ [ 1  2  1  0  0  0]
+ [ 1  3  3  1  0  0]
+ [ 1  4  6  4  1  0]
+ [ 1  5 10 10  5  1]]
+>>> print(p.as_tri(sums=True))
+[ 1  2  4  8 16 32]
+```
+
+`diag` walks through the array from a starting node by a fixed step. Row 4 of the triangle is an anti-diagonal of the rectangle; the main diagonal holds the central binomial coefficients.
+
+```pycon
+>>> print(p.diag(loc=(4, 0), move=(-1, 1)))
+[1 4 6 4 1]
+>>> print(p.diag())
+[  1   2   6  20  70 252]
+```
+
+The steeper diagonals sum to the Fibonacci numbers:
+
+```pycon
+>>> f = ndplex(10)
+>>> print([int(f.diag(loc=(k, 0), move=(-2, 1)).sum()) for k in range(10)])
+[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+```
+
+## Other arrays
+
+`ndplex(nrows, edges=(1, 1), arg_locs=None, func=sum, dtype=np.int64)`
+
+- **`edges`** sets the front edges, as numbers or as sequences of length `nrows`. Their number sets the dimension. In 2-D, `edges[0]` fills column 0 and `edges[1]` fills row 0.
+- **`func`** generates each interior node from a list of argument values. The default is `sum`.
+- **`arg_locs`** gives where those arguments are, relative to the node. The default in 2-D is `[[-1, 0], [0, -1]]`, the nodes above and to the left. A `None` coordinate means "on the edge".
+
+Odd numbers along the top edge give the squares, the square pyramidal numbers, and so on down the rows:
+
+```pycon
+>>> print(ndplex(5, edges=(1, [1, 3, 5, 7, 9])))
+[[  1   3   5   7   9]
+ [  1   4   9  16  25]
+ [  1   5  14  30  55]
+ [  1   6  20  50 105]
+ [  1   7  27  77 182]]
+```
+
+Pascal's rule modulo 2 gives the Sierpinski pattern:
+
+```pycon
+>>> print(ndplex(6, func=lambda x: sum(x) % 2))
+[[1 1 1 1 1 1]
+ [1 0 1 0 1 0]
+ [1 1 0 0 1 1]
+ [1 0 0 0 1 0]
+ [1 1 1 1 0 0]
+ [1 0 1 0 0 0]]
+```
+
+Adding the diagonal neighbour as a third argument gives the Delannoy numbers:
+
+```pycon
+>>> print(ndplex(6, arg_locs=[[-1, 0], [0, -1], [-1, -1]]))
+[[   1    1    1    1    1    1]
+ [   1    3    5    7    9   11]
+ [   1    5   13   25   41   61]
+ [   1    7   25   63  129  231]
+ [   1    9   41  129  321  681]
+ [   1   11   61  231  681 1683]]
+```
+
+## Higher dimensions
+
+Three edges make Pascal's cube; `as_tri` shows it as a tetrahedron, layer by layer. Each layer holds the trinomial coefficients, and the layers sum to powers of 3.
+
+```pycon
+>>> c = ndplex(4, edges=3)
+>>> print(c.as_tri()[2])
+[[1 2 1 0]
+ [2 2 0 0]
+ [1 0 0 0]
+ [0 0 0 0]]
+>>> print(c.as_tri(sums=True))
+[ 1  3  9 27]
+```
+
+The same works in any number of dimensions: `ndplex(5, edges=4)` is a 4-D array, and its `as_tri` is a 4-simplex.
+
+## Large values
+
+Node values grow quickly. With the default `int64`, the 2-D array is exact for nodes with `i + j <= 66`. If any node overflows, construction issues one `RuntimeWarning` naming the first node that did. For exact integers of any size, use `dtype=object`:
+
+```pycon
+>>> print(ndplex(70, dtype=object)[69, 69])
+23623985175715118288974865541854103729000
+```
+
+When only a residue is needed, reduce inside `func` instead, as in the Sierpinski example above.
+
+## Looking rows up in OEIS
+
+`oeis` searches oeis.org for each row of an array and prints the best match. It sends one request per row, so please search a few rows at a time.
+
+```python
+from ndplex import ndplex, oeis
+
+oeis(ndplex(5))
+oeis(ndplex(9).as_tri(), trim=True, size=5)   # rows of the triangle, zeros trimmed
+matches = oeis(ndplex(5), quiet=True)        # a list of (A-number, name) or None
+```
+
+The output has one line per row, for example `row 2: https://oeis.org/A000217 Triangular numbers: ...`. The names come from OEIS and can change. If oeis.org cannot be reached or refuses the request, the row's line says `lookup failed (...)`. Each request identifies itself to oeis.org as `ndplex/<version>`.
+
+## Plotting
+
+From 0.1.0, plotting is left to the user, so `import ndplex` needs only NumPy. The notebook's `plot_ndplex` and `diag_as_hist` are in [`ndplex_array.ipynb`](https://github.com/tedteske/ndplex/blob/master/ndplex_array.ipynb) in the repository; an examples notebook that installs from PyPI is planned.
+
+## Changes from the notebook
+
+ndplex began as the first code cell of `ndplex_array.ipynb` (2019–2024). The package keeps the notebook's results except where a change is documented. The changes are listed in the [changelog](https://github.com/tedteske/ndplex/blob/master/CHANGELOG.md), with migration notes in [`docs/`](https://github.com/tedteske/ndplex/tree/master/docs). In brief: no import side effects, plotting left out, overflow reported, `arg_locs` outside the array read 0, `diag` ends where its moves leave the array, and `as_tri` layers are justified left in every dimension.
+
+## Background and credits
+
+ndplex is the original work of Ted Teske (2019–2024). A general source for it is Thomas M. Green, *The Simplex, Duplex and Pascal's Triangles: Relatives of Pascal's Triangle, with Excursions Into Hyperspace* (CreateSpace, 2015; ISBN 9781514677094).
+
+The packaging, tests and audit (2026) were developed with assistance from Claude (Anthropic). [`ATTRIBUTION.md`](https://github.com/tedteske/ndplex/blob/master/ATTRIBUTION.md) sets out which work is whose, and the references.
+
+## Citing
+
+Citation metadata are in [`CITATION.cff`](https://github.com/tedteske/ndplex/blob/master/CITATION.cff); GitHub's "Cite this repository" button reads it.
+
+## License
+
+MIT. Copyright (c) 2019 Ted Teske.

ndplex-0.1.0/README.md

@@ -0,0 +1,167 @@
+# ndplex
+
+**The n-Dimensional m-Plex array: a generic Pascal's array for NumPy.**
+
+`ndplex` builds Pascal's rectangle, cube or hypercube as a NumPy array, and lets you change everything that defines it: the values on its edges, the rule that generates each interior node, and which neighbours that rule reads. It can then cut lines and cross-sections through the array, show the array as a triangle, tetrahedron or n-simplex, and look its rows up in the [On-Line Encyclopedia of Integer Sequences](https://oeis.org).
+
+## Install
+
+```
+pip install ndplex
+```
+
+In Google Colab, run `!pip install ndplex` in a cell. ndplex needs Python 3.10 or later and NumPy 1.23.5 or later, nothing else. `oeis` needs a network connection when it is called.
+
+## Quick start
+
+By default, `ndplex(n)` is Pascal's rectangle: ones on the top and left edges, and every other node the sum of the node above it and the node to its left.
+
+```pycon
+>>> from ndplex import ndplex
+>>> p = ndplex(6)
+>>> print(p)
+[[  1   1   1   1   1   1]
+ [  1   2   3   4   5   6]
+ [  1   3   6  10  15  21]
+ [  1   4  10  20  35  56]
+ [  1   5  15  35  70 126]
+ [  1   6  21  56 126 252]]
+```
+
+`as_tri` shows the same array as Pascal's triangle, justified left, or returns the sum of each row.
+
+```pycon
+>>> print(p.as_tri())
+[[ 1  0  0  0  0  0]
+ [ 1  1  0  0  0  0]
+ [ 1  2  1  0  0  0]
+ [ 1  3  3  1  0  0]
+ [ 1  4  6  4  1  0]
+ [ 1  5 10 10  5  1]]
+>>> print(p.as_tri(sums=True))
+[ 1  2  4  8 16 32]
+```
+
+`diag` walks through the array from a starting node by a fixed step. Row 4 of the triangle is an anti-diagonal of the rectangle; the main diagonal holds the central binomial coefficients.
+
+```pycon
+>>> print(p.diag(loc=(4, 0), move=(-1, 1)))
+[1 4 6 4 1]
+>>> print(p.diag())
+[  1   2   6  20  70 252]
+```
+
+The steeper diagonals sum to the Fibonacci numbers:
+
+```pycon
+>>> f = ndplex(10)
+>>> print([int(f.diag(loc=(k, 0), move=(-2, 1)).sum()) for k in range(10)])
+[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+```
+
+## Other arrays
+
+`ndplex(nrows, edges=(1, 1), arg_locs=None, func=sum, dtype=np.int64)`
+
+- **`edges`** sets the front edges, as numbers or as sequences of length `nrows`. Their number sets the dimension. In 2-D, `edges[0]` fills column 0 and `edges[1]` fills row 0.
+- **`func`** generates each interior node from a list of argument values. The default is `sum`.
+- **`arg_locs`** gives where those arguments are, relative to the node. The default in 2-D is `[[-1, 0], [0, -1]]`, the nodes above and to the left. A `None` coordinate means "on the edge".
+
+Odd numbers along the top edge give the squares, the square pyramidal numbers, and so on down the rows:
+
+```pycon
+>>> print(ndplex(5, edges=(1, [1, 3, 5, 7, 9])))
+[[  1   3   5   7   9]
+ [  1   4   9  16  25]
+ [  1   5  14  30  55]
+ [  1   6  20  50 105]
+ [  1   7  27  77 182]]
+```
+
+Pascal's rule modulo 2 gives the Sierpinski pattern:
+
+```pycon
+>>> print(ndplex(6, func=lambda x: sum(x) % 2))
+[[1 1 1 1 1 1]
+ [1 0 1 0 1 0]
+ [1 1 0 0 1 1]
+ [1 0 0 0 1 0]
+ [1 1 1 1 0 0]
+ [1 0 1 0 0 0]]
+```
+
+Adding the diagonal neighbour as a third argument gives the Delannoy numbers:
+
+```pycon
+>>> print(ndplex(6, arg_locs=[[-1, 0], [0, -1], [-1, -1]]))
+[[   1    1    1    1    1    1]
+ [   1    3    5    7    9   11]
+ [   1    5   13   25   41   61]
+ [   1    7   25   63  129  231]
+ [   1    9   41  129  321  681]
+ [   1   11   61  231  681 1683]]
+```
+
+## Higher dimensions
+
+Three edges make Pascal's cube; `as_tri` shows it as a tetrahedron, layer by layer. Each layer holds the trinomial coefficients, and the layers sum to powers of 3.
+
+```pycon
+>>> c = ndplex(4, edges=3)
+>>> print(c.as_tri()[2])
+[[1 2 1 0]
+ [2 2 0 0]
+ [1 0 0 0]
+ [0 0 0 0]]
+>>> print(c.as_tri(sums=True))
+[ 1  3  9 27]
+```
+
+The same works in any number of dimensions: `ndplex(5, edges=4)` is a 4-D array, and its `as_tri` is a 4-simplex.
+
+## Large values
+
+Node values grow quickly. With the default `int64`, the 2-D array is exact for nodes with `i + j <= 66`. If any node overflows, construction issues one `RuntimeWarning` naming the first node that did. For exact integers of any size, use `dtype=object`:
+
+```pycon
+>>> print(ndplex(70, dtype=object)[69, 69])
+23623985175715118288974865541854103729000
+```
+
+When only a residue is needed, reduce inside `func` instead, as in the Sierpinski example above.
+
+## Looking rows up in OEIS
+
+`oeis` searches oeis.org for each row of an array and prints the best match. It sends one request per row, so please search a few rows at a time.
+
+```python
+from ndplex import ndplex, oeis
+
+oeis(ndplex(5))
+oeis(ndplex(9).as_tri(), trim=True, size=5)   # rows of the triangle, zeros trimmed
+matches = oeis(ndplex(5), quiet=True)        # a list of (A-number, name) or None
+```
+
+The output has one line per row, for example `row 2: https://oeis.org/A000217 Triangular numbers: ...`. The names come from OEIS and can change. If oeis.org cannot be reached or refuses the request, the row's line says `lookup failed (...)`. Each request identifies itself to oeis.org as `ndplex/<version>`.
+
+## Plotting
+
+From 0.1.0, plotting is left to the user, so `import ndplex` needs only NumPy. The notebook's `plot_ndplex` and `diag_as_hist` are in [`ndplex_array.ipynb`](https://github.com/tedteske/ndplex/blob/master/ndplex_array.ipynb) in the repository; an examples notebook that installs from PyPI is planned.
+
+## Changes from the notebook
+
+ndplex began as the first code cell of `ndplex_array.ipynb` (2019–2024). The package keeps the notebook's results except where a change is documented. The changes are listed in the [changelog](https://github.com/tedteske/ndplex/blob/master/CHANGELOG.md), with migration notes in [`docs/`](https://github.com/tedteske/ndplex/tree/master/docs). In brief: no import side effects, plotting left out, overflow reported, `arg_locs` outside the array read 0, `diag` ends where its moves leave the array, and `as_tri` layers are justified left in every dimension.
+
+## Background and credits
+
+ndplex is the original work of Ted Teske (2019–2024). A general source for it is Thomas M. Green, *The Simplex, Duplex and Pascal's Triangles: Relatives of Pascal's Triangle, with Excursions Into Hyperspace* (CreateSpace, 2015; ISBN 9781514677094).
+
+The packaging, tests and audit (2026) were developed with assistance from Claude (Anthropic). [`ATTRIBUTION.md`](https://github.com/tedteske/ndplex/blob/master/ATTRIBUTION.md) sets out which work is whose, and the references.
+
+## Citing
+
+Citation metadata are in [`CITATION.cff`](https://github.com/tedteske/ndplex/blob/master/CITATION.cff); GitHub's "Cite this repository" button reads it.
+
+## License
+
+MIT. Copyright (c) 2019 Ted Teske.