ndplex 0.1.0__py3-none-any.whl

ndplex/__init__.py

@@ -0,0 +1,42 @@
+"""
+ndplex -- the n-Dimensional m-Plex array: a generic Pascal's array (rectangle,
+cube or higher) with user-defined edges and node-generating function.
+
+    from ndplex import ndplex, oeis
+
+    p = ndplex(9)              # Pascal's rectangle, 9 x 9
+    p.diag(loc=(4, 0), move=(-1, 1))   # row 4 of Pascal's triangle
+    p.as_tri()                 # the whole triangle, justified left
+    oeis(p.as_tri(), trim=True, size=5)   # look the rows up on oeis.org
+
+`import ndplex` needs only numpy. `oeis` is loaded on first use and needs
+network access when called.
+
+Attribution (see ATTRIBUTION.md for the tiered breakdown and references):
+  - Original work (2019-2024): Ted Teske -- the ndplex array, diag, as_tri
+    and oeis, in the notebook ndplex_array.ipynb.
+  - Packaging and the Phase 2 fixes (2026): Ted Teske with Claude (Anthropic).
+"""
+from ._core import ndplex
+
+__version__ = "0.1.0"
+
+__all__ = ["ndplex", "oeis", "__version__"]
+
+_MOVED = (
+    "is not part of the ndplex package (from 0.1.0, plotting is left to the "
+    "user). The notebook's version is in ndplex_array.ipynb, in the "
+    "repository: https://github.com/tedteske/ndplex")
+
+
+def __getattr__(name):
+    if name == "oeis":
+        from ._oeis import oeis
+        return oeis
+    if name in ("plot_ndplex", "diag_as_hist"):
+        raise ImportError(f"{name} {_MOVED}")
+    raise AttributeError(f"module 'ndplex' has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(set(globals()) | {"oeis"})

ndplex/_core.py

@@ -0,0 +1,399 @@
+"""
+The ndplex array: a generic Pascal's array of any dimension.
+
+Original design and code: Ted Teske, 2019-2024 (the notebook
+ndplex_array.ipynb). Package version: Ted Teske with Claude (Anthropic),
+2026; the changes from the notebook are listed in docs/phase2_package.md.
+"""
+import itertools as it
+import operator
+import pickle
+import warnings
+
+import numpy as np
+
+__all__ = ["ndplex"]
+
+# Padding and fill values below are created with np.zeros or assigned as the
+# Python int 0. For dtype=object both give Python int zeros, so sums of
+# object arrays stay exact (the notebook padded with np.pad, which inserts
+# numpy int64 zeros: audit finding N12).
+
+
+def _trim_outside(values, inside):
+    """Trim trailing positions that lie wholly outside the array.
+
+    `inside` has the shape of `values` and is True where a value was read
+    from the array (False where it is zero padding). Along each axis, the
+    result ends at the last position with any value read from the array,
+    so genuine zeros are kept and an all-zero line returns zeros.
+    """
+    slices = []
+    for axis in range(values.ndim):
+        others = tuple(a for a in range(values.ndim) if a != axis)
+        hits = np.flatnonzero(inside.any(axis=others))
+        slices.append(slice(hits[-1] + 1 if hits.size else 0))
+    return values[tuple(slices)]
+
+
+class ndplex(np.ndarray):
+    """
+    n-Dimensional m-Plex (ndplex) array: a generic Pascal's rectangle, cube,
+    or higher-dimensional array, as a numpy array subclass.
+
+    By default, a square array of integers with ones on the top and left
+    edges and every interior node generated by Pascal's rule (the sum of the
+    node above and the node to the left). Any number of edges, any edge
+    values and any node-generating function may be given instead.
+
+    Parameters
+    ----------
+    nrows : int >= 1
+        Length of each edge; the array has shape (nrows,) * ndim.
+    edges : int, or sequence of numbers or 1-D sequences of length nrows
+        The front edges. An int n means n edges of ones. The number of edges
+        sets ndim. Edge k lies along axis k (all other coordinates 0): in
+        2-D, edges[0] fills column 0 and edges[1] fills row 0. Where edges
+        meet, at the origin, the last edge's value is kept.
+    arg_locs : None or sequence of sequences of ints <= 0 or None
+        Locations, relative to the node being generated, of the arguments
+        passed to `func`, in that order. None (the default) means the
+        neighbour one step back along each axis: [[-1, 0], [0, -1]] in 2-D.
+        A None coordinate means "on the edge" (coordinate 0 on that axis).
+        A location outside the array reads 0. Positive offsets are not
+        allowed (those nodes have not been computed yet).
+    func : callable
+        Called with the list of argument values for each interior node;
+        returns the node's value. Default: the builtin `sum`.
+    dtype : numpy dtype
+        Default np.int64 on every platform. int64 is exact only while every
+        node fits: the default 2-D array is exact for i + j <= 66 and the
+        default 3-D array for i + j + k <= 43. If any node overflows (in
+        func's arithmetic, or because func returns an integer that does not
+        fit dtype), one RuntimeWarning names the first node that did; values
+        are kept as numpy computes them (wrapped modulo 2**64, or 2**bits
+        for a narrower integer dtype). The same holds on every platform and
+        NumPy version. Use dtype=object for
+        exact integers of any size, or reduce inside `func` (for example a
+        modulus) when only a residue is needed.
+
+    Attributes
+    ----------
+    nrows : int or None
+        Length of each edge, read from the shape (None if the sides differ,
+        as for some slices).
+    edges, func, arg_locs : the parameters the array was built with,
+        carried along by slices, copies and arithmetic as a record; they are
+        not used after construction.
+
+    Methods
+    -------
+    diag(loc, move, sum_axis)
+        A line or cross-section through the array.
+    as_tri(start, end, sums)
+        The array as a triangle (2-D), tetrahedron (3-D) or n-simplex.
+
+    Notes
+    -----
+    Slices and arithmetic return ndplex arrays; reductions such as `sum`
+    and `max` return plain numpy scalars; `diag` and `as_tri` return plain
+    numpy arrays. Pickling keeps the attributes, except a `func` that cannot
+    itself be pickled (such as a lambda), which comes back as None.
+    """
+
+    def __new__(cls, nrows, edges=(1, 1), arg_locs=None, func=sum,
+                dtype=np.int64):
+        if nrows < 1:
+            raise ValueError(f"nrows must be at least 1, got {nrows}")
+
+        if isinstance(edges, (int, np.integer)):
+            if edges < 1:
+                raise ValueError(f"edges must be at least 1, got {edges}")
+            edges = (1,) * int(edges)
+        ndim = len(edges)
+        if ndim < 1:
+            raise ValueError("edges must not be empty")
+        for k, e in enumerate(edges):
+            shape_e = np.shape(e)
+            if not (shape_e == () or shape_e == (nrows,)):
+                raise ValueError(
+                    f"edge {k} must be a number or a 1-D sequence of length "
+                    f"nrows={nrows}; got shape {shape_e}")
+
+        base = np.zeros((nrows,) * ndim, dtype=dtype)
+
+        # Populate the front edges: rotate the axes so that each edge in turn
+        # lies along the last axis, and fill it. After ndim rotations the
+        # axes are back in their original order.
+        view = base
+        edge_loc = (0,) * (ndim - 1) + (slice(None),)
+        for k in range(ndim):
+            view = np.moveaxis(view, 0, -1)
+            view[edge_loc] = edges[k]
+
+        if arg_locs is None or len(arg_locs) == 0:
+            arg_locs = -np.eye(ndim, dtype=int)
+            offsets = [tuple(int(v) for v in row) for row in arg_locs]
+        else:
+            offsets = []
+            for loc in arg_locs:
+                if len(loc) != ndim:
+                    raise ValueError(
+                        f"each arg_loc needs {ndim} coordinates, got "
+                        f"{tuple(loc)}")
+                offset = []
+                for v in loc:
+                    if v is not None:
+                        v = operator.index(v)
+                        if v > 0:
+                            raise ValueError(
+                                f"arg_locs offsets must be <= 0 (or None), "
+                                f"got {tuple(loc)}")
+                    offset.append(v)
+                offsets.append(tuple(offset))
+
+        zero = base.dtype.type(0)  # for dtype=object, the Python int 0
+        # Integer dtypes: also check that each integer func returns fits the
+        # dtype before it is stored, and wrap it if not. numpy's own overflow
+        # check (errstate, below) only sees overflow inside func's
+        # arithmetic, and numpy handles a value too wide for the dtype
+        # differently by version: NumPy < 2 wraps it silently on assignment,
+        # NumPy 2 raises OverflowError. The wide value is what the default
+        # func=sum returns on NumPy < 2 for dtypes narrower than the
+        # platform's default int (int8/16/32 on Linux and macOS), because
+        # sum's start value 0 promotes the total to that default int.
+        if np.issubdtype(base.dtype, np.integer):
+            info = np.iinfo(base.dtype)
+            low, high = int(info.min), int(info.max)
+            span = high - low + 1  # 2**bits
+            stored_type = base.dtype.type  # values of this type always fit
+        else:
+            low = None
+        first_overflow = None
+        with np.errstate(over="raise"):
+            for node in it.product(range(nrows), repeat=ndim):
+                if node.count(0) >= ndim - 1:
+                    continue  # on an edge
+                args = []
+                for offset in offsets:
+                    target = tuple(0 if o is None else n + o
+                                   for n, o in zip(node, offset))
+                    args.append(zero if min(target) < 0 else base[target])
+                try:
+                    value = func(args)
+                except FloatingPointError:
+                    # numpy reports the overflow; keep its wrapped value.
+                    with np.errstate(over="ignore"):
+                        value = func(args)
+                    if first_overflow is None:
+                        first_overflow = node
+                if (low is not None and type(value) is not stored_type
+                        and isinstance(value, (int, np.integer))):
+                    v = int(value)
+                    if not low <= v <= high:
+                        value = (v - low) % span + low  # wrap, as numpy does
+                        if first_overflow is None:
+                            first_overflow = node
+                base[node] = value
+
+        if first_overflow is not None:
+            warnings.warn(
+                f"ndplex: node values overflowed {base.dtype} from node "
+                f"{first_overflow} on (in generation order); that node and "
+                f"those computed from it are wrong. Use dtype=object for exact "
+                f"integers, or reduce inside func (e.g. a modulus).",
+                RuntimeWarning, stacklevel=2)
+
+        obj = base.view(cls)
+        obj.edges, obj.func, obj.arg_locs = edges, func, arg_locs
+        return obj
+
+    # --- numpy subclass plumbing ---------------------------------------------
+
+    def __array_finalize__(self, obj):
+        self.edges = getattr(obj, "edges", None)
+        self.func = getattr(obj, "func", None)
+        self.arg_locs = getattr(obj, "arg_locs", None)
+
+    def __array_wrap__(self, obj, context=None, return_scalar=False):
+        out = super().__array_wrap__(obj, context)
+        if out.ndim == 0:
+            return out[()]  # reductions give plain scalars
+        return out
+
+    def __reduce__(self):
+        constructor, args, state = super().__reduce__()
+        func = self.func
+        try:
+            pickle.dumps(func)
+        except Exception:
+            func = None
+        return constructor, args, (state, (self.edges, func, self.arg_locs))
+
+    def __setstate__(self, state):
+        array_state, (edges, func, arg_locs) = state
+        super().__setstate__(array_state)
+        self.edges, self.func, self.arg_locs = edges, func, arg_locs
+
+    @property
+    def nrows(self):
+        """Length of each edge, from the shape; None if the sides differ."""
+        s = self.shape
+        if s and all(x == s[0] for x in s):
+            return s[0]
+        return None
+
+    # --- lines and cross-sections --------------------------------------------
+
+    def _line(self, loc, move):
+        """Values along the moves from loc, and where they lie in the array.
+
+        Returns (values, inside): plain arrays of the same shape, one axis
+        per move (last move first) plus any axes loc does not fix. Positions
+        outside the array hold zero and are False in `inside`.
+        """
+        a = np.asarray(self)
+        if len(loc) == 0:
+            loc = (0,) * a.ndim
+        k = len(loc)
+        if len(move) == 0:
+            move = (1,) * k
+        if np.isscalar(move[0]):
+            move = [move]
+        if k > a.ndim:
+            raise ValueError(f"loc has {k} coordinates; the array has "
+                             f"{a.ndim} dimensions")
+        for m in move:
+            if len(m) != k:
+                raise ValueError(f"each move needs {k} coordinates (as many "
+                                 f"as loc), got {tuple(m)}")
+
+        steps = np.arange(max(a.shape))
+        coords = []
+        for dim in range(k):
+            c = loc[dim]
+            for i in range(len(move)):
+                step_grid = np.broadcast_to(steps, (len(steps),) * (i + 1)).T
+                c = step_grid * move[i][dim] + c
+            coords.append(c)
+        coords = np.stack(coords)
+
+        bounds = np.array(a.shape[:k]).reshape((k,) + (1,) * (coords.ndim - 1))
+        inside = ((coords >= 0) & (coords < bounds)).all(axis=0)
+        index = tuple(np.where(inside, coords, 0))
+        values = a[index]
+        rest = (1,) * (values.ndim - inside.ndim)
+        inside = np.broadcast_to(inside.reshape(inside.shape + rest),
+                                 values.shape)
+        values[~inside] = 0
+        return values, inside
+
+    def diag(self, loc=(), move=(), sum_axis=None):
+        """
+        A diagonal: a line or cross-section through the array.
+
+        Starts at the node (or, with fewer coordinates than dimensions, the
+        sub-array) `loc` and steps through the array by `move`, returning
+        the values it passes. With several moves, the result has one axis
+        per move, the last move first.
+
+        Parameters
+        ----------
+        loc : tuple of ints
+            Starting coordinates. Default: the origin.
+        move : tuple of ints, or list of such tuples
+            Step(s), each with as many coordinates as loc. Default: one step
+            along every axis that loc fixes (with the default loc, the main
+            diagonal).
+        sum_axis : None or int
+            If given, sum the result over this axis.
+
+        Returns
+        -------
+        numpy.ndarray (0-d for a single node), or its sums over sum_axis.
+
+        Notes
+        -----
+        The result ends where the moves leave the array, so its length is
+        set by the geometry, not the values: genuine trailing zeros are
+        kept, and a line of zeros returns zeros. Positions outside the array
+        but before the end read as 0.
+        """
+        values, inside = self._line(loc, move)
+        values = np.squeeze(values)
+        inside = np.squeeze(inside)
+        result = _trim_outside(values, inside)
+        if sum_axis is None:
+            return result
+        return result.sum(axis=sum_axis)
+
+    def as_tri(self, start=0, end=None, sums=False):
+        """
+        The array as a triangle (2-D), tetrahedron (3-D), 4-simplex (4-D),
+        and so on: the series of (n-1)-dimensional cross-sections through
+        the array along its anti-diagonals.
+
+        In the simplest case, Pascal's rectangle as Pascal's triangle,
+        justified left. Every layer is justified left (toward index 0 on
+        each axis): element [k][x_1, ..., x_(n-1)] is the node whose
+        coordinates are x_1, ..., x_(n-1) on the axes other than axis n-2,
+        and k - (x_1 + ... + x_(n-1)) on axis n-2. In 4-D, tri[k][a, b, c]
+        is the node (a, b, k - a - b - c, c). Returns the result (it does
+        not print it).
+
+        Parameters
+        ----------
+        start, end : int
+            First and last row (2-D) or layer (3-D and up). Default: all.
+        sums : bool
+            If True, return the sum of each row or layer instead.
+
+        Returns
+        -------
+        numpy.ndarray
+            If sums is False, shape (end - start + 1,) + (end + 1,) * (ndim - 1),
+            with each cross-section padded with zeros on the right. If sums is
+            True, the 1-D array of sums. A genuine zero in a cross-section is
+            indistinguishable from the padding.
+        """
+        a = np.asarray(self)
+        if a.ndim < 2:
+            raise ValueError("as_tri needs an array of at least 2 dimensions")
+        if any(x != a.shape[0] for x in a.shape):
+            raise ValueError(f"as_tri needs equal sides; the shape is {a.shape}")
+        ndim = a.ndim
+        if end is None:
+            end = a.shape[0] - 1
+
+        # The cross-section of layer i starts at the node with i on the
+        # pivot axis (ndim - 2) and 0 elsewhere. Each move takes one step
+        # from the pivot axis to another axis: first the last axis, then
+        # the axes before the pivot, nearest first.
+        #   2-D: [(-1, 1)]
+        #   3-D: [(0, -1, 1), (1, -1, 0)]
+        #   4-D: [(0, 0, -1, 1), (0, 1, -1, 0), (1, 0, -1, 0)]
+        # So every layer is a left-justified simplex: in 4-D, element
+        # [a, b, c] of layer i is the node (a, b, i - a - b - c, c).
+        # (The notebook's pattern took later moves' steps from the
+        # neighbouring axis instead, which sheared layers in 4-D and up;
+        # 2-D and 3-D are unchanged.)
+        pivot = ndim - 2
+        unit = np.eye(ndim, dtype=int)
+        targets = [ndim - 1] + list(range(pivot - 1, -1, -1))
+        moves = np.array([unit[t] - unit[pivot] for t in targets])
+        loc = [0] * ndim  # the cross-section starts at loc[pivot] = i
+
+        width = (end + 1,) * (ndim - 1)
+        rows = []
+        for i in range(start, end + 1):
+            loc[pivot] = i
+            values, inside = self._line(tuple(loc), moves)
+            section = _trim_outside(values, inside)
+            row = np.zeros(width, dtype=a.dtype)
+            row[tuple(slice(s) for s in section.shape)] = section
+            rows.append(row)
+
+        tri = np.stack(rows, axis=0)
+        if sums:
+            return tri.sum(axis=tuple(range(1, ndim)))
+        return tri

ndplex/_oeis.py

@@ -0,0 +1,120 @@
+"""
+oeis(): look up each row of an array in the On-Line Encyclopedia of Integer
+Sequences (https://oeis.org).
+
+Original function: Ted Teske, 2019-2024 (the notebook ndplex_array.ipynb).
+Package version (https, a timeout, standard library only, failures reported
+as failures, a User-Agent naming ndplex): Ted Teske with Claude (Anthropic),
+2026.
+"""
+import urllib.parse
+import urllib.request
+
+import numpy as np
+
+__all__ = ["oeis"]
+
+SEARCH_URL = "https://oeis.org/search"
+USER_AGENT = "ndplex/{version} (+https://github.com/tedteske/ndplex)"
+_GREETING = "# Greetings from The On-Line Encyclopedia"
+
+
+def urlopen(url, timeout):
+    """The network call, kept separate so tests can replace it.
+
+    The request names ndplex in its User-Agent header. oeis.org refuses
+    Python's default one ("Python-urllib/3.x") with HTTP 403 (Cloudflare
+    error 1010), checked from Google Colab on 7 Nov 2026.
+    """
+    from . import __version__  # here, not at the top: ndplex imports this module
+    request = urllib.request.Request(
+        url, headers={"User-Agent": USER_AGENT.format(version=__version__)})
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        return response.read().decode("utf-8", errors="replace")
+
+
+def _lookup(sequence, timeout):
+    """Best OEIS match for `sequence` as (A-number, name), or None.
+
+    Raises OSError if OEIS cannot be reached and ValueError if the answer
+    is not in OEIS's text format.
+    """
+    query = urllib.parse.urlencode(
+        {"q": ",".join(str(s) for s in sequence), "n": "1", "fmt": "text"})
+    text = urlopen(f"{SEARCH_URL}?{query}", timeout)
+    for line in text.splitlines():
+        if line.startswith("%N "):
+            anum, _, name = line[3:].partition(" ")
+            return anum, name
+    if text.lstrip().startswith(_GREETING):
+        return None  # a well-formed answer with no sequence in it
+    raise ValueError("unrecognized response from oeis.org")
+
+
+def oeis(array, size=None, trim=False, quiet=False, timeout=10):
+    """
+    Search OEIS for the sequence in each row of an array.
+
+    Parameters
+    ----------
+    array : array_like, 1-D or 2-D
+        A 1-D array is searched as one sequence; a 2-D array row by row.
+    size : int
+        Number of rows to search (2-D only). Default: all rows.
+    trim : bool
+        If True, trim zeros from the start and end of each row first (useful
+        for the rows of `as_tri`).
+    quiet : bool
+        If False (the default), print one line per row and return None, as
+        the notebook did. If True, print nothing and return the results.
+    timeout : float
+        Seconds to wait for each answer from oeis.org.
+
+    Returns
+    -------
+    None, or (with quiet=True) a list with one entry per row searched (one
+    entry for 1-D input): (A-number, name) for the best match, or None if
+    OEIS has no match.
+
+    Raises
+    ------
+    With quiet=True only: OSError (including urllib.error.URLError and
+    TimeoutError) if oeis.org cannot be reached, ValueError if its answer is
+    not in the expected format. When printing, these are reported on the
+    row's line as "lookup failed (...)" instead.
+
+    Notes
+    -----
+    Each row is a separate request to oeis.org, which needs a network
+    connection. Please search a few rows at a time.
+    """
+    array = np.asarray(array)
+    if array.ndim == 1:
+        rows, labels = [array], [None]
+    elif array.ndim == 2:
+        n = len(array) if size is None else size
+        rows, labels = list(array[:n]), list(range(n))
+    else:
+        raise ValueError(f"oeis takes a 1-D or 2-D array, not {array.ndim}-D")
+
+    if not quiet:
+        print("OEIS Search Results")
+        print("===================")
+
+    results = []
+    for row, label in zip(rows, labels):
+        sequence = np.trim_zeros(row) if trim else row
+        if quiet:
+            results.append(_lookup(sequence, timeout))
+            continue
+        prefix = "" if label is None else f"row {label}: "
+        try:
+            match = _lookup(sequence, timeout)
+        except (OSError, ValueError) as err:
+            print(f"{prefix}lookup failed ({err})")
+            continue
+        if match is None:
+            print(f"{prefix}no match")
+        else:
+            print(f"{prefix}https://oeis.org/{match[0]} {match[1]}")
+    return results if quiet else None

ndplex-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,7 @@
+ndplex/__init__.py,sha256=fJBOCDLp99Qlv6646z8ZIqe6mO39k1rIeTazXdnHy3Y,1480
+ndplex/_core.py,sha256=1BFjIPM-KgUJqUe7aflM6Vstbo3yBdPra0BCGsL7Kv0,17046
+ndplex/_oeis.py,sha256=kOV2k2GQ5RkpnXkw57of7qpG2wlxe1g4f9P7-74IXM8,4338
+ndplex-0.1.0.dist-info/METADATA,sha256=Fw5mKK57R0oRyZERuZFhtkLSPQg3RcsKT5ix378umZs,8010
+ndplex-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+ndplex-0.1.0.dist-info/licenses/LICENSE,sha256=SKsS0t2kxvXf8LvmoW2kQ0v5dMW19CQUe_l1vgx01r0,1066
+ndplex-0.1.0.dist-info/RECORD,,

ndplex-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ndplex-0.1.0.dist-info/licenses/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.