Floating point implementation refactoring:

* Define canonical `wire_struct` `Float` types, and use them as the source of
  truth for the number of exponent and mantissa bits. See `Float16` for an
  example. All operators are generic, and accept any of these `Float` types as
  input, and produce the same `Float` type as output. So if you add a `Float16`
  with a `Float16`, you get a `Float16`. If the operand types do not match, a
  `PyrtlError` is raised.

  This lets us remove `_fp_wire_struct`, `FPTypeProperties`,
  `FloatingPointType`, `PyrtlFloatConfig` because operands now carry their own
  metadata and describe themselves. For example, we can inspect the operand's
  mantissa bitwidth directly with `operand.mantissa.bitwidth`, rather than
  passing around another data structure.

* Remove the `FloatOperations` classes. They are no longer needed because the
  top-level `add`, `sub`, and `mul` functions are generic, and work with any
  matching `Float` types. The default rounding mode can be set with
  `set_default_rounding_mode`, and can be changed for individual operations.

* Rename the package from `pyrtlfloat` to just `float`. The full package name
  was `pyrtl.rtllib.pyrtlfloat`, which was redundant.

* Rename `mul` to `mult` for symmetry with `signed_mult`.

* Rename `make_inf` and friends to `make_inf_like`. These functions now take an
  operand that specifies the desired output bitwidths, similar to
  `np.ones_like`.

* Remove `make_zero`. It is clearer to directly set the exponent and mantissa
  to `0`.

* Use `dataclass` to simplify some class definitions.

* Use absolute imports (https://peps.python.org/pep-0008/#imports).

* Rename some variables to improve readability.

* Update `rtllib.rst` to generate Sphinx documentation for the `float` package.

Author: fdxmw

docs/rtllib.rst

@@ -23,6 +23,12 @@ Multipliers
 .. automodule:: pyrtl.rtllib.multipliers
    :members:
 
+Floating Point
+--------------
+
+.. automodule:: pyrtl.rtllib.float
+   :members:
+
 Barrel Shifter
 --------------
 

pyrtl/rtllib/float/__init__.py

@@ -0,0 +1,29 @@
+"""
+Add, subtract, and multiply floating point numbers.
+
+Several standard ``Float`` formats like :class:`Float16` and :class:`Float32` are
+predefined. Users may also define custom floating point formats.
+
+The main operators are :func:`add`, :func:`sub`, and :func:`mult`. These operators all
+accept and return one of these ``Float`` formats. Inputs to an operator must share
+the same ``Float`` format. The operator's output will be in the same ``Float`` format as
+its inputs.
+"""
+
+from .add_sub import add, sub
+from .mult import mult
+from .types import BFloat16, Float16, Float32, Float64, RoundingMode
+from .utils import get_default_rounding_mode, set_default_rounding_mode
+
+__all__ = [
+    "BFloat16",
+    "Float16",
+    "Float32",
+    "Float64",
+    "RoundingMode",
+    "add",
+    "get_default_rounding_mode",
+    "mult",
+    "sub",
+    "set_default_rounding_mode",
+]