jjinx 0.0.1__py3-none-any.whl

jinx/execution/numpy/adverbs.py

@@ -0,0 +1,334 @@
+"""Methods implementing J adverbs."""
+
+import dataclasses
+import functools
+from typing import Callable
+
+import numpy as np
+from jinx.errors import DomainError, JinxNotImplementedError, LengthError, ValenceError
+from jinx.execution.numpy.application import _apply_dyad, _apply_monad
+from jinx.execution.numpy.helpers import (
+    get_fill_value,
+    is_box,
+    is_ufunc,
+    maybe_pad_with_fill_value,
+    maybe_parenthesise_verb_spelling,
+)
+from jinx.vocabulary import Dyad, Monad, Verb
+
+INFINITY = float("inf")
+
+
+def slash_adverb(verb: Verb[np.ndarray]) -> Verb[np.ndarray]:
+    if verb.dyad is None or verb.dyad.function is None:
+        # Note: this differs from J which still allows the adverb to be applied
+        # to a verb, but may raise an error when the new verb is applied to a noun
+        # and the verb has no dyadic valence.
+        raise ValenceError(f"Verb {verb.spelling} has no dyadic valence.")
+
+    if is_ufunc(verb.dyad.function) and verb.dyad.is_commutative:
+        f: np.ufunc = verb.dyad.function  # type: ignore[assignment]
+        monad = f.reduce
+        dyad = f.outer
+
+    else:
+        # Slow path: dyad is not a ufunc.
+        # The function is either callable, in which cases it is applied directly,
+        # or a Verb object that needs to be applied indirectly with _apply_dyad().
+        if isinstance(verb.dyad.function, Verb):
+            func = functools.partial(_apply_dyad, verb)  # type: ignore[assignment]
+        else:
+            func = verb.dyad.function  # type: ignore[assignment]
+
+        def _dyad_arg_swap(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+            return func(y, x)
+
+        def _reduce(y: np.ndarray) -> np.ndarray:
+            y = np.atleast_1d(y)
+            y = np.flip(y, axis=0)
+            return functools.reduce(_dyad_arg_swap, y)
+
+        def _outer(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+            # We have already checked that verb.dyad is not None, so this is safe.
+            verb_slash = _modify_rank(verb, np.array([verb.dyad.left_rank, INFINITY]))  # type: ignore[union-attr]
+            return _apply_dyad(verb_slash, x, y)
+
+        monad = _reduce
+        dyad = _outer
+
+    spelling = maybe_parenthesise_verb_spelling(verb.spelling)
+    spelling = f"{verb.spelling}/"
+
+    return Verb[np.ndarray](
+        name=spelling,
+        spelling=spelling,
+        monad=Monad(name=spelling, rank=INFINITY, function=monad),
+        dyad=Dyad(
+            name=spelling, left_rank=INFINITY, right_rank=INFINITY, function=dyad
+        ),
+    )
+
+
+def bslash_adverb(verb: Verb[np.ndarray]) -> Verb[np.ndarray]:
+    # Common cases that have a straightforward optimisation.
+    SPECIAL_MONAD = {
+        "+/": np.add.accumulate,
+        "*/": np.multiply.accumulate,
+        "<./": np.minimum.accumulate,
+        ">./": np.maximum.accumulate,
+    }
+
+    if verb.spelling in SPECIAL_MONAD:
+        monad_ = SPECIAL_MONAD[verb.spelling]
+
+    else:
+
+        def monad_(y: np.ndarray) -> np.ndarray:  # type: ignore[misc]
+            y = np.atleast_1d(y)
+            result = []
+            for i in range(1, len(y) + 1):
+                result.append(_apply_monad(verb, y[:i]))
+            result = maybe_pad_with_fill_value(result, fill_value=get_fill_value(y))
+            return np.asarray(result)
+
+    def dyad_(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+        if not np.issubdtype(x.dtype, np.integer):
+            raise DomainError(f"x has nonintegral value ({x})")
+        y = np.atleast_1d(y)
+        if x == 0:
+            return np.zeros(len(y) + 1, dtype=np.int64)
+        if x == 1 or x == -1:
+            windows = y
+        elif x > 0:
+            # Overlapping windows
+            windows = np.array([y[i : i + x] for i in range(len(y) - x + 1)])
+        else:
+            # Non-overlapping windows
+            windows = np.array([y[i : i - x] for i in range(0, len(y), -x)])
+
+        result = []
+        for window in windows:
+            result.append(_apply_monad(verb, window))
+        result = maybe_pad_with_fill_value(result, fill_value=get_fill_value(y))
+        return np.asarray(result)
+
+    spelling = maybe_parenthesise_verb_spelling(verb.spelling)
+    spelling = f"{spelling}\\"
+
+    return Verb(
+        name=spelling,
+        spelling=spelling,
+        monad=Monad(name=spelling, rank=INFINITY, function=monad_),
+        dyad=Dyad(name=spelling, left_rank=0, right_rank=INFINITY, function=dyad_),
+    )
+
+
+def bslashdot_adverb(verb: Verb[np.ndarray]) -> Verb[np.ndarray]:
+    SPECIAL_MONAD = {
+        "+/": lambda x: np.add.accumulate(x[::-1])[::-1],
+        "*/": lambda x: np.multiply.accumulate(x[::-1])[::-1],
+        "<./": lambda x: np.minimum.accumulate(x[::-1])[::-1],
+        ">./": lambda x: np.maximum.accumulate(x[::-1])[::-1],
+    }
+
+    if verb.spelling in SPECIAL_MONAD:
+        monad_ = SPECIAL_MONAD[verb.spelling]
+    else:
+
+        def monad_(y: np.ndarray) -> np.ndarray:
+            y = np.atleast_1d(y)
+            result = []
+            for i in range(len(y)):
+                result.append(_apply_monad(verb, y[i:]))
+            result = maybe_pad_with_fill_value(result, fill_value=get_fill_value(y))
+            return np.asarray(result)
+
+    def dyad_(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+        if not np.issubdtype(x.dtype, np.integer):
+            raise DomainError(f"x has nonintegral value ({x})")
+        y = np.atleast_1d(y)
+        if x == 0:
+            return y
+        elif x > 0:
+            # Overlapping windows
+            windows = [
+                np.concatenate([y[:i], y[i + x :]], axis=0)
+                for i in range(len(y) - x + 1)
+            ]
+        else:
+            # Non-overlapping windows
+            windows = [
+                np.concatenate([y[:i], y[i - x :]], axis=0)
+                for i in range(0, len(y), -x)
+            ]
+
+        result = []
+        for window in windows:
+            result.append(_apply_monad(verb, window))
+        result = maybe_pad_with_fill_value(result, fill_value=get_fill_value(y))
+        return np.asarray(result)
+
+    spelling = maybe_parenthesise_verb_spelling(verb.spelling)
+    spelling = f"{verb.spelling}\\."
+
+    return Verb(
+        name=spelling,
+        spelling=spelling,
+        monad=Monad(name=spelling, rank=INFINITY, function=monad_),
+        dyad=Dyad(name=spelling, left_rank=0, right_rank=INFINITY, function=dyad_),
+    )
+
+
+def tilde_adverb(verb: Verb[np.ndarray]) -> Verb[np.ndarray]:
+    if verb.dyad is None or verb.dyad.function is None:
+        # Note: this differs from J which still allows the adverb to be applied
+        # to a verb, but may raise an error when the new verb is applied to a noun
+        # and the verb has no dyadic valence.
+        raise ValenceError(f"Verb {verb.spelling} has no dyadic valence.")
+
+    def monad(y: np.ndarray) -> np.ndarray:
+        # replicate argument and apply verb dyadically
+        return _apply_dyad(verb, y, y)
+
+    def dyad(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+        # swap the arguments and apply verb dyadically
+        return _apply_dyad(verb, y, x)
+
+    spelling = maybe_parenthesise_verb_spelling(verb.spelling)
+    spelling = f"{verb.spelling}~"
+
+    return Verb[np.ndarray](
+        name=spelling,
+        spelling=spelling,
+        monad=Monad(name=spelling, rank=INFINITY, function=monad),
+        dyad=Dyad(
+            name=spelling,
+            left_rank=verb.dyad.right_rank,
+            right_rank=verb.dyad.left_rank,
+            function=dyad,
+        ),
+    )
+
+
+def _modify_rank(verb: Verb, rank: np.ndarray | int | float) -> Verb:
+    rank = np.atleast_1d(rank)
+    if np.issubdtype(rank.dtype, np.floating):
+        if not np.isinf(rank).any():
+            raise DomainError(f"Rank must be an integer or infinity, got {rank.dtype}")
+
+    elif not np.issubdtype(rank.dtype, np.integer):
+        raise DomainError(f"Rank must be an integer or infinity, got {rank.dtype}")
+
+    if rank.size > 3 or rank.ndim > 1:
+        raise DomainError(
+            f"Rank must be a scalar or 1D array of length <= 3, got {rank.ndim}D array with shape {rank.shape}"
+        )
+
+    rank_list = [int(r) if not np.isinf(r) else INFINITY for r in rank.tolist()]
+    verb_spelling = spelling = maybe_parenthesise_verb_spelling(verb.spelling)
+
+    if len(rank_list) == 1:
+        monad_rank = left_rank = right_rank = rank_list[0]
+        spelling = f'{verb_spelling}"{rank_list[0]}'
+
+    elif len(rank_list) == 2:
+        left_rank, right_rank = rank_list
+        monad_rank = right_rank
+        spelling = f'{verb_spelling}"{left_rank} {right_rank}'
+
+    else:
+        monad_rank, left_rank, right_rank = rank_list
+        spelling = f'{verb_spelling}"{monad_rank} {left_rank} {right_rank}'
+
+    if verb.monad:
+        monad = dataclasses.replace(verb.monad, rank=monad_rank, function=verb)
+    else:
+        monad = None
+
+    if verb.dyad:
+        dyad = dataclasses.replace(
+            verb.dyad,
+            left_rank=left_rank,
+            right_rank=right_rank,
+            function=verb,
+        )
+    else:
+        dyad = None
+
+    return dataclasses.replace(
+        verb,
+        spelling=spelling,
+        name=spelling,
+        monad=monad,
+        dyad=dyad,
+    )
+
+
+def slashdot_adverb(verb: Verb) -> Verb:
+    def monad(y: np.ndarray) -> np.ndarray:
+        y = np.atleast_1d(y)
+
+        if y.ndim == 1:
+            result = [_apply_monad(verb, item) for item in y]
+        elif y.ndim <= 3:
+            result = []
+            for offset in range(1 - y.shape[0], y.shape[1]):
+                item = np.diagonal(y[::-1], offset).T[::-1]
+                result.append(_apply_monad(verb, item))
+        else:
+            JinxNotImplementedError(
+                f"Monad {verb.spelling} dooes not yet support array rank > 3."
+            )
+
+        result = maybe_pad_with_fill_value(result, fill_value=get_fill_value(y))
+        return np.asarray(result)
+
+    def dyad(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+        x = np.atleast_1d(x)
+        y = np.atleast_1d(y)
+
+        if len(x) != len(y):
+            raise LengthError(
+                f"x and y must have the same length, got {len(x)} and {len(y)}"
+            )
+
+        item_indices: dict[bytes, list[int]] = {}
+
+        if is_box(x):
+            for i, x_item in enumerate(x):
+                item_indices.setdefault(x_item[0].tobytes(), []).append(i)
+
+        else:
+            for i, x_item in enumerate(x):
+                item_indices.setdefault(x_item.tobytes(), []).append(i)
+
+        result = []
+        for idx in item_indices.values():
+            result.append(_apply_monad(verb, y[idx]))
+
+        result = maybe_pad_with_fill_value(result, fill_value=get_fill_value(y))
+        return np.asarray(result)
+
+    spelling = maybe_parenthesise_verb_spelling(verb.spelling)
+    spelling = f"{verb.spelling}/."
+
+    return Verb(
+        name=spelling,
+        spelling=spelling,
+        monad=Monad(name=spelling, rank=INFINITY, function=monad),
+        dyad=Dyad(
+            name=spelling,
+            left_rank=INFINITY,
+            right_rank=INFINITY,
+            function=dyad,
+        ),
+    )
+
+
+ADVERB_MAP: dict[str, Callable[[Verb[np.ndarray]], Verb[np.ndarray]]] = {
+    "SLASH": slash_adverb,
+    "SLASHDOT": slashdot_adverb,
+    "BSLASH": bslash_adverb,
+    "BSLASHDOT": bslashdot_adverb,
+    "TILDE": tilde_adverb,
+}

jinx/execution/numpy/application.py

@@ -0,0 +1,343 @@
+"""Methods for applying verb implementations to nouns and verbs.
+
+Main references:
+* https://code.jsoftware.com/wiki/Vocabulary/Agreement
+* https://www.jsoftware.com/help/jforc/loopless_code_i_verbs_have_r.htm
+
+"""
+
+import functools
+from dataclasses import dataclass
+
+import numpy as np
+from jinx.errors import JinxNotImplementedError, LengthError, ValenceError
+from jinx.execution.numpy.conversion import ndarray_or_scalar_to_noun
+from jinx.execution.numpy.helpers import (
+    is_ufunc,
+    is_ufunc_based,
+    maybe_pad_with_fill_value,
+)
+from jinx.vocabulary import Adverb, Conjunction, Dyad, Monad, Noun, RankT, Verb
+
+
+def get_rank(verb_rank: RankT, noun_rank: int) -> int:
+    """Get the rank at which to apply the verb to the noun.
+
+    If the verb rank is negative, it means that the verb rank is subtracted
+    from the noun rank, to a minimum of 0.
+    """
+    if verb_rank < 0:
+        return max(0, noun_rank + verb_rank)  # type: ignore[return-value]
+    return min(verb_rank, noun_rank)  # type: ignore[return-value]
+
+
+def fill_and_assemble(
+    cells: list[np.ndarray], frame_shape: tuple[int, ...]
+) -> np.ndarray:
+    if not cells:
+        return np.asarray(cells).reshape(frame_shape)
+
+    cells = maybe_pad_with_fill_value(cells)
+    return np.asarray(cells).reshape(frame_shape + cells[0].shape)
+
+
+@dataclass
+class ArrayCells:
+    cell_shape: tuple[int, ...]
+    frame_shape: tuple[int, ...]
+    cells: np.ndarray
+
+
+def split_into_cells(arr: np.ndarray, rank: int) -> ArrayCells:
+    """
+    Look at the array shape and rank to determine frame and cell shape.
+
+    The trailing `rank` axes define the cell shape and the preceding
+    axes define the frame shape. E.g. for rank=2:
+
+      arr.shape = (n0, n1, n2, n3, n4)
+                   ----------  ------
+                   ^ frame     ^ cell
+
+    If rank=0, the frame shape is the same as the shape and the monad
+    applies to each atom of the array.
+    """
+    if arr.size == 0:
+        return ArrayCells(cell_shape=(), frame_shape=arr.shape, cells=arr)
+
+    if rank == 0:
+        return ArrayCells(cell_shape=(), frame_shape=arr.shape, cells=arr.ravel())
+
+    return ArrayCells(
+        cell_shape=arr.shape[-rank:],
+        frame_shape=arr.shape[:-rank],
+        cells=arr.reshape(-1, *arr.shape[-rank:]),
+    )
+
+
+def apply_monad(verb: Verb[np.ndarray], noun: Noun[np.ndarray]) -> Noun[np.ndarray]:
+    result = _apply_monad(verb, noun.implementation)
+    return ndarray_or_scalar_to_noun(result)
+
+
+def _apply_monad(verb: Verb[np.ndarray], arr: np.ndarray) -> np.ndarray:
+    if verb.monad is None or verb.monad.function is None:
+        raise ValenceError(f"Verb {verb.spelling} has no monadic valence.")
+    if verb.monad.function is NotImplemented:
+        raise JinxNotImplementedError(
+            f"Verb {verb.spelling} monad function is not yet implemented in Jinx."
+        )
+
+    if isinstance(verb.monad.function, Verb):
+        function = functools.partial(_apply_monad, verb.monad.function)
+    else:
+        function = verb.monad.function  # type: ignore[assignment]
+
+    if arr.size == 0:
+        return function(arr)
+
+    rank = get_rank(verb.monad.rank, arr.ndim)
+
+    # If the verb rank is 0 it applies to each atom of the array.
+    # NumPy's unary ufuncs are typically designed to work this way
+    # Apply the function directly here as an optimisation.
+    if rank == 0 and (is_ufunc(function) or is_ufunc_based(function)):
+        return function(arr)
+
+    array_cells = split_into_cells(arr, rank)
+    cells = [function(cell) for cell in array_cells.cells]
+    return fill_and_assemble(cells, array_cells.frame_shape)
+
+
+def apply_dyad(
+    verb: Verb[np.ndarray], noun_1: Noun[np.ndarray], noun_2: Noun[np.ndarray]
+) -> Noun[np.ndarray]:
+    result = _apply_dyad(verb, noun_1.implementation, noun_2.implementation)
+    return ndarray_or_scalar_to_noun(result)
+
+
+def _apply_dyad(
+    verb: Verb[np.ndarray], left_arr: np.ndarray, right_arr: np.ndarray
+) -> np.ndarray:
+    if verb.dyad is None or verb.dyad.function is None:
+        raise ValenceError(f"Verb {verb.spelling} has no dyadic valence.")
+    if verb.dyad.function is NotImplemented:
+        raise JinxNotImplementedError(
+            f"Verb {verb.spelling} dyad function is not yet implemented."
+        )
+
+    if isinstance(verb.dyad.function, Verb):
+        function = functools.partial(_apply_dyad, verb.dyad.function)
+    else:
+        function = verb.dyad.function  # type: ignore[assignment]
+
+    if left_arr.size == 0 or right_arr.size == 0:
+        return function(left_arr, right_arr)
+
+    left_rank = get_rank(verb.dyad.left_rank, left_arr.ndim)
+    right_rank = get_rank(verb.dyad.right_rank, right_arr.ndim)
+
+    # If the left and right ranks are both 0 and one of the arrays is a scalar,
+    # apply the dyad directly as an optimisation.
+    if (
+        left_rank == right_rank == 0
+        and (is_ufunc(function) or is_ufunc_based(function))
+        and (left_arr.ndim == 0 or right_arr.ndim == 0)
+    ):
+        return function(left_arr, right_arr)
+
+    left = split_into_cells(left_arr, left_rank)
+    right = split_into_cells(right_arr, right_rank)
+
+    # If the left and right frame shapes are the same, we can apply the dyad immediately.
+    if left.frame_shape == right.frame_shape:
+        cells = [
+            function(left_cell, right_cell)
+            for left_cell, right_cell in zip(left.cells, right.cells, strict=True)
+        ]
+        return fill_and_assemble(cells, left.frame_shape)
+
+    # Otherwise we need to find the common frame shape. One of the frame shapes must
+    # be a prefix of the other, otherwise it's not possible to apply the dyad.
+    common_frame_shape = find_common_frame_shape(left.frame_shape, right.frame_shape)
+    if common_frame_shape is None:
+        raise LengthError(
+            f"Cannot apply dyad {verb.spelling} to arrays of shape {left.frame_shape} and {right.frame_shape}"
+        )
+
+    rcf = len(common_frame_shape)
+
+    left_rcf_cell_shape = left_arr.shape[rcf:]
+    right_rcf_cell_shape = right_arr.shape[rcf:]
+
+    left_arr_reshaped = left_arr.reshape(-1, *left_rcf_cell_shape)
+    right_arr_reshaped = right_arr.reshape(-1, *right_rcf_cell_shape)
+
+    cells = []
+    for left_cell, right_cell in zip(
+        left_arr_reshaped, right_arr_reshaped, strict=True
+    ):
+        subcells = []
+        if common_frame_shape == left.frame_shape:
+            # right_cell is longer and contains multiple operand cells
+            if right_rank == 0:
+                right_subcells = right_cell.ravel()
+            else:
+                right_subcells = right_cell.reshape(-1, *right.cell_shape)
+
+            for right_subcell in right_subcells:
+                subcells.append(function(left_cell, right_subcell))
+        else:
+            # left_cell is longer and contains multiple operand cells
+            if left_rank == 0:
+                left_subcells = left_cell.ravel()
+            else:
+                left_subcells = left_cell.reshape(-1, *left.cell_shape)
+
+            for left_subcell in left_subcells:
+                subcells.append(function(left_subcell, right_cell))
+
+        subcells = maybe_pad_with_fill_value(subcells)
+        subarray = np.asarray(subcells)
+        if subarray.shape:
+            cells.extend(subcells)
+        else:
+            cells.append(subarray)
+
+    cells = maybe_pad_with_fill_value(cells)
+    array = np.asarray(cells)
+
+    # Gather the cells into the final frame shape (the longer of the left
+    # and right frame shapes, plus the result cell shape).
+    collecting_frame = max(left.frame_shape, right.frame_shape, key=len)
+    return array.reshape(collecting_frame + cells[0].shape)
+
+
+def find_common_frame_shape(
+    left_frame_shape: tuple[int, ...], right_frame_shape: tuple[int, ...]
+) -> tuple[int, ...] | None:
+    if len(left_frame_shape) <= len(right_frame_shape):
+        shorter = left_frame_shape
+        longer = right_frame_shape
+    else:
+        shorter = right_frame_shape
+        longer = left_frame_shape
+
+    if all(a == b for a, b in zip(shorter, longer)):
+        return shorter
+
+    return None
+
+
+def apply_conjunction(
+    verb_or_noun_1: Verb | Noun, conjunction: Conjunction, verb_or_noun_2: Verb | Noun
+) -> Verb | Noun:
+    return conjunction.function(verb_or_noun_1, verb_or_noun_2)
+
+
+def apply_adverb(verb_or_noun: Verb | Noun, adverb: Adverb) -> Verb:
+    return adverb.function(verb_or_noun)
+
+
+INFINITY = float("inf")
+
+
+def build_hook(f: Verb[np.ndarray], g: Verb[np.ndarray]) -> Verb[np.ndarray]:
+    """Build a hook given verbs f and g.
+
+      (f g) y  ->  y f (g y)
+    x (f g) y  ->  x f (g y)
+
+    The new verb has infinite rank.
+    """
+
+    def _monad(y: np.ndarray) -> np.ndarray:
+        a = _apply_monad(g, y)
+        return _apply_dyad(f, y, a)
+
+    def _dyad(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+        a = _apply_monad(g, y)
+        return _apply_dyad(f, x, a)
+
+    f_spelling = f"({f.spelling})" if " " in f.spelling else f.spelling
+    g_spelling = f"({g.spelling})" if " " in g.spelling else g.spelling
+    spelling = f"{f_spelling} {g_spelling}"
+
+    return Verb[np.ndarray](
+        spelling=spelling,
+        name=spelling,
+        monad=Monad(
+            name=spelling,
+            rank=INFINITY,
+            function=_monad,
+        ),
+        dyad=Dyad(
+            name=spelling,
+            left_rank=INFINITY,
+            right_rank=INFINITY,
+            function=_dyad,
+        ),
+    )
+
+
+def build_fork(
+    f: Verb[np.ndarray] | Noun[np.ndarray], g: Verb[np.ndarray], h: Verb[np.ndarray]
+) -> Verb[np.ndarray]:
+    """Build a fork given verbs f, g, h.
+
+      (f g h) y  ->    (f y) g   (h y)
+    x (f g h) y  ->  (x f y) g (x h y)
+
+    The new verb has infinite rank.
+
+    Note that f can be a noun, in which case there is one fewer function calls.
+    """
+
+    def _monad(y: np.ndarray) -> np.ndarray:
+        if isinstance(f, Verb) and f.spelling == "[:":
+            hy = _apply_monad(h, y)
+            return _apply_monad(g, hy)
+
+        if isinstance(f, Verb):
+            a = _apply_monad(f, y)
+        else:
+            a = f.implementation
+        b = _apply_monad(h, y)
+        return _apply_dyad(g, a, b)
+
+    def _dyad(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+        if isinstance(f, Verb) and f.spelling == "[:":
+            hy = _apply_dyad(h, x, y)
+            return _apply_monad(g, hy)
+
+        if isinstance(f, Verb):
+            a = _apply_dyad(f, x, y)
+        else:
+            a = f.implementation
+        b = _apply_dyad(h, x, y)
+        return _apply_dyad(g, a, b)
+
+    if isinstance(f, Verb):
+        f_spelling = f"({f.spelling})" if " " in f.spelling else f.spelling
+    else:
+        f_spelling = str(f.implementation)
+
+    g_spelling = f"({g.spelling})" if " " in g.spelling else g.spelling
+    h_spelling = f"({h.spelling})" if " " in h.spelling else h.spelling
+    spelling = f"{f_spelling} {g_spelling} {h_spelling}"
+
+    return Verb[np.ndarray](
+        spelling=spelling,
+        name=spelling,
+        monad=Monad(
+            name=spelling,
+            rank=INFINITY,
+            function=_monad,
+        ),
+        dyad=Dyad(
+            name=spelling,
+            left_rank=INFINITY,
+            right_rank=INFINITY,
+            function=_dyad,
+        ),
+    )