unitx 0.14.2__tar.gz → 0.14.4__tar.gz

{unitx-0.14.2 → unitx-0.14.4}/.github/consumers/arrays.py

@@ -17,6 +17,11 @@ def check_arrays(values: NDArray[np.float64]) -> None:
     assert level.value is values
     np.testing.assert_allclose(level.to_quantity(si.W).value, [0.001, 0.1, 1.0])
 
+    voltage_level = LogQuantity(values, si.dB(si.mV))
+    assert_type(voltage_level, LogQuantity[NDArray[np.float64]])
+    assert voltage_level.value is values
+    np.testing.assert_allclose(voltage_level.to_quantity(si.mV).value, 10 ** (values / 20))
+
     distance = Quantity(values.copy(), si.m)
     assert_type(distance, Quantity[NDArray[np.float64]])
     assert_type(distance.unit, Unit)

{unitx-0.14.2 → unitx-0.14.4}/.github/consumers/scalars.py

@@ -12,7 +12,17 @@ from pathlib import Path
 from typing import Final, assert_type
 
 import unitx
-from unitx import AffineQuantity, LogQuantity, Quantity, Registry, Unit, UnitCatalog, math, time
+from unitx import (
+    AffineQuantity,
+    LogQuantity,
+    LogUnit,
+    Quantity,
+    Registry,
+    Unit,
+    UnitCatalog,
+    math,
+    time,
+)
 from unitx.factor import Factor
 from unitx.imperial import imperial
 from unitx.serialization import from_dict, to_dict
@@ -70,6 +80,12 @@ assert celsius.to_quantity(si.K) == Fraction(5863, 20) * si.K
 assert (32 @ imperial.degF).to(si.degC) == 0 @ si.degC
 assert level.to_quantity(si.W) == 1 * si.W
 assert LogQuantity.from_quantity(1 * si.W, si.dBm) == level
+assert_type(si.dB(si.V), LogUnit)
+assert si.dB(si.mW) is si.dBm
+assert Unit('decibel')(si.V) is si.dBV
+millivolt_level = Decimal(20) @ si.dB(si.mV)
+assert_type(millivolt_level, LogQuantity[Decimal])
+assert millivolt_level.to_quantity(si.mV).value == Decimal(10)
 
 registry = Registry([si.m])
 with registry.defining():

{unitx-0.14.2 → unitx-0.14.4}/.github/workflows/ci.yml

@@ -57,6 +57,7 @@ jobs:
       - name: Run Ruff
         run: |
           ruff check .
+          ruff check tests conftest.py --select ANN --ignore ANN401
           ruff format --check .
 
       - name: Run tests

unitx-0.14.4/.github/workflows/pages.yml

@@ -0,0 +1,52 @@
+name: Documentation site
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/pages.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: read
+
+concurrency:
+  group: github-pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v7
+        with:
+          python-version: '3.12'
+      - name: Configure GitHub Pages
+        uses: actions/configure-pages@v5
+      - name: Install documentation dependencies
+        run: python -m pip install -r docs/requirements.txt
+      - name: Build documentation
+        run: python -m mkdocs build --strict
+      - name: Upload site
+        uses: actions/upload-pages-artifact@v4
+        with:
+          path: site
+
+  deploy:
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

{unitx-0.14.2 → unitx-0.14.4}/.github/workflows/release.yml

@@ -52,6 +52,7 @@ jobs:
       - name: Validate source
         run: |
           python -m ruff check .
+          python -m ruff check tests conftest.py --select ANN --ignore ANN401
           python -m ruff format --check .
           python -m pytest -q
           python -m doctest README.md docs/*.md docs/catalogues/*.md

{unitx-0.14.2 → unitx-0.14.4}/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [0.14.4] - 2026-10-24
+
+### Fixed
+
+- Correct the Impedance example's mixed-addition result annotations and retain
+  its specialized scalar `+=` result types. Document the subclass boundary and
+  check it with runtime and static consumers.
+
+### Documentation
+
+- Host the MkDocs guides on GitHub Pages with automatic deployment from main.
+  Keep Read the Docs deployment pending transfer of the project name.
+
+## [0.14.3] - 2026-10-24
+
+### Added
+
+- Allow `si.dB(reference, kind=...)` to construct a logarithmic coordinate.
+  Named watts and volts, including SI prefixes, supply conventional defaults;
+  common references reuse dBm, dBW and dBV. Other units require an explicit kind.
+- Add a standalone Impedance subclass example with series addition, parallel
+  `//` composition, unit conversion and a complex RLC circuit calculation,
+  plus a notebook that traces its frequency response on a Smith chart.
+
+### Internal
+
+- Consolidate static consumers under scalar and NumPy typing fixtures, checking
+  actual notebook source instead of duplicate blackbody examples. Keep the
+  NumPy 2.5 asarray regression separately gated and exclude static fixtures from
+  pytest collection.
+- Complete runtime-test signature annotations and check them in the existing CI
+  and release lint steps.
+
 ## [0.14.2] - 2026-10-24
 
 ### Documentation

{unitx-0.14.2 → unitx-0.14.4}/CONTRIBUTING.md

@@ -15,6 +15,7 @@ without NumPy and the built-in factorization path without SymPy.
 ```sh
 python -m pytest -q
 python -m ruff check .
+python -m ruff check tests conftest.py --select ANN --ignore ANN401
 python -m ruff format --check .
 python -m pyright --pythonpath /path/to/your/python
 ```
@@ -28,6 +29,9 @@ consumers in `.github/consumers/`. It copies those scripts and their independent
 Pyright configuration outside the checkout, first checking scalar runtime and
 types without NumPy, then installing NumPy and checking array runtime and types.
 The release workflow runs the same consumers before uploading distributions.
+Test functions and helpers have annotated parameters and return values. The
+dedicated Ruff command checks those signatures; static inference regressions
+use the separate Pyright consumers rather than annotating expected results.
 
 Run the executable Markdown examples as well:
 
@@ -54,9 +58,13 @@ python -m mkdocs serve
 ```
 
 The build writes to the ignored `site/` directory. CI checks the strict build,
-including internal links and anchors. `.readthedocs.yaml` uses the same pinned
-MkDocs requirement; connect the repository to a Read the Docs project to host
-it. These configuration files alone do not create or publish a hosted site.
+including internal links and anchors. The [documentation site](https://daitthu.github.io/unitx/)
+is hosted on GitHub Pages. `.github/workflows/pages.yml` builds and deploys
+changes to `docs/`, `mkdocs.yml` or the workflow on main; it also supports
+manual runs. Repository Settings → Pages must use GitHub Actions as its source.
+`.readthedocs.yaml` retains the same pinned MkDocs requirement for a future
+Read the Docs deployment. Do not connect or publish that project until
+ownership of `unitx.readthedocs.io` has transferred to the project owner.
 Mermaid diagrams load a pinned JavaScript module from jsDelivr in the browser;
 building the HTML does not require that CDN. Repository files outside `docs/`
 use GitHub links so they also work on a hosted documentation site.

{unitx-0.14.2 → unitx-0.14.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.14.2
+Version: 0.14.4
 Summary: Physical units, quantities, and unit conversion with exact unit algebra, type hints, and NumPy integration.
 Project-URL: Homepage, https://github.com/DaitTHU/unitx
-Project-URL: Documentation, https://github.com/DaitTHU/unitx/blob/main/docs/README.md
+Project-URL: Documentation, https://daitthu.github.io/unitx/
 Project-URL: Source, https://github.com/DaitTHU/unitx
 Project-URL: Changelog, https://github.com/DaitTHU/unitx/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/DaitTHU/unitx/issues
@@ -237,7 +237,7 @@ plt.show()
 
 ## Read more
 
-Start at the [documentation index](https://github.com/DaitTHU/unitx/blob/main/docs/README.md),
+Start at the [documentation site](https://daitthu.github.io/unitx/),
 or go directly to a topic:
 
 | Topic | Guide |

{unitx-0.14.2 → unitx-0.14.4}/README.md

@@ -209,7 +209,7 @@ plt.show()
 
 ## Read more
 
-Start at the [documentation index](https://github.com/DaitTHU/unitx/blob/main/docs/README.md),
+Start at the [documentation site](https://daitthu.github.io/unitx/),
 or go directly to a topic:
 
 | Topic | Guide |

{unitx-0.14.2 → unitx-0.14.4}/conftest.py

@@ -7,7 +7,7 @@ from unitx.exceptions import InexactFloatWarning
 from unitx.factor import Factor
 
 # Static-only fixtures run through Pyright in tests/test_typing.py.
-collect_ignore = ['tests/example_typing', 'tests/numpy_typing']
+collect_ignore = ['tests/typing', 'tests/numpy_typing']
 if find_spec('numpy') is None:
     collect_ignore.append('src/unitx/_numpy.py')
 

{unitx-0.14.2 → unitx-0.14.4}/docs/architecture.md

@@ -75,6 +75,12 @@ a physical Quantity; `LogQuantity.from_quantity(quantity, coordinate)` enters a
 logarithmic coordinate. These boundaries prevent an implicit exponential or
 logarithm from entering ordinary Quantity conversions.
 
+`Unit.__call__` is a narrow convenience boundary for the formal dB unit. It
+delegates lazily to the logarithmic module, which constructs an ordinary
+LogUnit or reuses a named descriptor. Default conventions recognize watt and
+volt definition identities with their prefixes; they are not inferred from
+dimensions or symbol strings. Calling another Unit raises TypeError.
+
 The difference-unit factor uses the neper scale. The mapping coefficient is
 `ln(10)/2` for power and `ln(10)` for amplitude, so a reading displacement `x - at`
 represents the ratio `10**((x - at) * delta.factor / coefficient)` relative to

{unitx-0.14.2 → unitx-0.14.4}/docs/logarithmic.md

@@ -54,6 +54,43 @@ True
 
 ## Defining logarithmic coordinates
 
+For a zero-reading reference, `si.dB(reference, kind=...)` is a shorthand for
+`LogUnit(reference, delta_unit=si.dB, kind=...)`. A Unit argument means one of
+that unit; a Quantity argument supplies the full reference value. Watts and
+volts, including their SI prefixes and extra exact scales, default to
+`kind='power'` and `kind='amplitude'`, respectively. This convention follows
+the named unit definition, not physical dimension: other units and composite
+expressions require an explicit `kind`. An explicit `kind` always takes precedence.
+
+```pycon
+>>> si.dB(si.mW) is si.dBm
+True
+>>> si.dB(si.W) is si.dBW
+True
+>>> si.dB(si.V) is si.dBV
+True
+>>> millivolt_level = si.dB(si.mV)
+>>> (20 @ millivolt_level).to_quantity(si.mV).value
+10
+>>> (0 @ millivolt_level).to(si.dBV).value
+-60
+>>> pressure_level = si.dB(20 * si.uPa, kind='amplitude')
+>>> (0 @ pressure_level).to_quantity(si.uPa).value
+20
+
+```
+
+References with value one and unit mW, W or V, using their usual conventions,
+return the existing named descriptors. Other references return
+anonymous LogUnits without registering new names. The millivolt reference
+corresponds to dBmV; dBm refers to a milliwatt. Voltage-to-power conversion
+requires additional physical information such as impedance.
+
+Only the formal dB unit supports this call. Reconstructed dB units behave the
+same way; other Units raise TypeError when called. As a consequence of the
+shared `Unit.__call__` method, `callable(unit)` is true for all Unit objects
+and does not test whether this shorthand is supported.
+
 `LogUnit(reference, /, *, delta_unit, kind, at=0)` means reading `at` represents
 `reference`. A reference is a physical Quantity or LogQuantity. Both `delta_unit`
 and `kind='power'|'amplitude'` are required. References must be positive finite

{unitx-0.14.2 → unitx-0.14.4}/docs/typing.md

@@ -36,6 +36,20 @@ seconds. An `Annotated` label alone does not teach a type checker dimensional
 algebra. unitx does not currently supply dimension-parameterized quantities
 or a call-validation decorator.
 
+## Quantity subclasses
+
+Preserving the magnitude parameter T does not preserve a Quantity subclass.
+Quantity's ordinary binary arithmetic, unary operators and `.to()` construct
+ordinary Quantity objects. A subclass must explicitly implement the operations
+that preserve its own invariants. Scalar augmented operators delegate to the
+corresponding binary operation; their annotations must describe the subclass's
+results too.
+For example, the [Impedance extension](https://github.com/DaitTHU/unitx/blob/main/examples/impedance.md)
+preserves its type for addition of two Impedances, parallel composition and
+conversion. Adding an ordinary Quantity returns an ordinary Quantity in either
+operand order. Its local overrides specialize the base class's wider input
+domain; they are not a template for preserving every array or coordinate overload.
+
 ## NumPy magnitude types
 
 `_numerics.py` defines `Scalar`, `Array`, and `Magnitude = Array | Scalar`
@@ -93,7 +107,12 @@ in static analysis. Result dtype and shape remain determined by NumPy.
 
 The test suite runs strict scalar fixtures with and without NumPy and checks
 array consumers separately when NumPy is installed. `tests/typing` and
-`tests/numpy_typing` are static fixtures, not runtime test modules.
+`tests/numpy_typing` are static fixtures excluded from pytest collection.
+The small `check_asarray.py` regression requires NumPy >= 2.5 stubs; other array
+fixtures cover the full supported NumPy range. Notebook checks extract the
+actual code and add selected type assertions, rather than maintaining copies
+of scientific examples. Runtime test annotations describe fixtures and test
+data; they do not replace static `assert_type()` checks of public inference.
 
 ```sh
 python -m pyright --pythonpath /path/to/your/python

{unitx-0.14.2 → unitx-0.14.4}/examples/README.md

@@ -1,5 +1,10 @@
 # Scientific examples
 
+For a small extension without optional dependencies, see
+[Extending Quantity: complex impedances](impedance.md). Its standalone Python
+script uses a Quantity subclass for series `+` and parallel `//` composition
+and calculates an RLC circuit with complex current and power.
+
 These notebooks use unitx for dimensional calculations and NumPy for numerical
 work. Each contains a model, assumptions, plots, and numerical checks. The
 material parameters and measurement draws are illustrative, not experimental data.
@@ -12,6 +17,7 @@ material parameters and measurement draws are illustrative, not experimental dat
 | [Optical attenuation](optical_attenuation.ipynb) | Transmission through absorbing layers | prod/multiply.reduce, input masks, Quantity initial, fixed-unit out |
 | [Pendulum uncertainty](pendulum_uncertainty.ipynb) | Correlated input uncertainties and Monte Carlo propagation | Mean/std/var units, mixed measurement units, explicit quantiles |
 | [Arrhenius fit](arrhenius_fit.ipynb) | Estimate activation energy from synthetic reaction rates | Absolute temperatures, regression boundary, parameter units and model-based standard errors |
+| [Smith chart](smith_chart.ipynb) | Series/parallel RLC impedance and reflection trajectories | Quantity subclass, complex arithmetic, explicit normalization and plotting boundary |
 
 ## Run
 
@@ -25,11 +31,14 @@ jupyter lab examples/
 
 Open a notebook and run all cells from the beginning. Use the current checkout
 so that all demonstrated APIs are available.
+Keep `smith_chart.ipynb` beside its companion `impedance.py` module.
 The examples do not download datasets or write files. Keep physical quantities in calculations;
 plot their `.value` and derive labels from their `.unit`. Convert only to choose
 a useful display scale or to align units at a numerical boundary. Quantiles use
 an explicit numerical boundary and reattach the input unit, without naming a
 variable after its unit. Display equations use `$$...$$`.
+Generate physical parameter labels from Quantity formatting or `to_latex()`;
+do not repeat their numerical values and unit spellings in plot strings.
 
 ## Keep Git history small
 

unitx-0.14.4/examples/impedance.md

@@ -0,0 +1,66 @@
+# Extending Quantity: complex impedances
+
+[impedance.py](impedance.py) is a standalone example, available from this checkout
+rather than the installed unitx API. Run it without optional dependencies:
+
+```sh
+python examples/impedance.py
+```
+
+Open [the Smith-chart notebook](smith_chart.ipynb) alongside this module to sweep
+an RLC network over frequency and plot its reflection coefficient. Keep both
+files in the same directory; the notebook imports the class from `impedance.py`.
+
+`Impedance` subclasses `Quantity` to represent the complex impedance of an ideal
+two-terminal circuit at a given angular frequency. A real value describes an
+ordinary resistor. The class adds `//` for parallel composition, while `+`
+represents series composition. Both return another Impedance and keep the left
+operand's unit. Conversion with `.to()` also returns an Impedance, allowing
+`(z1 + z2).to(si.kohm) // z3` and `z1 // z2 // z3`.
+
+For the convention $e^{i\omega t}$, ideal components have impedances
+
+$$Z_R=R, \qquad Z_L=i\omega L, \qquad Z_C=\frac{1}{i\omega C}.$$
+
+Series and parallel combinations follow
+
+$$Z_{\mathrm{series}}=Z_1+Z_2, \qquad
+Z_{\mathrm{parallel}}=\frac{Z_1Z_2}{Z_1+Z_2}.$$
+
+All impedances being combined must correspond to the **same frequency**. This
+class stores a value and unit, without recording or checking frequency. It does
+not model a frequency-dependent component or preserve the circuit topology.
+The script evaluates a 100 ohm, 10 mH, 1 microfarad series branch at 1 kHz,
+puts a 300 ohm resistor in parallel and applies a 12 V RMS voltage phasor.
+It calculates the current and complex power $S=VI^*$, retaining quantities
+throughout the circuit calculation. $\operatorname{Re}S$ is active power and
+$\operatorname{Im}S$ is reactive power; the latter retains its sign.
+
+The example accepts finite scalar `int`, `float`, `Fraction` and `complex`
+magnitudes, preserving their types at construction. Fraction inputs keep purely
+rational calculations exact; float and complex calculations follow Python's
+rounding rules. Decimal and arrays are outside this small model. Negative real
+and imaginary parts are accepted; the class imposes no passivity assumption.
+
+Parallel composition handles zero impedance explicitly, including two shorts.
+It rearranges the formula to avoid multiplying large magnitudes. Nonzero
+impedances with cancelling admittances, such as `100j` and `-100j` ohm at ideal
+parallel resonance, produce an infinite equivalent impedance. Infinity is
+outside this finite-value example, so that operation raises ZeroDivisionError.
+Use parentheses when mixing `+` and `//`: Python gives `//` higher precedence.
+
+Inherited multiplication and division return ordinary Quantity: voltage,
+current, admittance and power have their usual units. Ordinary operations such
+as subtraction also retain the base class's result behavior. Only addition of
+two Impedances, parallel composition and conversion preserve the extension
+type. Quantity's general subclass and serialization contracts stay unchanged.
+Mixing an Impedance with an ordinary Quantity in addition returns an ordinary
+Quantity in either operand order. For example, `z + 50 * si.ohm` loses the
+extension's `//` operation; construct `Impedance(50)` to compose circuit elements.
+The type annotations distinguish this mixed result from `z1 + z2`.
+The scalar `+=` operation follows the same rule, returning a new result rather
+than changing the original object. `//=` follows parallel composition.
+The example deliberately narrows the inherited addition and conversion
+signatures to its scalar model and str/Unit targets. Local Pyright annotations
+mark that specialization; it is not a general template for preserving all of
+Quantity's array and coordinate overloads.

unitx-0.14.4/examples/impedance.py

@@ -0,0 +1,121 @@
+"""A scalar Quantity extension for series and parallel complex impedances.
+
+Run `python examples/impedance.py` from the checkout. See `impedance.md` for the
+fixed-frequency model. Fraction inputs retain exact rational arithmetic;
+float and complex calculations follow ordinary Python numerical rules.
+"""
+
+from __future__ import annotations
+
+import cmath
+import math
+from fractions import Fraction
+from typing import cast, overload
+
+from unitx import Quantity, Unit
+from unitx._numerics import Scalar
+from unitx.exceptions import DimensionError
+from unitx.si import si
+
+type Number = int | float | Fraction | complex
+
+
+class Impedance(Quantity[Number]):
+    """A finite scalar impedance with `+` series and `//` parallel composition.
+
+    Values being combined must describe the same angular frequency. This class
+    stores the impedance value and unit, without frequency or circuit topology.
+    Open circuits (infinity), Decimal and arrays are outside this small model.
+    """
+
+    __slots__ = ()
+
+    def __init__(self, value: Number, unit: str | Unit = si.ohm) -> None:
+        if type(value) not in (int, float, Fraction, complex):
+            error_message = 'Impedance requires an int, float, Fraction or complex scalar.'
+            raise TypeError(error_message)
+        if isinstance(value, (float, complex)) and not cmath.isfinite(value):
+            error_message = 'Impedance must be finite.'
+            raise ValueError(error_message)
+        super().__init__(value, unit)
+        if self.dimension != si.ohm.dimension:
+            error_message = 'Impedance requires an impedance unit.'
+            raise DimensionError(error_message)
+
+    # This small extension intentionally specializes the broader Quantity
+    # signatures to scalar impedances and str/Unit conversion targets.
+    def value_in(self, unit: str | Unit, /) -> Number:  # pyright: ignore[reportIncompatibleMethodOverride]
+        # Scaling the explicitly supported numeric domain stays in that domain.
+        return cast(Number, super().value_in(unit))
+
+    @overload
+    def __add__(self, other: Impedance, /) -> Impedance: ...
+
+    @overload
+    def __add__(self, other: Quantity[Scalar] | Scalar, /) -> Quantity[Scalar]: ...
+
+    def __add__(self, other: object, /) -> Quantity[Scalar]:  # pyright: ignore[reportIncompatibleMethodOverride]
+        if not isinstance(other, Impedance):
+            return NotImplemented
+        return Impedance(self.value + other.value_in(self.unit), self.unit)
+
+    @overload
+    def __iadd__(self, other: Impedance, /) -> Impedance: ...
+
+    @overload
+    def __iadd__(self, other: Quantity[Scalar] | Scalar, /) -> Quantity[Scalar]: ...
+
+    def __iadd__(self, other: Quantity[Scalar] | Scalar, /) -> Quantity[Scalar]:  # pyright: ignore[reportIncompatibleMethodOverride]
+        return self + other
+
+    def __floordiv__(self, other: object, /) -> Impedance:
+        if not isinstance(other, Impedance):
+            return NotImplemented
+        left, right = self.value, other.value_in(self.unit)
+        if left == 0 or right == 0:
+            return Impedance(0, self.unit)
+        if left + right == 0:
+            error_message = 'Parallel admittances cancel; the equivalent impedance is infinite.'
+            raise ZeroDivisionError(error_message)
+        # Z1*Z2/(Z1+Z2), avoiding a large product. Complex values use modulus.
+        smaller, larger = (left, right) if abs(left) <= abs(right) else (right, left)
+        return Impedance(smaller / (1 + smaller / larger), self.unit)
+
+    def to(self, unit: str | Unit, /) -> Impedance:  # pyright: ignore[reportIncompatibleMethodOverride]
+        return Impedance(self.value_in(unit), unit)
+
+
+def main() -> None:
+    """Evaluate an RLC branch in parallel with a resistor, using RMS phasors."""
+    first = Impedance(Fraction(100))
+    second = Impedance(Fraction(1, 5), si.kohm)
+    parallel_resistors = first // second
+    assert parallel_resistors == Fraction(200, 3) * si.ohm
+    print(f'({first}) // ({second.to(first.unit)}) = {parallel_resistors}')
+
+    frequency = 1 * si.kHz
+    omega = 2 * math.pi * frequency
+    inductance = 10 * si.mH
+    capacitance = 1 * si.uF
+    inductor = Impedance(1j * (omega * inductance).value_in(si.ohm))
+    capacitor = Impedance(-1j * (1 / (omega * capacitance)).value_in(si.ohm))
+    series = first + inductor + capacitor
+    shunt = Impedance(300)
+    network = series // shunt
+    voltage = 12 * si.V  # Real RMS voltage phasor; the current may be complex.
+    current = voltage / network
+    current_value = current.value
+    assert isinstance(current_value, complex)
+    complex_power = voltage * Quantity(current_value.conjugate(), current.unit)
+
+    assert network.dimension == si.ohm.dimension
+    assert current.dimension == si.A.dimension
+    assert complex_power.dimension == si.W.dimension
+    assert current_value.real > 0 and current_value.imag > 0  # Net capacitive branch.
+    print(f'At {frequency}: series RLC = {series.to(si.ohm):.3f}')
+    print(f'With a {shunt} parallel branch: Z = {network.to(si.ohm):.3f}')
+    print(f'At {voltage} RMS: I = {current.to(si.mA):.3f}, S = {complex_power.to(si.W):.3f}')
+
+
+if __name__ == '__main__':
+    main()