fpy2 0.0.2__tar.gz → 0.0.4__tar.gz

fpy2-0.0.4/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: fpy2
+Version: 0.0.4
+Summary: An embedded DSL for numerical computing
+Author-email: Brett Saiki <bsaiki@cs.washington.edu>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bksaiki/fpy
+Project-URL: Issues, https://github.com/bksaiki/fpy/issues
+Project-URL: Documentation, https://fpy.readthedocs.io/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: titanfp==0.1.1
+Requires-Dist: gmpy2==2.2
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Dynamic: license-file
+
+# FPy
+
+An embedded Python DSL for specifying and simulating numerical algorithms.
+
+Important links:
+ - PyPI package: [fpy2](https://pypi.org/project/fpy2/)
+ - Documentation: [fpy.readthedocs.io](https://fpy.readthedocs.io/)
+ - GitHub: [fpy](https://github.com/bksaiki/fpy)
+
+## Installation
+
+Requirements:
+ - Python 3.11 or later
+
+The following instructions assume a `bash`-like shell.
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+
+To install a _frozen_ instance of FPy, run:
+```bash
+pip install .
+```
+or with `make`, run
+```bash
+make install
+```
+Note that this will not install the necessary dependencies for
+development and installs a copy of the `fpy2` package.
+If you checkout a different commit or branch, you will
+need to reinstall FPy to overwrite the previous version.
+
+To uninstall FPy, run:
+```bash
+pip uninstall fpy2
+```
+
+## Development
+
+Developers of FPy should read this section since
+installing FPy is actually different.
+
+Requirements:
+ - Python 3.11 or later
+ - `make`
+
+### Installation
+
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+To install an instance of FPy for development, run:
+```bash
+pip install -e .[dev]
+```
+or with `make`, run
+```bash
+make install-dev
+```
+
+### Testing
+
+There are a number of tests that can be run through
+the `Makefile` including
+```bash
+make lint
+```
+to ensure formatting and type safety;
+```bash
+make unittest
+```
+to run the unit tests;
+```bash
+make infratest
+```
+to run the infrastructure tests.

fpy2-0.0.4/README.md

@@ -0,0 +1,88 @@
+# FPy
+
+An embedded Python DSL for specifying and simulating numerical algorithms.
+
+Important links:
+ - PyPI package: [fpy2](https://pypi.org/project/fpy2/)
+ - Documentation: [fpy.readthedocs.io](https://fpy.readthedocs.io/)
+ - GitHub: [fpy](https://github.com/bksaiki/fpy)
+
+## Installation
+
+Requirements:
+ - Python 3.11 or later
+
+The following instructions assume a `bash`-like shell.
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+
+To install a _frozen_ instance of FPy, run:
+```bash
+pip install .
+```
+or with `make`, run
+```bash
+make install
+```
+Note that this will not install the necessary dependencies for
+development and installs a copy of the `fpy2` package.
+If you checkout a different commit or branch, you will
+need to reinstall FPy to overwrite the previous version.
+
+To uninstall FPy, run:
+```bash
+pip uninstall fpy2
+```
+
+## Development
+
+Developers of FPy should read this section since
+installing FPy is actually different.
+
+Requirements:
+ - Python 3.11 or later
+ - `make`
+
+### Installation
+
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+To install an instance of FPy for development, run:
+```bash
+pip install -e .[dev]
+```
+or with `make`, run
+```bash
+make install-dev
+```
+
+### Testing
+
+There are a number of tests that can be run through
+the `Makefile` including
+```bash
+make lint
+```
+to ensure formatting and type safety;
+```bash
+make unittest
+```
+to run the unit tests;
+```bash
+make infratest
+```
+to run the infrastructure tests.

fpy2-0.0.4/fpy2/__init__.py

@@ -0,0 +1,113 @@
+"""
+FPy is a library for simulating numerical programs
+with many different number systems.
+
+It provides an embedded DSL for specifying programs via its `@fpy` decorator.
+The language has a runtime that can simulate programs
+under different number systems and compilers to other languages.
+
+The numbers library supports many different number types including:
+
+ - multiprecision floating point (`MPFloatContext`)
+ - multiprecision floatingpoint with subnormalization (`MPSFloatContext`)
+ - bounded, multiprecision floating point (`MPBFloatContext`)
+ - IEEE 754 floating point (`IEEEContext`)
+
+These number systems guarantee correct rounding via MPFR.
+"""
+
+from .number import (
+    # number types
+    Float,
+    RealFloat,
+    # abstract context types
+    Context,
+    OrdinalContext,
+    SizedContext,
+    EncodableContext,
+    # concrete context types
+    ExtFloatContext,
+    FixedContext,
+    MPFixedContext,
+    MPFloatContext,
+    MPBFixedContext,
+    MPBFloatContext,
+    MPSFloatContext,
+    IEEEContext,
+    RealContext,
+    # rounding utilities
+    RoundingMode,
+    RoundingDirection, RM,
+    # encoding utilities
+    ExtFloatNanKind,
+    FixedOverflowKind, OF,
+    # type aliases
+    FP256, FP128, FP64, FP32, FP16,
+    TF32, BF16,
+    S1E5M2, S1E4M3,
+    MX_E5M2, MX_E4M3, MX_E3M2, MX_E2M3, MX_E2M1,
+    FP8P1, FP8P2, FP8P3, FP8P4, FP8P5, FP8P6, FP8P7,
+    INTEGER,
+    SINT8, SINT16, SINT32, SINT64,
+    UINT8, UINT16, UINT32, UINT64
+)
+
+from .fpc_context import FPCoreContext, NoSuchContextError
+
+from .decorator import fpy, pattern, fpy_prim
+
+from .backend import (
+    Backend,
+    FPCoreCompiler
+)
+
+from .interpret import (
+    Interpreter,
+    PythonInterpreter,
+    DefaultInterpreter,
+    set_default_interpreter,
+    get_default_interpreter,
+)
+
+from .function import Function
+from .env import ForeignEnv
+
+from .utils import (
+    fraction,
+    digits_to_fraction as digits,
+    decnum_to_fraction as decnum,
+    hexnum_to_fraction as hexnum,
+)
+
+###########################################################
+# Re-exports
+
+from titanfp.titanic.ndarray import NDArray
+
+###########################################################
+# typing hints
+
+import typing
+
+from typing import Literal as Dim
+
+_Dims = typing.TypeVarTuple('_Dims')
+_DType = typing.TypeVar('_DType')
+
+class Tensor(tuple, typing.Generic[*_Dims, _DType]):
+    """
+    FPy type hint for a homogenous tensor object::
+
+        from fpy2 import Tensor, Real
+        from typing import TypeAlias
+
+        MatrixN: TypeAlias = Tensor[Literal['N', 'N'], Real]
+        Matrix3: TypeAlias = Tensor[Literal[3, 3], Real]
+
+    Tensors have fixed or symbolic sizes and a uniform scalar data type.
+
+    Values of this type should not be constructed directly.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

fpy2-0.0.4/fpy2/analysis/__init__.py

@@ -0,0 +1,5 @@
+"""Program analyses for FPy programs"""
+
+from .define_use import DefineUse, DefineUseAnalysis, Definition, DefinitionCtx
+from .live_vars import LiveVars
+from .syntax_check import SyntaxCheck

fpy2-0.0.4/fpy2/analysis/define_use.py

@@ -0,0 +1,227 @@
+"""Definition use analysis for FPy ASTs"""
+
+from dataclasses import dataclass
+from typing import TypeAlias, Union
+
+from ..ast.fpyast import *
+from ..ast.visitor import DefaultVisitor
+from ..utils import default_repr
+
+Definition: TypeAlias = Argument | Stmt | CompExpr
+
+@default_repr
+class _DefineUnion:
+    """Union of possible definition sites."""
+    defs: set[Definition]
+
+    def __init__(self, defs: set[Definition]):
+        self.defs = set(defs)
+
+    def __eq__(self, other):
+        if not isinstance(other, _DefineUnion):
+            return NotImplemented
+        return self.defs == other.defs
+
+    def __hash__(self):
+        return hash(tuple(self.defs))
+
+    @staticmethod
+    def union(*defs_or_unions: Union[Definition, '_DefineUnion']):
+        """Create a union of definitions from a set of definitions or unions."""
+        defs: set[Definition] = set()
+        for item in defs_or_unions:
+            if isinstance(item, _DefineUnion):
+                defs.update(item.defs)
+            else:
+                defs.add(item)
+
+        if len(defs) == 0:
+            raise ValueError('Cannot create a union of an empty set of definitions')
+        elif len(defs) == 1:
+            return defs.pop()
+        else:
+            return _DefineUnion(defs)
+
+class DefinitionCtx(dict[NamedId, Definition | _DefineUnion]):
+    """Mapping from variable to its definition (or possible definitions)."""
+
+    def copy(self) -> 'DefinitionCtx':
+        """Returns a shallow copy of the context."""
+        return DefinitionCtx(self)
+
+    def mutated_in(self, other: 'DefinitionCtx') -> list[NamedId]:
+        """
+        Returns the set of variables that are defined in `self`
+        and mutated in `other`.
+        """
+        names: set[NamedId] = set()
+        for name in self.keys() & other.keys():
+            if self[name] != other[name]:
+                names.add(name)
+        return list(names)
+
+    def fresh_in(self, other: 'DefinitionCtx') -> set[NamedId]:
+        """
+        Returns the set of variables that are defined in `other`
+        but not in `self`.
+        """
+        return set(other.keys() - self.keys())
+
+
+@dataclass
+class DefineUseAnalysis:
+    """Result of definition-use analysis"""
+    defs: dict[NamedId, set[Definition]]
+    uses: dict[Definition, set[Var | IndexedAssign]]
+    stmts: dict[Stmt, tuple[DefinitionCtx, DefinitionCtx]]
+    blocks: dict[StmtBlock, tuple[DefinitionCtx, DefinitionCtx]]
+
+    @staticmethod
+    def default():
+        """Default analysis with empty definitions and uses"""
+        return DefineUseAnalysis({}, {}, {}, {})
+
+    @property
+    def names(self) -> set[NamedId]:
+        """Returns the set of all variable names in the analysis"""
+        return set(self.defs.keys())
+
+
+class _DefineUseInstance(DefaultVisitor):
+    """Per-IR instance of definition-use analysis"""
+    ast: FuncDef | StmtBlock
+    analysis: DefineUseAnalysis
+
+    def __init__(self, ast: FuncDef | StmtBlock):
+        self.ast = ast
+        self.analysis = DefineUseAnalysis.default()
+
+    def analyze(self):
+        match self.ast:
+            case FuncDef():
+                self._visit_function(self.ast, DefinitionCtx())
+            case StmtBlock():
+                self._visit_block(self.ast, DefinitionCtx())
+            case _:
+                raise RuntimeError(f'unreachable case: {self.ast}')
+        return self.analysis
+
+    def _add_def(self, name: NamedId, definition: Definition):
+        if name not in self.analysis.defs:
+            self.analysis.defs[name] = set()
+        self.analysis.defs[name].add(definition)
+        self.analysis.uses[definition] = set()
+
+    def _add_use(self, name: NamedId, use: Var | IndexedAssign, ctx: DefinitionCtx):
+        def_or_union = ctx[name]
+        if isinstance(def_or_union, _DefineUnion):
+            for def_ in def_or_union.defs:
+                self.analysis.uses[def_].add(use)
+        else:
+            self.analysis.uses[def_or_union].add(use)
+
+    def _visit_var(self, e: Var, ctx: DefinitionCtx):
+        if e.name not in ctx:
+            raise NotImplementedError(f'undefined variable {e.name}')
+        self._add_use(e.name, e, ctx)
+
+    def _visit_comp_expr(self, e: CompExpr, ctx: DefinitionCtx):
+        for iterable in e.iterables:
+            self._visit_expr(iterable, ctx)
+        ctx = ctx.copy()
+        for target in e.targets:
+            for name in target.names():
+                self._add_def(name, e)
+                ctx[name] = e
+        self._visit_expr(e.elt, ctx)
+
+    def _visit_assign(self, stmt: Assign, ctx: DefinitionCtx):
+        self._visit_expr(stmt.expr, ctx)
+        for var in stmt.binding.names():
+            self._add_def(var, stmt)
+            ctx[var] = stmt
+
+    def _visit_indexed_assign(self, stmt: IndexedAssign, ctx: DefinitionCtx):
+        self._add_use(stmt.var, stmt, ctx)
+        for slice in stmt.slices:
+            self._visit_expr(slice, ctx)
+        self._visit_expr(stmt.expr, ctx)
+
+    def _visit_if1(self, stmt: If1Stmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.cond, ctx)
+        body_ctx = self._visit_block(stmt.body, ctx.copy())
+        # merge contexts along both paths
+        # definitions cannot be introduced in the body
+        for var in ctx:
+            ctx[var] = _DefineUnion.union(ctx[var], body_ctx[var])
+
+    def _visit_if(self, stmt: IfStmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.cond, ctx)
+        ift_ctx = self._visit_block(stmt.ift, ctx.copy())
+        iff_ctx = self._visit_block(stmt.iff, ctx.copy())
+        # merge contexts along both paths
+        for var in ift_ctx.keys() & iff_ctx.keys():
+            ctx[var] = _DefineUnion.union(ift_ctx[var], iff_ctx[var])
+
+    def _visit_while(self, stmt: WhileStmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.cond, ctx)
+        body_ctx = self._visit_block(stmt.body, ctx.copy())
+        # merge contexts along both paths
+        # definitions cannot be introduced in the body
+        for var in ctx:
+            ctx[var] = _DefineUnion.union(ctx[var], body_ctx[var])
+
+    def _visit_for(self, stmt: ForStmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.iterable, ctx)
+        body_ctx = ctx.copy()
+        match stmt.target:
+            case NamedId():
+                self._add_def(stmt.target, stmt)
+                body_ctx[stmt.target] = stmt
+            case TupleBinding():
+                for var in stmt.target.names():
+                    self._add_def(var, stmt)
+                    body_ctx[var] = stmt
+
+        body_ctx = self._visit_block(stmt.body, body_ctx)
+        # merge contexts along both paths
+        # definitions cannot be introduced in the body
+        for var in ctx:
+            ctx[var] = _DefineUnion.union(ctx[var], body_ctx[var])
+
+    def _visit_statement(self, stmt: Stmt, ctx: DefinitionCtx):
+        ctx_in = ctx.copy()
+        super()._visit_statement(stmt, ctx)
+        self.analysis.stmts[stmt] = (ctx_in, ctx.copy())
+
+    def _visit_block(self, block: StmtBlock, ctx: DefinitionCtx):
+        ctx_in = ctx.copy()
+        for stmt in block.stmts:
+            self._visit_statement(stmt, ctx)
+        self.analysis.blocks[block] = (ctx_in, ctx.copy())
+        return ctx
+
+    def _visit_function(self, func: FuncDef, ctx: DefinitionCtx):
+        for arg in func.args:
+            if isinstance(arg.name, NamedId):
+                self._add_def(arg.name, arg)
+                ctx[arg.name] = arg
+        self._visit_block(func.body, ctx.copy())
+
+
+class DefineUse:
+    """
+    Definition-use analyzer for the FPy IR.
+
+    Computes definition-use chains for each variable.
+
+    name ---> definition ---> use1, use2, ...
+         ---> definition ---> use1, use2, ...
+         ...
+    """
+
+    @staticmethod
+    def analyze(ast: FuncDef | StmtBlock):
+        if not isinstance(ast, FuncDef | StmtBlock):
+            raise TypeError(f'Expected \'FuncDef\' or \'StmtBlock\', got {type(ast)} for {ast}')
+        return _DefineUseInstance(ast).analyze()