paramrf 0.22.0__tar.gz → 0.23.2__tar.gz

{paramrf-0.22.0/paramrf.egg-info → paramrf-0.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramrf
-Version: 0.22.0
+Version: 0.23.2
 Summary: Parametric radio frequency modeling
 Author-email: Gary Allen <gvcallen@gmail.com>
 Project-URL: homepage, https://github.com/gvcallen/paramrf

{paramrf-0.22.0 → paramrf-0.23.2}/docs/api/index.rst

@@ -11,7 +11,7 @@ Core Primitives
 
    pmrf.Model
    pmrf.Frequency
-   pmrf.Value
+   pmrf.Variable
    pmrf.Param
    pmrf.Fixed
    pmrf.Bounded

{paramrf-0.22.0 → paramrf-0.23.2}/docs/examples/parameter_and_model_manipulation.rst

@@ -19,8 +19,8 @@ Let's first define a custom RLC composite model to manipulate:
 
   class RLC(prf.Model):
       res: Resistor = Resistor(R=100.0)
-      ind: Inductor = Inductor(L=prf.Value(2.0, scale=1e-9))
-      cap: Capacitor = Capacitor(C=prf.Value(1.0, scale=1e-12))
+      ind: Inductor = Inductor(L=prf.Variable(2.0, scale=1e-9))
+      cap: Capacitor = Capacitor(C=prf.Variable(1.0, scale=1e-12))
 
       def build(self) -> prf.Model:
           return self.res ** self.ind ** self.cap
@@ -48,7 +48,7 @@ Using :meth:`pmrf.Model.at`, we can traverse down the model tree to focus on spe
 
 .. code-block:: python
 
-  rlc_R200 = rlc.at(lambda m: m.res.R).set(prf.Value(200.0))
+  rlc_R200 = rlc.at(lambda m: m.res.R).set(prf.Variable(200.0))
   rlc_fixed = rlc.at(lambda m: m.cap.C).set(prf.Fixed(rlc.cap.C))
 
 Since a model's structure is not rigid, we can also completely swap out components:

{paramrf-0.22.0 → paramrf-0.23.2}/paper/paper.md

@@ -58,8 +58,8 @@ import pmrf as prf
 from pmrf.models import Resistor, Inductor, Capacitor
 
 res = Resistor(50)
-ind = Inductor(prf.Value(1.0, scale=1e-9))
-cap = Capacitor(prf.Value(1.0, scale=1e-12))
+ind = Inductor(prf.Variable(1.0, scale=1e-9))
+cap = Capacitor(prf.Variable(1.0, scale=1e-12))
 model = res ** ind ** cap
 
 goal = prf.evaluators.Goal('s11_db', '<', -20)

{paramrf-0.22.0 → paramrf-0.23.2/paramrf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramrf
-Version: 0.22.0
+Version: 0.23.2
 Summary: Parametric radio frequency modeling
 Author-email: Gary Allen <gvcallen@gmail.com>
 Project-URL: homepage, https://github.com/gvcallen/paramrf

{paramrf-0.22.0 → paramrf-0.23.2}/paramrf.egg-info/SOURCES.txt

@@ -85,13 +85,14 @@ pmrf/models/adapters/static.py
 pmrf/models/components/__init__.py
 pmrf/models/components/ideal.py
 pmrf/models/components/lumped.py
-pmrf/models/components/topological.py
+pmrf/models/components/sections.py
 pmrf/models/components/lines/__init__.py
 pmrf/models/components/lines/nonuniform.py
 pmrf/models/components/lines/uniform.py
 pmrf/models/composite/__init__.py
 pmrf/models/composite/interconnected.py
 pmrf/models/composite/nodal.py
+pmrf/models/composite/topological.py
 pmrf/models/composite/transformed.py
 pmrf/models/composite/wrapped.py
 pmrf/models/surrogates/__init__.py
@@ -107,9 +108,12 @@ pmrf/optimize/backends/optimistix.py
 pmrf/optimize/backends/scipy.py
 pmrf/rf/__init__.py
 pmrf/rf/cascades.py
-pmrf/rf/connections.py
 pmrf/rf/conversions.py
 pmrf/rf/terminations.py
+pmrf/rf/connections/__init__.py
+pmrf/rf/connections/s_arbitrary.py
+pmrf/rf/connections/s_common.py
+pmrf/rf/connections/y_arbitrary.py
 pmrf/solve/__init__.py
 pmrf/utils/__init__.py
 pmrf/utils/array.py

{paramrf-0.22.0 → paramrf-0.23.2}/pmrf/__init__.py

@@ -30,12 +30,12 @@ from pmrf.frequency import Frequency as Frequency
 
 #: The canonical type hint for a parameter in a model.
 #: Parameters should be created using factories in :mod:`pmrf.parameters`,
-#: most of which are re-exported at root (e.g. :func:`pmrf.Value`, :func:`pmrf.Fixed`, :func:`pmrf.Bounded`).
+#: most of which are re-exported at root (e.g. :func:`pmrf.Variable`, :func:`pmrf.Fixed`, :func:`pmrf.Bounded`).
 Param: TypeAlias = parax.AbstractVariable | Inexact[Array, "..."]
 from pmrf.parameters import (
     param as param,
     as_param as as_param,
-    Value as Value,
+    Variable as Variable,
     Fixed as Fixed,
     Bounded as Bounded,
     Constrained as Constrained,
@@ -92,7 +92,7 @@ __all__ = [
     "Param",
     "param",
     "as_param",
-    "Value",
+    "Variable",
     "Fixed",
     "Bounded",
     "Constrained",

{paramrf-0.22.0 → paramrf-0.23.2}/pmrf/infer/base.py

@@ -5,6 +5,7 @@ Base inference functions and classes.
 from typing import Callable, Any, Optional, TypeVar, TypeAlias
 import abc
 
+import numpy as np
 import jax.numpy as jnp
 import jax
 from jaxtyping import Array, PyTree, Scalar
@@ -237,12 +238,13 @@ def sample(
         A tuple of `(batched_model, payload, metrics)`.
     """
     # Filtering/unwrapping
-    is_dynamic, is_leaf = prx.probability.is_dynamic, prx.probability.is_leaf
+    is_dynamic = lambda x: prx.probability.is_dynamic(x) and not isinstance(x, np.ndarray)
+    is_leaf = prx.probability.is_leaf
     dynamic, static = eqx.partition(model, is_dynamic, is_leaf=is_leaf)
     params = prx.unwrap(dynamic, only_if=prx.is_probabilistic)
 
     try:
-        eqx.combine(params, static)
+        eqx.combine(params, static, is_leaf=is_leaf)
     except Exception as e:
         raise Exception(f"Error re-combining params and static. Error: {e}")
     

{paramrf-0.22.0 → paramrf-0.23.2}/pmrf/models/__init__.py

@@ -10,12 +10,17 @@ from pmrf.models.base import (
     validate as validate,
 )
 
+# Adapters
 from pmrf.models.adapters.base import (
     AbstractDiscrete as AbstractDiscrete,
     AbstractSingleProperty as AbstractSingleProperty,
     AbstractSingleDiscreteProperty as AbstractSingleDiscreteProperty,
 )
-from pmrf.models.adapters.bridge import Host as Host
+
+from pmrf.models.adapters.bridge import (
+    Host as Host
+)
+
 from pmrf.models.adapters.static import (
     Measured as Measured,
     SModel as SModel,
@@ -23,16 +28,28 @@ from pmrf.models.adapters.static import (
     YModel as YModel,
     ZModel as ZModel,
 )
+
 from pmrf.models.adapters.callable import (
     ContinuousCallable as ContinuousCallable,
     DiscreteCallable as DiscreteCallable,
 )
+
+# Components
 from pmrf.models.components.ideal import (
+    Load as Load,
+    Short as Short,
+    Open as Open,
+    Match as Match,
     Port as Port,
     Ground as Ground,
     SourceConverter as SourceConverter,
     Transformer as Transformer,
+    Splitter as Splitter,
+    Tee as Tee,
+    Attenuator as Attenuator,
+    DirectionalCoupler as DirectionalCoupler,
 )
+
 from pmrf.models.components.lines import (
     TransmissionLine as TransmissionLine,
     FloatingLine as FloatingLine,
@@ -44,8 +61,8 @@ from pmrf.models.components.lines import (
     CoaxialLine as CoaxialLine,
     MicrostripLine as MicrostripLine,
 )
+
 from pmrf.models.components.lumped import (
-    Load as Load,
     Resistor as Resistor,
     Capacitor as Capacitor,
     Inductor as Inductor,
@@ -54,21 +71,26 @@ from pmrf.models.components.lumped import (
     ShuntInductor as ShuntInductor,
     CapacitorQ as CapacitorQ,
     InductorQ as InductorQ,
-    Short as Short,
-    Open as Open,
-    Match as Match,
 )
-from pmrf.models.components.topological import (
-    PiCLC as PiCLC,
-    BoxCLCC as BoxCLCC,
-    TeeLCL as TeeLCL,
+
+from pmrf.models.components.sections import (
+    PiSection as PiSection,
+    TSection as TSection,
+    LSection as LSection,
+    BoxSection as BoxSection,
+    PiSectionCLC as PiSectionCLC,
+    BoxSectionCLCC as BoxSectionCLCC,
+    TSectionLCL as TSectionLCL,
     LSectionLC as LSectionLC,
 )
+
+# Composite
 from pmrf.models.composite.interconnected import (
     Circuit as Circuit,
     Cascade as Cascade,
     Terminated as Terminated,
 )
+
 from pmrf.models.composite.transformed import (
     Renumbered as Renumbered,
     Flipped as Flipped,
@@ -76,24 +98,36 @@ from pmrf.models.composite.transformed import (
 )
 
 from pmrf.models.composite.nodal import (
+    Shunt as Shunt,
     GroundLifted as GroundLifted,
     GroundExposed as GroundExposed,
-    Shunt as Shunt,
     CoupledOnePorts as CoupledOnePorts,
     CoupledTwoPorts as CoupledTwoPorts,
 )
+
+from pmrf.models.composite.topological import (
+    PiTopology as PiTopology,
+    TTopology as TTopology,
+    LTopology as LTopology,
+)
+
 from pmrf.models.composite.wrapped import (
     Tied as Tied,
     Probabilistic as Probabilistic,
 )
 
-from pmrf.models.surrogates.expansion import VectorExpansion as VectorExpansion
+# Surrogates
+from pmrf.models.surrogates.expansion import (
+    VectorExpansion as VectorExpansion
+)
+
 from pmrf.models.surrogates.rational import (
     PolynomialRatio as PolynomialRatio,
     PoleResidue as PoleResidue,
     StateSpace as StateSpace,
     BarycentricRational as BarycentricRational,
 )
+
 from pmrf.models import adapters, components, composite, surrogates
 
 __all__ = [

{paramrf-0.22.0 → paramrf-0.23.2}/pmrf/models/base.py

@@ -582,40 +582,40 @@ class Model(eqx.Module):
     
     # ---- Magic methods and copying --------------------------------------------------
 
-    # def __repr__(self) -> str:
-    #     """String representation of the Model."""
-    #     import numpy as np
-    #     import jax
-
-    #     class _RawFormatter:
-    #         """Wrapper to print arrays cleanly with rounded float values."""
-    #         def __init__(self, val):
-    #             self.val = np.asarray(val)
+    def __repr__(self) -> str:
+        """String representation of the Model."""
+        import numpy as np
+        import jax
+
+        class _RawFormatter:
+            """Wrapper to print arrays cleanly with rounded float values."""
+            def __init__(self, val):
+                self.val = np.asarray(val)
                 
-    #         def __repr__(self):
-    #             # precision=4 limits decimal places
-    #             # suppress_small=True formats numbers very close to zero as 0
-    #             return np.array2string(
-    #                 self.val, 
-    #                 separator=', ', 
-    #                 precision=4, 
-    #             )
-
-    #     # Unwrap the model to resolve variables
-    #     unwrapped = unwrap(self)
+            def __repr__(self):
+                # precision=4 limits decimal places
+                # suppress_small=True formats numbers very close to zero as 0
+                return np.array2string(
+                    self.val, 
+                    separator=', ', 
+                    precision=4, 
+                )
+
+        # Unwrap the model to resolve variables
+        unwrapped = unwrap(self)
         
-    #     # Identify JAX arrays
-    #     is_array = lambda x: isinstance(x, (jax.Array, jnp.ndarray))
+        # Identify JAX arrays
+        is_array = lambda x: isinstance(x, (jax.Array, jnp.ndarray))
         
-    #     # Replace JAX arrays with our custom formatter
-    #     unwrapped_clean = jax.tree_util.tree_map(
-    #         lambda x: _RawFormatter(x) if is_array(x) else x,
-    #         unwrapped,
-    #         is_leaf=is_array
-    #     )
+        # Replace JAX arrays with our custom formatter
+        unwrapped_clean = jax.tree_util.tree_map(
+            lambda x: _RawFormatter(x) if is_array(x) else x,
+            unwrapped,
+            is_leaf=is_array
+        )
 
-    #     # Use Equinox's formatter, displaying full internal arrays instead of generic shape labels
-    #     return eqx.tree_pformat(unwrapped_clean, short_arrays=False)
+        # Use Equinox's formatter, displaying full internal arrays instead of generic shape labels
+        return eqx.tree_pformat(unwrapped_clean, short_arrays=False)
 
     def __str__(self) -> str:
         return repr(self)    
@@ -904,26 +904,24 @@ def validate(tree):
     
     for node in nodes:
         if isinstance(node, Model):
-            # Inspect the dataclass fields of our custom RF models
             for f in dataclasses.fields(node):
                 val = getattr(node, f.name)
                 
-                # Check for the silent corruption hazard
-                is_array = isinstance(val, (jnp.ndarray, np.ndarray))
+                is_array = isinstance(val, jnp.ndarray)
                 is_static = f.metadata.get("static", False)
                 
                 if is_array and not is_static and jnp.issubdtype(val.dtype, jnp.inexact):
                     raise TypeError(
-                        f"Field '{f.name}' in '{node.__class__.__name__}' is a raw JAX/NumPy array, "
-                        f"which can be updated during optimization/inference.\n\n"
+                        f"Field '{f.name}' in '{node.__class__.__name__}' is a raw JAX array, "
+                        f"meaning it is unclear whether this is a free or fixed parameter.\n\n"
                         f"To make your intention clear, you must either:\n"
-                        f"  1. Use the `pmrf.param` specifier (or a factory in `pmrf.parameters`) to indicate the value is a parameter\n"
-                        f"  2. Explicitly mark the field as frozen using `{f.name}: jnp.ndarray = prf.field(converter=prf.freeze)` "
-                        f"and then unwrap the frozen field when you need it using `prf.unwrap`."
+                        f"  1. Use a factory in `pmrf.parameters` (e.g. `prf.Variable`) for free variables, or a numpy array for fixed variables\n"
+                        f"  2. Use a field specifier in the model class definition, e.g. `{f.name}: prf.Param = prf.param()` for automatic parameter conversion, "
+                        f"or `{f.name}: jnp.ndarray = prf.field(converter=prf.freeze)` combined with `prf.unwrap` to ensure the variable is not optimized.\n"
+                        f"This restriction is enforced to allow compatibility with machine learning models from othe libraries."
                     )
                 
-                # Manually recurse into the field's value to catch nested Models, 
-                # lists of Models, dicts of Models, etc.
+                # Recurse into submodels
                 validate(val)
 
 

{paramrf-0.22.0 → paramrf-0.23.2}/pmrf/models/components/__init__.py

@@ -5,11 +5,11 @@ This module provides all the built-in components and circuit elements for buildi
 This includes lumped elements, transmission lines, topological sub-circuits, and more.
 """
 
-from pmrf.models.components import ideal, lines, lumped, topological
+from pmrf.models.components import ideal, lines, lumped, sections
 
 __all__ = [
     "ideal",
     "lines",
     "lumped",
-    "topological",
+    "sections",
 ]