hypercomplex-engine 0.0.4__py3-none-any.whl

hypercomplex/printer/cd_format.py

@@ -0,0 +1,209 @@
+try:
+    from ..core import BasisNotation
+except ImportError:
+    try:
+        from ..core.Basis_notation import BasisNotation
+    except ImportError:
+        from ..core.basis_notation import BasisNotation
+
+
+class CDFormat:
+    """
+    Formatting engine for hypercomplex elements.
+
+    This class handles all string formatting for:
+        - Single basis elements (from holo / O1 multipliers)
+        - Table cells (from table builders)
+        - Row/column labels
+
+    It does NOT handle printing or file IO.
+    """
+
+    VALID_MODES = {
+        "integer",
+        "graded",
+        "latex",
+        "latex_integer",
+        "latex_graded",
+    }
+
+    # ==================================================================
+    # MODE HELPERS
+    # ==================================================================
+
+    @classmethod
+    def validate_mode(cls, mode: str) -> None:
+        if mode not in cls.VALID_MODES:
+            raise ValueError(
+                f"Invalid mode '{mode}'. "
+                f"Valid modes: {sorted(cls.VALID_MODES)}"
+            )
+
+    @staticmethod
+    def is_latex(mode: str) -> bool:
+        return mode.startswith("latex")
+
+    # ==================================================================
+    # CORE FORMATTING
+    # ==================================================================
+
+    @classmethod
+    def format_basis(cls, index: int, mode: str) -> str:
+        """
+        Format only the basis element.
+
+        integer:        e0, e1, e2, ...
+        graded:         1, o1, o2, o12, ...
+        latex_integer:  e_{0}, e_{1}, ...
+        latex_graded:   1, o_{1}, o_{2}, o_{12}, ...
+        """
+        cls.validate_mode(mode)
+        index = int(index)
+
+        if mode == "integer":
+            return f"e{index}"
+
+        if mode == "graded":
+            return BasisNotation.to_graded_str(index)
+
+        if mode == "latex":
+            return BasisNotation.to_latex(index, mode="integer")
+
+        if mode == "latex_integer":
+            return BasisNotation.to_latex(index, mode="integer")
+
+        if mode == "latex_graded":
+            return BasisNotation.to_latex(index, mode="graded")
+
+        raise ValueError(f"Invalid mode '{mode}'")
+
+    @classmethod
+    def format_entry(
+        cls,
+        sign: int,
+        index: int,
+        eps: int = 0,
+        mode: str = "integer",
+    ) -> str:
+        """
+        Format a single element from its components.
+
+        This is the low-level formatter used by both
+        format_element and the table printer.
+        """
+        cls.validate_mode(mode)
+
+        sign = int(sign)
+        index = int(index)
+        eps = int(eps)
+
+        if sign == 0:
+            return "0"
+
+        prefix = "+" if sign > 0 else "-"
+        base = cls.format_basis(index, mode)
+
+        if eps == 0:
+            return prefix + base
+
+        latex = cls.is_latex(mode)
+        eps_label = "\\epsilon" if latex else "eps"
+
+        # epsilon alone: +eps or +\epsilon
+        if index == 0:
+            return prefix + eps_label
+
+        if latex:
+            return f"{prefix}{base}{eps_label}"
+
+        return f"{prefix}{base}*{eps_label}"
+
+    # ==================================================================
+    # SINGLE ELEMENT FORMATTING (for holo / O1 output)
+    # ==================================================================
+
+    @classmethod
+    def format_element(cls, element: tuple, mode: str = "integer") -> str:
+        """
+        Format a basis element tuple returned by holo or O1 multipliers.
+
+        Parameters
+        ----------
+        element : tuple
+            (sign, index)        for standard / split
+            (sign, index, eps)   for dual
+
+        mode : str
+            integer, graded, latex, latex_integer, latex_graded
+
+        Returns
+        -------
+        str
+            Formatted string.
+
+        Examples
+        --------
+        >>> CDFormat.format_element((1, 3), mode="integer")
+        '+e3'
+
+        >>> CDFormat.format_element((-1, 5), mode="graded")
+        '-o13'
+
+        >>> CDFormat.format_element((1, 2, 1), mode="integer")
+        '+e2*eps'
+
+        >>> CDFormat.format_element((0, 0, 1), mode="integer")
+        '0'
+        """
+        if not isinstance(element, tuple):
+            raise TypeError(f"element must be a tuple, got {type(element).__name__}")
+
+        if len(element) == 2:
+            sign, index = element
+            return cls.format_entry(sign, index, eps=0, mode=mode)
+
+        if len(element) == 3:
+            sign, index, eps = element
+            return cls.format_entry(sign, index, eps=eps, mode=mode)
+
+        raise ValueError(
+            f"element must be a 2-tuple or 3-tuple, got {len(element)}-tuple"
+        )
+
+    # ==================================================================
+    # TABLE LABELS
+    # ==================================================================
+
+    @classmethod
+    def basis_labels(cls, dim: int, dual: bool, mode: str) -> list:
+        """
+        Build row/column labels for a multiplication table.
+        """
+        cls.validate_mode(mode)
+
+        base_dim = dim // 2 if dual else dim
+
+        labels = [
+            cls.format_basis(i, mode)
+            for i in range(base_dim)
+        ]
+
+        if not dual:
+            return labels
+
+        latex = cls.is_latex(mode)
+        eps_label = "\\epsilon" if latex else "eps"
+
+        # epsilon itself: eps*e0
+        labels.append(eps_label)
+
+        # epsilon times non-scalar basis elements
+        for i in range(1, base_dim):
+            base = cls.format_basis(i, mode)
+
+            if latex:
+                labels.append(f"{base}{eps_label}")
+            else:
+                labels.append(f"{base}*{eps_label}")
+
+        return labels

hypercomplex/printer/cd_table_printer.py

@@ -0,0 +1,204 @@
+from .cd_format import CDFormat
+
+
+class CDTablePrinter:
+    """
+    Printer / CSV exporter for hypercomplex multiplication tables.
+
+    This class handles only:
+        - terminal printing
+        - CSV export
+
+    All formatting is delegated to CDFormat.
+    """
+
+    @staticmethod
+    def print_table(
+        signs,
+        indices,
+        eps=None,
+        title: str | None = None,
+        limit: int | None = None,
+        mode: str = "integer",
+    ):
+        """
+        Print a multiplication table to the terminal.
+
+        Parameters
+        ----------
+        signs:
+            2D array of signs.
+
+        indices:
+            2D array of basis indices.
+
+        eps:
+            Optional 2D array for dual tables.
+            If provided, the table is treated as dual.
+
+        title:
+            Optional title.
+
+        limit:
+            Optional maximum number of rows/columns to display.
+
+        mode:
+            integer, graded, latex, latex_integer, latex_graded
+        """
+        CDFormat.validate_mode(mode)
+
+        dim = signs.shape[0]
+        lim = dim if limit is None else min(limit, dim)
+
+        if lim == 0:
+            return []
+
+        dual = eps is not None
+
+        labels = CDFormat.basis_labels(
+            dim,
+            dual=dual,
+            mode=mode,
+        )[:lim]
+
+        rows = []
+
+        for i in range(lim):
+            row = []
+
+            for j in range(lim):
+                e = 0 if eps is None else int(eps[i, j])
+
+                row.append(
+                    CDFormat.format_entry(
+                        int(signs[i, j]),
+                        int(indices[i, j]),
+                        e,
+                        mode,
+                    )
+                )
+
+            rows.append(row)
+
+        if title is None:
+            title = "Dual Table" if dual else "Table"
+
+        print(title)
+
+        cell_width = max(len(cell) for row in rows for cell in row)
+        label_width = max(len(label) for label in labels)
+
+        # Header
+        print(
+            " " * (label_width + 3)
+            + " ".join(f"{label:>{cell_width}}" for label in labels)
+        )
+
+        # Rows
+        for label, row in zip(labels, rows):
+            print(
+                f"{label:>{label_width}} | "
+                + " ".join(f"{cell:>{cell_width}}" for cell in row)
+            )
+
+        print()
+
+        return rows
+
+    @staticmethod
+    def export_csv(
+        path: str,
+        signs,
+        indices,
+        eps=None,
+        mode: str = "integer",
+        csv_mode: str = "matrix",
+    ) -> str:
+        """
+        Export table to CSV.
+
+        Parameters
+        ----------
+        path:
+            Output file path.
+
+        signs:
+            2D sign array.
+
+        indices:
+            2D index array.
+
+        eps:
+            Optional epsilon array for dual tables.
+
+        mode:
+            integer, graded, latex, latex_integer, latex_graded
+
+        csv_mode:
+            "matrix":
+                Spreadsheet-style grid.
+
+            "long":
+                One row per product:
+                    i,j,sign,index[,eps]
+        """
+        CDFormat.validate_mode(mode)
+
+        if csv_mode not in ("matrix", "long"):
+            raise ValueError("csv_mode must be 'matrix' or 'long'")
+
+        dim = signs.shape[0]
+        dual = eps is not None
+
+        with open(path, "w", newline="", encoding="utf-8") as f:
+
+            if csv_mode == "matrix":
+                labels = CDFormat.basis_labels(
+                    dim,
+                    dual=dual,
+                    mode=mode,
+                )
+
+                # Header row
+                f.write("," + ",".join(labels) + "\n")
+
+                for i in range(dim):
+                    cells = []
+
+                    for j in range(dim):
+                        e = 0 if eps is None else int(eps[i, j])
+
+                        cells.append(
+                            CDFormat.format_entry(
+                                int(signs[i, j]),
+                                int(indices[i, j]),
+                                e,
+                                mode,
+                            )
+                        )
+
+                    f.write(labels[i] + "," + ",".join(cells) + "\n")
+
+            else:
+                header = "i,j,sign,index"
+
+                if dual:
+                    header += ",eps"
+
+                f.write(header + "\n")
+
+                for i in range(dim):
+                    for j in range(dim):
+                        line = (
+                            f"{i},"
+                            f"{j},"
+                            f"{int(signs[i, j])},"
+                            f"{int(indices[i, j])}"
+                        )
+
+                        if dual:
+                            line += f",{int(eps[i, j])}"
+
+                        f.write(line + "\n")
+
+        return path