rfnetwork 0.0.1__tar.gz

rfnetwork-0.0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ricklyon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rfnetwork-0.0.1/MANIFEST.in

@@ -0,0 +1,6 @@
+recursive-include rfnetwork/core *.cpp *.h *.c *.py
+recursive-include rfnetwork/core/lib/eigen/Eigen *
+recursive-exclude * *.so
+recursive-exclude * __pycache__
+recursive-exclude tests *
+recursive-exclude examples *

rfnetwork-0.0.1/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: rfnetwork
+Version: 0.0.1
+Summary: rf/microwave network and noise simulation tool
+Author-email: Rick Lyon <rlyon14@gmail.com>
+License-Expression: MIT
+Project-URL: repository, https://github.com/ricklyon/rfnetwork
+Keywords: rf,microwave,network,noise
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: np-struct
+Requires-Dist: mpl-markers
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: parameterized; extra == "dev"
+Requires-Dist: ipykernel; extra == "dev"
+Dynamic: license-file
+
+# rfnetwork
+
+rf/microwave network simulation tool

rfnetwork-0.0.1/README.md

@@ -0,0 +1,3 @@
+# rfnetwork
+
+rf/microwave network simulation tool

rfnetwork-0.0.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires      = ["setuptools >= 77.0.3", "wheel", "numpy >= 2.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rfnetwork"
+version = "0.0.1"
+description = "rf/microwave network and noise simulation tool"
+readme = "README.md"
+authors = [{ name = "Rick Lyon", email = "rlyon14@gmail.com" }]
+license = "MIT"
+license-files = ["LICENSE.txt"]
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["rf", "microwave", "network", "noise"]
+dependencies = [
+    "numpy>=2.0.0", "matplotlib", "scipy", "np-struct", "mpl-markers"
+]
+requires-python = ">=3.7"
+
+[project.optional-dependencies]
+dev = ["black", "flake8", "pytest", "parameterized", "ipykernel"]
+
+[tool.setuptools.packages.find]
+include = ["rfnetwork"]
+
+[tool.setuptools]
+include-package-data = true
+
+[project.urls]
+repository = "https://github.com/ricklyon/rfnetwork"

rfnetwork-0.0.1/rfnetwork/__init__.py

@@ -0,0 +1,7 @@
+from . core.units import const, conv
+from . component import Component, Component_SnP
+from . network import Network
+from . core import core
+from . import elements
+from . import plots
+from . import filters

rfnetwork-0.0.1/rfnetwork/component.py

@@ -0,0 +1,236 @@
+import numpy as np
+from np_struct import ldarray
+from pathlib import Path
+from scipy.interpolate import CubicSpline
+from copy import deepcopy as dcopy
+
+from abc import abstractmethod
+from typing import Tuple
+
+from . import touchstone, const, utils
+from . core import core
+from . import plots
+
+class Component(object):
+    
+    def __init__(self, shunt: bool = False, passive: bool = True, pnum: int = 2):
+        """
+        Parameters
+        ----------
+        shunt : bool, default: False
+            if True, port 2 of the component is grounded. Component must be a passive 2-port device.
+        passive : bool, default: True
+            if True, ``evaluate`` calls ``evaluate_sdata`` instead of ``evaluate_data`` and noise correlation
+            matrix is computed passively.
+        """
+        self._shunt = shunt
+        self._passive = passive
+        self._pnum = pnum
+
+    @property
+    def pnum(self):
+        return self._pnum
+    
+    def __or__(self, other):
+        """ Allows port to be indexed with the syntax: block|2 """
+        return (self, int(other))
+    
+    def equals(self, other):
+        """
+        Returns True if other is equivalent to this object. Subclasses must override this method with their own
+        checks and call ``super().equals(other)``.
+        """
+        self_class = self.__class__.__name__
+        other_class = other.__class__.__name__
+        return (self_class == other_class) and (self._shunt == other._shunt) and (self._passive == other._passive)
+    
+    @abstractmethod
+    def evaluate_data(self, frequency: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Returns s-matrix and noise correlation matrix
+        """
+        raise NotImplementedError()
+    
+    @abstractmethod
+    def evaluate_sdata(self, frequency: np.ndarray) -> np.ndarray:
+        """
+        Returns s-matrix data of the component.
+        """
+        raise NotImplementedError()
+    
+    def plot(self, frequency, *paths, fmt: str = "db", **kwargs):
+        """
+        
+        """
+        data = self.evaluate(frequency, noise=fmt in ["nf"])
+        return plots.plot(data, *paths, fmt=fmt, **kwargs)
+    
+    def evaluate(self, frequency: np.ndarray = None, noise: bool = False) -> dict:
+        """
+        Returns a dictionary with keys: "n" (noise correlation matrix) and "s" (s-matrix). 
+        """
+        # compute noise data only if not passive
+        if self._passive or not noise:
+            sdata = self.evaluate_sdata(frequency)
+            ndata = None
+
+        else:
+            sdata, ndata = self.evaluate_data(frequency)
+        
+        # ground port two of a 2-port device if shunted. 
+        if self._shunt:
+            # raises an error if not a 2-port
+            assert sdata.shape[-1] == 2, "must be 2-port"
+
+            short = np.full((len(frequency), 1, 1), -1, dtype="complex128")
+            _, shunt_data = core.connect(dict(s=sdata), dict(s=short), (2, 1), noise=False)
+
+            # connect port 1 to a junction so the open port can be connected to 2 other components
+            node = core.junction_sdata(frequency, 3)
+            _, shunt_data = core.connect(shunt_data, dict(s=node), (1, 1), noise=False)
+            sdata = shunt_data["s"]
+
+            # invalidate noise data, shunting active components is not supported.
+            ndata = None
+                
+        if noise and ndata is None:
+            assert core.is_passive(sdata), "Noise data not found for active component."
+            # get the noise correlation matrix
+            ndata = core.get_passive_ndata(sdata)
+            
+        # attempt to use the frequency vector already in the sdata if frequency is not provided.
+        if frequency is None:
+            if hasattr(sdata, "dim"):
+                frequency = sdata.dim["frequency"]
+            else:
+                raise RuntimeError("Frequency data not found in sdata.")
+
+        # cast data as labeled arrays
+        ret_data = dict()
+        pnum = sdata.shape[-2]
+        port_a = np.arange(1, pnum +1)
+
+        ret_data["s"] = ldarray(sdata, dim=dict(frequency=frequency, b=port_a, a=port_a))
+
+        if noise:
+            ret_data["n"] = ldarray(ndata, dim=dict(frequency=frequency, b=port_a, a=port_a))
+
+        if getattr(self, "_probe_data", None) is not None:
+            ret_data["probes"] = self._probe_data
+
+        return ret_data
+
+
+class Component_SnP(Component):
+    """
+    Component defined from a touchstone file (.snp)
+    """
+
+    def __init__(self, file: str | dict, state: str = None, shunt: bool = False, passive: bool = False):
+
+        if isinstance(file, (str, Path)):
+            self.file = dict(default=Path(file))
+
+        elif isinstance(file, dict):
+            self.file = dict(**{k: Path(v) for k,v in file.items()})
+
+        # check that all files have the same number of ports
+        pnums = np.array([utils.get_pnum_from_snp(v) for v in self.file.values()])
+        pnum = pnums[0]
+
+        # check that all files exist
+        if any([not v.exists() or not v.is_file() for v in self.file.values()]):
+            raise ValueError(f"File does not exist: {list(self.file.values())}")
+
+        if not np.all(pnums == pnum):
+            raise ValueError("Files must all have the same number of ports.")
+        
+        self._state = state if state is not None else tuple(self.file.keys())[0]
+        self._comments = []
+        self._data_cache = dict()
+
+        if shunt and not np.all(pnums == 2):
+            raise ValueError("Only 2-port components can be shunted.")
+        
+        # component might be passive, but don't assume that it is by default, check for passivity in evaluate_data
+        super().__init__(shunt=shunt, passive=passive, pnum=pnum)
+
+    def __call__(self, state: str = None):
+        # simple syntax for duplicating components in Network declarations, optionally with a different state.
+        # for example: 
+        # c1 = ComponentFromFile(<path>)
+        # c2 = sw()
+        nobj = dcopy(self)
+        nobj.set_state(state)
+
+        return nobj
+    
+    def equals(self, other):
+        
+        if not super().equals(other):
+            return False
+        
+        files_match = self.file[self.state] == other.file[other.state]
+        return self.state == other.state and files_match
+    
+    def evaluate_sdata(self, frequency: np.ndarray = None) -> np.ndarray:
+
+        # reading touchstones is slow, only read file if state hasn't been hit before
+        if self.state not in self._data_cache.keys():
+            filepath = self.file[self.state]
+            sdata, np_data, self._comments = touchstone.read_snp(filepath)
+            # store into cache
+            self._data_cache[self.state] = [sdata, np_data]
+
+        # otherwise load from cache
+        else:
+            sdata, np_data = self._data_cache[self.state]
+
+        # interpolate the s-parameters at the desired frequency points
+        if frequency is not None:
+            sp1 = CubicSpline(sdata.dim["frequency"], sdata, axis=-3)
+            sdata = sp1(frequency)
+
+        return sdata
+        
+
+    def evaluate_data(self, frequency: np.ndarray = None) -> Tuple[np.ndarray, np.ndarray]:
+
+        sdata = self.evaluate_sdata(frequency)
+
+        if frequency is None:
+            frequency = data.dim["frequency"]
+
+        # get noise parameters from cache
+        _, np_data = self._data_cache[self.state]
+
+        if np_data is not None:
+            # interpolate the noise parameters at the sdata frequency points, allow extrapolation
+            sp2 = CubicSpline(np_data.dim["frequency"], np_data, axis=-2)
+            np_data = sp2(frequency)
+
+            ndata = core.noise_params_to_ndata(np_data, sdata)
+
+        elif core.is_passive(sdata):
+            ndata = core.get_passive_ndata(sdata)
+
+        else:
+            raise RuntimeError("Noise parameters not available for active component.")
+        
+        return sdata, ndata
+
+    def set_state(self, state: str = None):
+        if state == self._state or state is None:
+            return
+
+        if state not in self.file.keys():
+            raise KeyError(f"Unrecognized state: {state}")
+        
+        self._state = state
+
+    @property
+    def state(self):
+        return self._state
+
+class ComponentFromData(Component):
+    pass

rfnetwork-0.0.1/rfnetwork/core/core.py

@@ -0,0 +1,260 @@
+import numpy as np
+from pathlib import Path
+from np_struct import ldarray
+
+from scipy.interpolate import CubicSpline
+from . units import const, conv
+from . import core_func
+
+
+def junction_sdata(frequency: np.ndarray, N: int) -> np.ndarray:
+    sdata = np.full((N, N), 2 / N, dtype="complex128")
+    np.fill_diagonal(sdata, (2 / N) - 1)
+    return np.broadcast_to(sdata, (len(frequency), N, N)).copy()
+    
+
+def connect(s1: dict, s2: dict, connections: list, probes: list = None, noise: bool = False):
+    """
+    Connect multiple ports between two components s1 and s2.
+    Connections is of the form [(s1 port, s2 port), (s1 port, s2 port), ...].
+    """
+    connections = np.atleast_2d(connections)
+
+    if probes is None:
+        probes = np.zeros(connections.shape)
+    else:
+        probes = np.atleast_2d(probes)
+
+    s1_b, s1_a = s1["s"].shape[-2:]
+    s2_b, s2_a = s2["s"].shape[-2:]
+
+    b_len = s1_b + s2_b
+    a_len = s1_a + s2_a
+    m1_shape = (s1["s"].shape[-3], b_len, b_len)
+    m2_shape = (s2["s"].shape[-3], b_len, a_len)
+
+    # create first matrix, starts with just the identity matrix
+    m1 = np.identity(b_len, dtype="complex128")
+    m1 = np.broadcast_to(m1, m1_shape).copy()
+
+    # create second matrix, this is a "block" diagonal matrix with S1, S2 down the diagonal
+    m2 = np.zeros(m2_shape, dtype="complex128")
+    m2[..., :s1_b, :s1_a] = s1["s"]
+    m2[..., s1_b:, s1_a:] = s2["s"]
+
+    cnx_col = []
+
+    cas_rows = np.arange(s1_b + s2_b)
+    # probe row indices should always be located at the bottom of each s-matrix block
+    s1_probes = cas_rows[s1_a: s1_b]
+    s2_probes = cas_rows[s1_b + s2_a: s1_b + s2_b]
+    # external rows indices
+    s1_ext = cas_rows[: s1_a]
+    s2_ext = cas_rows[s1_b: s1_b + s2_a]
+    
+    # move columns from m2 to m1 based on the connections
+    for i, (p1, p2) in enumerate(connections):
+        # if p1 or p2 are greater than the external number of ports, they are internal ports that cannot be 
+        # connected.
+        if p1 > s1_a or p2 > s2_a:
+            raise ValueError(
+                f"Cannot connect internal port numbers {p1}, {p2} with shapes: {s1.shape}, {s2.shape}"
+            )
+
+        # list of connected columns in the second matrix, these will be zero columns after the connection
+        cnx_col += [p1-1, s1_a + p2-1]
+
+        # move connected columns from m2 into m1
+        m1[..., :s1_b, s1_b + p2-1] = -m2[..., :s1_b, p1-1]
+        m1[..., s1_b:, p1-1] = -m2[..., s1_b:, s1_a + p2-1]
+
+        # if p1 or p2 is a probe port, move the row index of the connected port to the probe list
+        if probes[i][0]:
+            s1_probes = np.append(s1_probes, s1_ext[p1 - 1])
+        if probes[i][1]:
+            s2_probes = np.append(s2_probes, s2_ext[p2 - 1])
+
+    # remove the connected row indices from the external port section
+    s1_ext = np.delete(s1_ext, connections[:, 0] - 1)
+    s2_ext = np.delete(s2_ext, connections[:, 1] - 1)
+
+    # matrix inversion on square matrix m1
+    m1_inv = np.linalg.inv(m1)
+
+    # remove the columns of all connected ports
+    m2 = np.delete(m2, cnx_col, -1)
+
+    # row indices of the cascaded matrix in the desired order. S1 ports, S2 ports, followed by probe ports.
+    row_order = np.concatenate([s1_ext, s2_ext, s1_probes, s2_probes])
+
+    cas_data = dict(s=np.einsum("...ij,...jk->...ik", m1_inv[:, row_order], m2, optimize="greedy"))
+
+    if noise:
+        # get rows corresponding to the external ports, including the connected ports but excluding any previous probe
+        # rows
+        # split columns between the first and second component
+        rows_ext = np.concatenate([np.arange(s1_a), s1_b + np.arange(s2_a)])
+        m1_1 = np.array(m1_inv[:, rows_ext, :s1_a], order="C")
+        m1_2 = np.array(m1_inv[:, rows_ext, s1_a:], order="C")
+
+        # get the correlation matrices for each component
+        c1, c2 = np.array(s1["n"], order="C"), np.array(s2["n"], order="C")
+
+        f_len = s1["s"].shape[0] # number of frequencies
+        # run extension function to compute cascaded data, result is written to cas_ndata
+        cas_ndata = np.zeros((f_len, a_len, a_len), dtype="complex128")
+        core_func.cascade_noise_data(m1_1, m1_2, c1, c2, cas_ndata)
+
+        # delete the connected rows/columns
+        cas_ndata = np.delete(cas_ndata, cnx_col, axis=-1)
+        cas_ndata = np.delete(cas_ndata, cnx_col, axis=-2)
+
+        # save result to output dictionary
+        cas_data["n"] = cas_ndata
+
+    return row_order, cas_data
+
+def connect_self(s1: dict, p1: int, p2: int, probes: list = None, noise: bool = False):
+    """
+    Connect two ports between the same component.
+    """
+
+    if probes is None:
+        probes = np.zeros(2)
+    else:
+        probes = np.atleast_1d(probes)
+
+    s1_b, s1_a = s1["s"].shape[-2:]
+    m1_shape = (s1["s"].shape[-3], s1_b, s1_b)
+
+    # if p1 or p2 are greater than the external number of ports, they are internal probes that cannot be 
+    # connected.
+    if p1 > s1_a or p2 > s1_a:
+        raise ValueError(
+            f"Cannot connect internal port numbers {p1}, {p2} with shape: {s1.shape}"
+        )
+
+    # create first matrix, starts with just the identity matrix
+    m1 = np.identity(s1_b, dtype="complex128")
+    m1 = np.broadcast_to(m1, m1_shape).copy()
+
+    # create second matrix
+    m2 = np.array(s1["s"])
+    # move columns from m2 to m1 based on the connections
+    m1[..., p2-1] = m1[..., :, p2-1] - m2[..., :s1_b, p1-1]
+    m1[..., p1-1] = m1[..., :, p1-1] - m2[..., :s1_b, p2-1]
+
+    m1_inv = np.linalg.inv(m1)
+
+    # remove the columns of all connected ports
+    cnx_col = [p1 - 1, p2 - 1]
+    m2 = np.delete(m2, cnx_col, -1)
+    
+    cas_rows = np.arange(s1_b)
+    # probe row indices should always be located at the bottom of each s-matrix block
+    s1_ext = cas_rows[: s1_a]
+    s1_probes = cas_rows[s1_a: s1_b]
+
+    # if p1 or p2 is a probe port, move the row index of the connected port to the probe list
+    if probes[0]:
+        s1_probes = np.append(s1_probes, s1_ext[p1 - 1])
+    if probes[1]:
+        s1_probes = np.append(s1_probes, s1_ext[p2 - 1])
+
+    # delete the connected ports from the external rows
+    s1_ext = np.delete(s1_ext, [(p1 - 1), (p2 -1)])
+
+    # append the probe rows to the end of the external rows
+    row_order = np.concatenate([s1_ext, s1_probes])
+
+    cas_data = dict(s=np.einsum("...ij,...jk->...ik", m1_inv[:, row_order], m2, optimize="greedy"))
+
+    if noise:
+        # get rows corresponding to the external ports
+        m1_1 = np.array(m1_inv[:, :s1_a], order="C")
+        # get the correlation matrices for the component
+        c1 = np.array(s1["n"], order="C")
+
+        f_len = s1["s"].shape[-3] # number of frequencies
+        # run extension function to compute cascaded data, result is written to cas_ndata
+        cas_ndata = np.zeros((f_len, s1_a, s1_a), dtype="complex128")
+        core_func.cascade_self_noise_data(m1_1, c1, cas_ndata)
+
+        # remove connected rows/columns
+        cas_ndata = np.delete(cas_ndata, [(p1 - 1), (p2 -1)], axis=-1)
+        cas_ndata = np.delete(cas_ndata, [(p1 - 1), (p2 -1)], axis=-2)
+
+        # save result to output dictionary
+        cas_data["n"] = cas_ndata
+
+    return row_order, cas_data
+
+
+def noise_params_to_ndata(np_data: np.ndarray, sdata: np.ndarray):
+    """
+    Converts noise parameters into a 2x2 noise correlation matrix.
+    Frequency vectors of np_data and sdata must be identical.
+    """
+
+    N = sdata.shape[-1]
+    NFREQ = sdata.shape[-3]
+
+    if N != 2:
+        raise NotImplementedError("Noise parameters are only supported for 2-port networks.")
+
+    nf_min, gmma_opt, rn = np_data.T
+
+    # initialize noise wave matrix
+    ndata = np.zeros(shape=(NFREQ, 2, 2), dtype="complex128")
+
+    # constants, rn is already normalized.
+    t = (4 * rn * const.t0)
+
+    # pull out sdata for better readability
+    s11 = sdata[:, 0,0]
+    s21 = sdata[:, 1,0]
+
+    # convert nfmin to temperature
+    tmin = const.t0 * (nf_min - 1)
+
+    c2 = const.k*(np.abs(s21)**2) * (tmin + t * ((np.abs(gmma_opt)**2)/(np.abs(1 + gmma_opt)**2)))
+    c1 = const.k*tmin * (np.abs(s11)**2  -1) + ((const.k*t*np.abs(1-(s11*gmma_opt))**2)/(np.abs(1+gmma_opt)**2))
+    c1c2 = ((-np.conj(s21)*np.conj(gmma_opt)*const.k*t) / ( np.abs(1 + gmma_opt)**2)) + ((s11/s21)*c1)
+    c2c1 = np.conj(c1c2)
+
+    ndata[:, 0,0] = c1
+    ndata[:, 1,1] = c2
+    ndata[:, 0,1] = c1c2
+    ndata[:, 1,0] = c2c1
+
+    return ndata
+
+def get_passive_ndata(sdata: np.ndarray):
+    """
+    Correlation matrix for a passive network. Passivity is not verified.
+    """
+    # https://authors.library.caltech.edu/995/1/WEDieeemgwl91.pdf
+    
+    N = sdata.shape[-1]
+    idn = np.identity(N, dtype="complex128")
+    idn = np.broadcast_to(idn, sdata.shape).copy()
+
+    s_conj_T = np.transpose(sdata, (-3, -1, -2)).conj()
+    return (idn - np.einsum("...ij, ...jk->...ik", sdata, s_conj_T)) * const.k * const.t0
+
+def is_passive(sdata: np.ndarray):
+    return np.max(np.abs(sdata)) < 1.01
+
+def noise_figure_from_ndata(sdata: np.ndarray, ndata: np.ndarray, path: tuple, t0: float = 290):
+    """
+    Linear noise figure.
+    """
+    # path gain
+    s21 = sdata[:, path[0] - 1, path[1] - 1]
+    s21_m = s21 * s21.conj()
+    # output noise power of output port
+    nout = np.abs(ndata[:, path[0] - 1, path[0] - 1])
+    # device equivalent temperature
+    te = nout / (const.k * s21_m)
+    # noise figure
+    return (te / t0) + 1

rfnetwork-0.0.1/rfnetwork/core/inc/connect.h

@@ -0,0 +1,12 @@
+#ifndef CONNECT_H
+#define CONNECT_H
+
+int cascade_noise_data(
+    char * m1, char * m2, char * c1, char * c2, char * out, int flen, int m1_len, int m2_len
+);
+
+int cascade_self_noise_data(
+    char * m1, char * c1, char * out, int flen, int m1_len
+);
+
+#endif /* CONNECT_H */

rfnetwork-0.0.1/rfnetwork/core/lib/eigen/Eigen/AccelerateSupport

@@ -0,0 +1,52 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ACCELERATESUPPORT_MODULE_H
+#define EIGEN_ACCELERATESUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \ingroup Support_modules
+ * \defgroup AccelerateSupport_Module AccelerateSupport module
+ *
+ * This module provides an interface to the Apple Accelerate library.
+ * It provides the seven following main factorization classes:
+ * - class AccelerateLLT: a Cholesky (LL^T) factorization.
+ * - class AccelerateLDLT: the default LDL^T factorization.
+ * - class AccelerateLDLTUnpivoted: a Cholesky-like LDL^T factorization with only 1x1 pivots and no pivoting
+ * - class AccelerateLDLTSBK: an LDL^T factorization with Supernode Bunch-Kaufman and static pivoting
+ * - class AccelerateLDLTTPP: an LDL^T factorization with full threshold partial pivoting
+ * - class AccelerateQR: a QR factorization
+ * - class AccelerateCholeskyAtA: a QR factorization without storing Q (equivalent to A^TA = R^T R)
+ *
+ * \code
+ * #include <Eigen/AccelerateSupport>
+ * \endcode
+ *
+ * In order to use this module, the Accelerate headers must be accessible from
+ * the include paths, and your binary must be linked to the Accelerate framework.
+ * The Accelerate library is only available on Apple hardware.
+ *
+ * Note that many of the algorithms can be influenced by the UpLo template
+ * argument. All matrices are assumed to be symmetric. For example, the following
+ * creates an LDLT factorization where your matrix is symmetric (implicit) and
+ * uses the lower triangle:
+ *
+ * \code
+ * AccelerateLDLT<SparseMatrix<float>, Lower> ldlt;
+ * \endcode
+ */
+
+// IWYU pragma: begin_exports
+#include "src/AccelerateSupport/AccelerateSupport.h"
+// IWYU pragma: end_exports
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_ACCELERATESUPPORT_MODULE_H