paramrf 0.37.0__tar.gz → 0.37.2__tar.gz

{paramrf-0.37.0/paramrf.egg-info → paramrf-0.37.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramrf
-Version: 0.37.0
+Version: 0.37.2
 Summary: Parametric radio frequency modeling
 Author-email: Gary Allen <gvcallen@gmail.com>
 Project-URL: homepage, https://github.com/gvcallen/paramrf
@@ -35,6 +35,7 @@ Requires-Dist: jupyter-sphinx; extra == "docs"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-xdist; extra == "tests"
+Requires-Dist: jedi==0.20.0; extra == "tests"
 Requires-Dist: filelock; extra == "tests"
 Requires-Dist: ipython; extra == "tests"
 Requires-Dist: scikit-rf; extra == "tests"

{paramrf-0.37.0 → paramrf-0.37.2/paramrf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramrf
-Version: 0.37.0
+Version: 0.37.2
 Summary: Parametric radio frequency modeling
 Author-email: Gary Allen <gvcallen@gmail.com>
 Project-URL: homepage, https://github.com/gvcallen/paramrf
@@ -35,6 +35,7 @@ Requires-Dist: jupyter-sphinx; extra == "docs"
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-xdist; extra == "tests"
+Requires-Dist: jedi==0.20.0; extra == "tests"
 Requires-Dist: filelock; extra == "tests"
 Requires-Dist: ipython; extra == "tests"
 Requires-Dist: scikit-rf; extra == "tests"

{paramrf-0.37.0 → paramrf-0.37.2}/paramrf.egg-info/SOURCES.txt

@@ -206,6 +206,7 @@ tests/test_fitting_routers.py
 tests/test_fitting_sample.py
 tests/test_fitting_targets.py
 tests/test_frequency.py
+tests/test_grouped_exports.py
 tests/test_infer_base.py
 tests/test_infer_sample.py
 tests/test_line_internal_discrepancy_example.py

{paramrf-0.37.0 → paramrf-0.37.2}/paramrf.egg-info/requires.txt

@@ -28,6 +28,7 @@ jupyter-sphinx
 [tests]
 pytest
 pytest-xdist
+jedi==0.20.0
 filelock
 ipython
 scikit-rf

{paramrf-0.37.0 → paramrf-0.37.2}/pmrf/__init__.py

@@ -1,6 +1,8 @@
 import logging
 import warnings
 import os
+from importlib import import_module
+from typing import TYPE_CHECKING
 
 # Stop thread contention between vmap and CPU backend multithreading
 os.environ["OPENBLAS_NUM_THREADS"] = "1"
@@ -102,21 +104,32 @@ from pmrf.utils import (
 
 # Public packages
 from pmrf import (
-    fitting as fitting,
-    infer as infer,
     materials as materials,
     math as math,
     models as models,
     modules as modules,
     objectives as objectives,
-    optimize as optimize,
     parameters as parameters,
     rf as rf,
     serialization as serialization,
     stats as stats,
-    viz as viz,
 )
 
+# These packages pull in objective implementations. Expose them on first access.
+if TYPE_CHECKING:
+    from pmrf import fitting as fitting, infer as infer, optimize as optimize, viz as viz
+
+def __getattr__(name):
+    if name in ("fitting", "infer", "optimize", "viz"):
+        module = import_module(f"{__name__}.{name}")
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(set(globals()) | set(__all__))
+
 __all__ = [
     # Base/Core
     "Model",

{paramrf-0.37.0 → paramrf-0.37.2}/pmrf/models/__init__.py

@@ -96,6 +96,7 @@ from pmrf.models.components.lines.nodal import (
 )
 
 from pmrf.models.components.lines.ideal import (
+    DelayLine as DelayLine,
     PhaseLine as PhaseLine,
     RLGCLine as RLGCLine,
 )
@@ -206,6 +207,7 @@ from pmrf.models.composite.transformed import (
 from pmrf.models.composite.nodal import (
     FloatingTwoPort as FloatingTwoPort,
     Shunt as Shunt,
+    Series as Series,
     GroundLifted as GroundLifted,
     GroundExposed as GroundExposed,
     CoupledOnePorts as CoupledOnePorts,

{paramrf-0.37.0 → paramrf-0.37.2}/pmrf/models/components/lines/ideal.py

@@ -66,6 +66,53 @@ class PhaseLine(AbstractUniformLine):
         return zc, gammaL
 
 
+class DelayLine(AbstractUniformLine):
+    r"""
+    Ideal, lossless, and dispersionless transmission line defined by 
+    a constant time delay. Characteristic impedance is real and constant; 
+    phase scales linearly with frequency.
+
+    **Mathematical Formulation**
+
+    $$Z_c(\omega) = Z_c$$
+    $$\gamma L(\omega) = j \cdot \omega \cdot t_d$$
+
+    Example
+    --------
+    .. code-block:: python
+
+        import pmrf as prf
+        from pmrf.models import DelayLine
+
+        # Create an ideal 1 ns delay line with 50-ohm characteristic impedance
+        line = DelayLine(
+            z0=50.0,
+            td=1.0e-9
+        )
+
+        freq = prf.Frequency(start=0.5, stop=1.5, npoints=101, unit='ghz')
+        s = line.s(freq)
+
+    Parameters
+    ----------
+    z0 : Param, default=50.0
+        Characteristic impedance in Ohms.
+    td : Param, default=1.0e-9
+        Time delay in seconds.
+    """
+    #: Characteristic impedance
+    z0: Param = param(default=50.0, constraint=Positive())
+    
+    #: Time delay
+    td: Param = param(default=1.0e-9, constraint=Positive())
+
+    def zc_and_gammaL(self, frequency: Frequency) -> tuple[jnp.ndarray, jnp.ndarray]:
+        zc = self.z0 * jnp.ones(frequency.npoints, dtype=complex)
+        gammaL = 1j * frequency.w * self.td
+        
+        return zc, gammaL
+
+
 class RLGCLine(AbstractImmittanceLine):
     r"""
     Transmission line with specified RLGC parameters.

{paramrf-0.37.0 → paramrf-0.37.2}/pmrf/models/composite/nodal.py

@@ -203,6 +203,52 @@ class Shunt(Model):
         return renormalize_s(S_shunt, z0_eval, z0, 'power', 'power')
     
 
+class Series(Model):
+    r"""Connect a 1-port impedance in series along a 2-port line.
+
+    **Mathematical Formulation**
+
+    At a common reference impedance of 50 ohms, the wrapped 1-port's
+    reflection coefficient $\Gamma$ gives
+
+    $$S_{11} = S_{22} = \frac{1 + \Gamma}{3 - \Gamma}, \qquad
+    S_{21} = S_{12} = \frac{2(1 - \Gamma)}{3 - \Gamma}.$$
+
+    The resulting two-port is then renormalized to the requested reference
+    impedance. This form also covers ideal shorts and opens without converting
+    the wrapped reflection coefficient to an impedance.
+
+    Parameters
+    ----------
+    series : Model
+        The 1-port model to insert in series.
+
+    References
+    ----------
+    D. M. Pozar, *Microwave Engineering*, 4th ed., Wiley, 2012, sec. 4.4.
+    """
+    #: The 1-port model to insert in series.
+    series: Model
+
+    def __post_init__(self):
+        if self.series.nports != 1:
+            raise ValueError(
+                f"Series requires a 1-port model. Received a {self.series.nports}-port model."
+            )
+
+    def s(self, freq: Frequency, z0: ArrayLike = 50.0) -> jnp.ndarray:
+        z0_eval = 50.0
+        gamma = self.series.s(freq, z0=z0_eval)[:, 0, 0]
+        denom = 3.0 - gamma
+        s11 = (1.0 + gamma) / denom
+        s21 = 2.0 * (1.0 - gamma) / denom
+        s_series = jnp.array([
+            [s11, s21],
+            [s21, s11],
+        ]).transpose(2, 0, 1)
+        return renormalize_s(s_series, z0_eval, z0, 'power', 'power')
+
+
 class CoupledOnePorts(Model):
     r"""
     (experimental) Wraps N 1-port models (e.g. inductors) and couples them via a given K-matrix.

{paramrf-0.37.0 → paramrf-0.37.2}/pmrf/objectives/__init__.py

@@ -1,6 +1,43 @@
 """Public objectives modules and their common entry points."""
 
 from importlib import import_module
+from typing import TYPE_CHECKING
+
+# Keep static analyzers aware of the public names without loading them at runtime.
+if TYPE_CHECKING:
+    from .evaluators import (
+        AbstractEvaluator as AbstractEvaluator,
+        EvaluatorFn as EvaluatorFn,
+        EvaluatorLike as EvaluatorLike,
+        Feature as Feature,
+        GibbsMarginalLogLikelihood as GibbsMarginalLogLikelihood,
+        Goal as Goal,
+        MarginalLogLikelihood as MarginalLogLikelihood,
+        Negated as Negated,
+        TargetLoss as TargetLoss,
+    )
+    from .losses import (
+        AbstractLoss as AbstractLoss,
+        HingeLoss as HingeLoss,
+        HuberLoss as HuberLoss,
+        LogMSELoss as LogMSELoss,
+        MSELoss as MSELoss,
+        MAPELoss as MAPELoss,
+        RMSELoss as RMSELoss,
+    )
+    from .problems import (
+        AbstractProblem as AbstractProblem,
+        PriorPenalized as PriorPenalized,
+        SummedTerms as SummedTerms,
+        problem_terms as problem_terms,
+    )
+    from .terms import (
+        AbstractTerm as AbstractTerm,
+        BoundEvaluator as BoundEvaluator,
+        TermFn as TermFn,
+        TermLike as TermLike,
+        as_terms as as_terms,
+    )
 
 _EXPORTS = {
     'AbstractEvaluator': 'evaluators',

{paramrf-0.37.0 → paramrf-0.37.2}/pmrf/stats/__init__.py

@@ -1,6 +1,75 @@
 """Public stats modules and their common entry points."""
 
 from importlib import import_module
+from typing import TYPE_CHECKING
+
+# Keep static analyzers aware of the public names without loading them at runtime.
+if TYPE_CHECKING:
+    from .bijectors import (
+        AbstractBijector as AbstractBijector,
+        Chain as Chain,
+        DiagLinear as DiagLinear,
+        Exp as Exp,
+        Identity as Identity,
+        Inverse as Inverse,
+        Leafwise as Leafwise,
+        Permute as Permute,
+        R2ToComplex as R2ToComplex,
+        ScalarAffine as ScalarAffine,
+        Shift as Shift,
+        Sigmoid as Sigmoid,
+        Softplus as Softplus,
+        Tanh as Tanh,
+        Transpose as Transpose,
+        TriangularLinear as TriangularLinear,
+    )
+    from .covariance_kernels import (
+        AbstractCovarianceKernel as AbstractCovarianceKernel,
+        AutoCrossKernel as AutoCrossKernel,
+        ConstantKernel as ConstantKernel,
+        CosineKernel as CosineKernel,
+        Matern32Kernel as Matern32Kernel,
+        Matern52Kernel as Matern52Kernel,
+        PeriodicKernel as PeriodicKernel,
+        ProductKernel as ProductKernel,
+        RBFKernel as RBFKernel,
+        SharedIndependentKernel as SharedIndependentKernel,
+        SumKernel as SumKernel,
+        WhiteNoiseKernel as WhiteNoiseKernel,
+        ZeroKernel as ZeroKernel,
+        cross_gram as cross_gram,
+        gram as gram,
+    )
+    from .discrepancy_models import (
+        AbstractDiscrepancyModel as AbstractDiscrepancyModel,
+        GaussianProcess as GaussianProcess,
+    )
+    from .distributions import (
+        AbstractDistribution as AbstractDistribution,
+        CenteredUniform as CenteredUniform,
+        Gamma as Gamma,
+        Joint as Joint,
+        LogNormal as LogNormal,
+        Normal as Normal,
+        RelativeNormal as RelativeNormal,
+        RelativeTruncatedNormal as RelativeTruncatedNormal,
+        Transformed as Transformed,
+        TruncatedNormal as TruncatedNormal,
+        Uniform as Uniform,
+        truncate as truncate,
+    )
+    from .likelihoods import (
+        AbstractLikelihood as AbstractLikelihood,
+        GaussianLikelihood as GaussianLikelihood,
+    )
+    from .linearization import (
+        Linearization as Linearization,
+        posterior_covariance as posterior_covariance,
+    )
+    from .noise_models import (
+        AbstractNoiseModel as AbstractNoiseModel,
+        AutoCrossNoise as AutoCrossNoise,
+    )
 
 _EXPORTS = {
     'AbstractBijector': 'bijectors',

{paramrf-0.37.0 → paramrf-0.37.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "paramrf"
-version = "0.37.0"
+version = "0.37.2"
 description = "Parametric radio frequency modeling"
 readme = "README.rst"
 authors = [
@@ -39,6 +39,7 @@ docs = [
 tests = [
     "pytest",
     "pytest-xdist",
+    "jedi==0.20.0",
     "filelock",
     "ipython",
     "scikit-rf",

{paramrf-0.37.0 → paramrf-0.37.2}/tests/test_dc_limits.py

@@ -33,6 +33,7 @@ from pmrf.models.components.lines.base import TransmissionLine
 from pmrf.models import (
     CoaxialLine,
     DatasheetLine,
+    DelayLine,
     FloatingLine,
     MicrostripLine,
     PhaseLine,
@@ -55,6 +56,7 @@ def dc_freq():
 
 LINES = {
     "PhaseLine": PhaseLine(z0=50.0, theta=90.0, f0=5e9),
+    "DelayLine": DelayLine(z0=50.0, td=1e-9),
     "RLGCLine": RLGCLine(R=0.1, L=250e-9, G=1e-6, C=100e-12, length=0.1),
     "RLGCLine (lossless)": RLGCLine(R=0.0, L=250e-9, G=0.0, C=100e-12, length=0.1),
     "PhysicalLine": PhysicalLine(

paramrf-0.37.2/tests/test_grouped_exports.py

@@ -0,0 +1,156 @@
+"""Grouped export checks. Run with ``python -m pytest tests/test_grouped_exports.py``.
+
+The static checks use the test extra's pinned Jedi 0.20.0. They check source
+analysis, not any particular notebook editor or language server.
+"""
+
+import ast
+import importlib
+import subprocess
+import sys
+from pathlib import Path
+
+import jedi
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+PACKAGES = ("objectives", "stats")
+
+
+def exports(package):
+    source = ast.parse((ROOT / "pmrf" / package / "__init__.py").read_text())
+    assignment = next(
+        node for node in source.body
+        if isinstance(node, ast.Assign)
+        and any(isinstance(target, ast.Name) and target.id == "_EXPORTS"
+                for target in node.targets)
+    )
+    return ast.literal_eval(assignment.value)
+
+
+def infer(source):
+    line = len(source.splitlines())
+    return jedi.Script(source, project=jedi.Project(str(ROOT))).infer(
+        line=line, column=len(source.splitlines()[-1])
+    )
+
+
+@pytest.mark.parametrize("package", PACKAGES)
+def test_jedi_resolves_every_declared_export(package):
+    unresolved = [
+        name for name in exports(package)
+        if not infer(f"import pmrf as prf\nprf.{package}.{name}")
+    ]
+    assert not unresolved
+
+
+@pytest.mark.parametrize("package,name", [("objectives", "Goal"), ("stats", "Normal")])
+def test_jedi_resolves_direct_and_qualified_imports(package, name):
+    for source in (
+        f"import pmrf as prf\nprf.{package}.{name}",
+        f"import pmrf.{package} as grouped\ngrouped.{name}",
+        f"from pmrf import {package}\n{package}.{name}",
+        f"from pmrf.{package} import {name}\n{name}",
+    ):
+        assert infer(source), source
+
+
+@pytest.mark.parametrize("package,name", [("objectives", "Goal"), ("stats", "Normal")])
+def test_jedi_completes_grouped_names(package, name):
+    source = f"import pmrf as prf\nprf.{package}."
+    completions = jedi.Script(source, project=jedi.Project(str(ROOT))).complete(
+        line=2, column=len(source.splitlines()[-1])
+    )
+    assert name in {completion.name for completion in completions}
+
+
+def test_jedi_infers_goal_instance():
+    result = infer(
+        "import pmrf as prf\n"
+        "goal = prf.objectives.Goal('s11_db', '<', -20)\n"
+        "goal"
+    )
+    assert any(item.name == "Goal" and item.type == "instance" for item in result)
+
+
+@pytest.mark.parametrize("package", PACKAGES)
+def test_runtime_exports_keep_implementation_identity(package):
+    grouped = importlib.import_module(f"pmrf.{package}")
+    import pmrf as prf
+
+    assert set(exports(package)).issubset(grouped.__all__)
+    for name in set(grouped.__all__) - set(exports(package)):
+        implementation = importlib.import_module(f"pmrf.{package}.{name}")
+        assert getattr(grouped, name) is implementation
+        assert getattr(getattr(prf, package), name) is implementation
+
+    for name, module in exports(package).items():
+        implementation = getattr(importlib.import_module(f"pmrf.{package}.{module}"), name)
+        assert getattr(grouped, name) is implementation
+        assert getattr(getattr(prf, package), name) is implementation
+        assert getattr(importlib.import_module(f"pmrf.{package}"), name) is implementation
+        namespace = {}
+        exec(f"from pmrf.{package} import {name}", namespace)
+        assert namespace[name] is implementation
+
+    with pytest.raises(AttributeError):
+        getattr(grouped, "NotAnExport")
+
+
+@pytest.mark.parametrize("package", PACKAGES)
+def test_grouped_initializer_keeps_implementations_lazy(package):
+    script = f"""
+import sys
+import types
+root = types.ModuleType('pmrf')
+root.__path__ = [{str(ROOT / 'pmrf')!r}]
+sys.modules['pmrf'] = root
+import pmrf.{package}
+loaded = {{name for name in sys.modules if name.startswith('pmrf.{package}.')}}
+assert not loaded, loaded
+"""
+    subprocess.run([sys.executable, "-P", "-c", script], cwd=ROOT, check=True)
+
+
+@pytest.mark.parametrize("import_statement", [
+    "import pmrf",
+    "import pmrf.objectives",
+    "import pmrf.stats",
+])
+def test_fresh_import_does_not_load_every_grouped_implementation(import_statement):
+    modules = {
+        package: sorted(set(exports(package).values())) for package in PACKAGES
+    }
+    script = f"""
+import sys
+{import_statement}
+for package, modules in {modules!r}.items():
+    assert not all(f'pmrf.{{package}}.{{module}}' in sys.modules for module in modules), package
+"""
+    subprocess.run([sys.executable, "-P", "-c", script], cwd=ROOT, check=True)
+
+
+def test_root_lazy_packages_remain_available():
+    script = """
+import importlib
+import pmrf
+for name in ('fitting', 'infer', 'optimize', 'viz'):
+    assert name in dir(pmrf)
+    assert getattr(pmrf, name) is importlib.import_module(f'pmrf.{name}')
+"""
+    subprocess.run([sys.executable, "-P", "-c", script], cwd=ROOT, check=True)
+
+
+@pytest.mark.parametrize("package,name,module", [
+    ("objectives", "Goal", "evaluators"),
+    ("stats", "AutoCrossNoise", "noise_models"),
+])
+def test_fresh_export_access_loads_defining_module(package, name, module):
+    script = f"""
+import sys
+import pmrf as prf
+assert getattr(prf.{package}, '{name}') is not None
+assert 'pmrf.{package}.{module}' in sys.modules
+"""
+    subprocess.run([sys.executable, "-P", "-c", script], cwd=ROOT, check=True)

{paramrf-0.37.0 → paramrf-0.37.2}/tests/test_models/test_edge_values.py

@@ -52,13 +52,14 @@ import pmrf.models
 from pmrf.frequency import Frequency
 from pmrf.materials import ColeColeDielectric, MultipoleDebyeDielectric, RoughConductor
 from pmrf.parameters import Param
+from pmrf.parameters.constraints import Interval
 from pmrf.models import (
     Model, Circuit, Port,
     GlobalMNACircuitSolver, GlobalScatteringCircuitSolver,
     Load, Short, Open, Match, Ground, Transformer, CentreTappedTransformer,
     Autotransformer, Balun, SourceConverter, MixedModeConverter, Isolator, Splitter,
     Tee, Attenuator, Amplifier, DirectionalCoupler,
-    PhaseLine, RLGCLine, PhysicalLine, DatasheetLine, CoaxialLine, MicrostripLine,
+    PhaseLine, DelayLine, RLGCLine, PhysicalLine, DatasheetLine, CoaxialLine, MicrostripLine,
     StriplineLine, FloatingLine,
     Resistor, Capacitor, Inductor, CoupledInductors, SeriesRL, Impedance, Admittance,
     ShuntResistor, ShuntCapacitor, ShuntInductor, CapacitorQ, InductorQ,
@@ -91,6 +92,12 @@ EXAMPLES = {
     Amplifier: lambda: Amplifier(gain=10.0),
     DirectionalCoupler: lambda: DirectionalCoupler(coupling=10.0),
     PhaseLine: lambda: PhaseLine(z0=50.0, theta=90.0, f0=0.5e9),
+    # Both built-in bounds are open or infinite. A finite fitting limit gives the
+    # sweep a closed edge for DelayLine's delay parameter to evaluate.
+    DelayLine: lambda: DelayLine(
+        z0=50.0,
+        td=Param(value=0.25e-9, validity=Interval(0.0, 0.3e-9, closed=(False, True))),
+    ),
     # Not a multiple of a half wavelength on FREQ. There a nearly lossless line's Y has a
     # pole, and the MNA solver, which stamps lines from `y()`, loses precision: at
     # length=0.1 (half a wavelength at 1 GHz) with R = 0, MNA and scattering differ by 7e-6.

{paramrf-0.37.0 → paramrf-0.37.2}/tests/test_models/test_nodal.py

@@ -3,6 +3,7 @@ import pytest
 import numpy as np
 import jax.numpy as jnp
 import equinox as eqx
+from skrf.media import DefinedGammaZ0
 
 from pmrf.frequency import Frequency
 from pmrf.parameters import Unconstrained
@@ -10,7 +11,8 @@ from pmrf.rf import s2y
 
 from pmrf.models import (
     Model, Cascade, Circuit, FloatingLine, FloatingTwoPort, GroundLifted,
-    GroundExposed, Shunt, PhaseLine, Port, RLGCLine, Resistor, Short, Open,
+    GroundExposed, Shunt, Series, PhaseLine, Port, RLGCLine, Resistor, Short, Open,
+    Load,
     Inductor
 )
 from pmrf.models.composite.nodal import CoupledOnePorts, CoupledTwoPorts
@@ -282,6 +284,44 @@ def test_shunt_invalid_port_count():
     with pytest.raises(ValueError, match="Shunt requires a 1-port model"):
         Shunt(shunt=res_model)
 
+# ---------------------------------------------------------
+# Series Tests
+# ---------------------------------------------------------
+
+@pytest.mark.parametrize("inner, reflection, transmission", [
+    (Short(), 0.0, 1.0),
+    (Open(), 1.0, 0.0),
+])
+def test_series_ideal_limits(inner, reflection, transmission, basic_freq):
+    s = Series(series=inner).s(basic_freq)
+
+    assert s.shape == (basic_freq.npoints, 2, 2)
+    assert jnp.all(jnp.isfinite(s))
+    np.testing.assert_allclose(s[:, 0, 0], reflection, atol=1e-12)
+    np.testing.assert_allclose(s[:, 1, 1], reflection, atol=1e-12)
+    np.testing.assert_allclose(s[:, 0, 1], transmission, atol=1e-12)
+    np.testing.assert_allclose(s[:, 1, 0], transmission, atol=1e-12)
+
+
+@pytest.mark.parametrize("resistance", [25.0, 50.0, 200.0])
+@pytest.mark.parametrize("z0", [50.0, 75.0, np.array([45.0, 75.0])])
+def test_series_resistance_matches_skrf(resistance, z0, basic_freq):
+    gamma = (resistance - 50.0) / (resistance + 50.0)
+    actual = Series(series=Load(gamma=gamma, z0=50.0)).s(basic_freq, z0=z0)
+
+    # A series element has a singular two-port Z matrix. Construct directly at
+    # the target z0: scikit-rf's S -> Z -> S renormalization perturbs that
+    # singularity and introduces errors of order 1e-8.
+    media = DefinedGammaZ0(basic_freq.to_skrf(), z0=50.0)
+    reference = media.resistor(resistance, z0=z0)
+
+    np.testing.assert_allclose(actual, reference.s, rtol=1e-12, atol=1e-12)
+
+
+def test_series_invalid_port_count():
+    with pytest.raises(ValueError, match="Series requires a 1-port model"):
+        Series(series=Resistor(R=50.0))
+
 # ---------------------------------------------------------
 # CoupledOnePorts Tests
 # ---------------------------------------------------------