tikzplot42 0.5.8__tar.gz → 0.5.10__tar.gz

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.5.8
+Version: 0.5.10
 Summary: TikzPlot to make TikZ/PGFPlots plots with matplotlib.pyplot-like syntax.
 Author-email: Zan Ambrozic <zan.ambrozic7@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -745,6 +745,7 @@ Some basic plot commands are already implemented with commonly used arguments:
 #### Plotting
 - `plot()`,
 - `scatter()`,
+- `quiver()`,
 - `loglog()`,
 - `semilogx()/semilogy()`,
 - `errorbar()`,
@@ -765,6 +766,11 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `pie()`,
 - `pie_label()` (basic only for now),
 - `ecdf()` (empirical cumulative distribution function),
+- `magnitue_spectrum()`,
+- `phase_spectrum()`,
+- `angle_spectrum()`,
+- `specgram()`,
+- `psd()` (power spectral density),
 - `magnify()` (used to magnify part of a plot, but Tikz cannot handle `fill_between` if this one is used, which is a long known issue),
 - `axvline()/axhline()`,
 - `axvspan()/axhspan()` (background span).

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/README.md

@@ -45,6 +45,7 @@ Some basic plot commands are already implemented with commonly used arguments:
 #### Plotting
 - `plot()`,
 - `scatter()`,
+- `quiver()`,
 - `loglog()`,
 - `semilogx()/semilogy()`,
 - `errorbar()`,
@@ -65,6 +66,11 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `pie()`,
 - `pie_label()` (basic only for now),
 - `ecdf()` (empirical cumulative distribution function),
+- `magnitue_spectrum()`,
+- `phase_spectrum()`,
+- `angle_spectrum()`,
+- `specgram()`,
+- `psd()` (power spectral density),
 - `magnify()` (used to magnify part of a plot, but Tikz cannot handle `fill_between` if this one is used, which is a long known issue),
 - `axvline()/axhline()`,
 - `axvspan()/axhspan()` (background span).

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tikzplot42"
-version = "0.5.8"
+version = "0.5.10"
 description = "TikzPlot to make TikZ/PGFPlots plots with matplotlib.pyplot-like syntax."
 authors = [
     { name = "Zan Ambrozic", email = "zan.ambrozic7@gmail.com" }

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/src/tikzplot/axes.py

@@ -225,6 +225,67 @@ class BaseAxes:
         except: pass
         
         return self._plot(x, y, **kwargs, ls="", settings={"scatter": None})
+
+    def quiver(self, *args, **kwargs):
+        kws = {"pivot", "scale", "color", "c", "alpha", "cmap", "width", "linewidth", "lw"}
+        kwargs = self._check_kwargs("quiver", kws, **kwargs)
+        X = Y = C = None
+        if len(args) == 2:
+            U, V = _np.atleast_1d(*args)
+        elif len(args) == 3:
+            U, V, C = _np.atleast_1d(*args)
+        elif len(args) == 4:
+            X, Y, U, V = _np.atleast_1d(*args)
+        elif len(args) == 5:
+            X, Y, U, V, C = _np.atleast_1d(*args)
+        else:
+            raise Warning("Invalid number of arguments for quiver. Expected 2 to 5 arguments.")
+        nr, nc = (1, U.shape[0]) if U.ndim == 1 else U.shape
+        if X is not None and Y is not None:
+            X, Y = X.ravel(), Y.ravel()
+            if len(X) == nc and len(Y) == nr:
+                X, Y = (a.ravel() for a in _np.meshgrid(X, Y))
+            elif len(X) != len(Y):
+                raise Warning("X and Y must have the same length.")
+        else:
+            ind_grid = _np.meshgrid(_np.arange(nc), _np.arange(nr))
+            X, Y = (a.ravel() for a in ind_grid)
+        X, Y, U, V = (a.flatten() for a in (X, Y, U, V))
+        sc = kwargs.pop("scale", None)
+        if sc is not None:
+            U *= sc
+            V *= sc
+        pivot = kwargs.get("pivot", None)
+        if pivot is not None:
+            if pivot == "tail":
+                pass
+            elif pivot == "middle":
+                X -= U / 2
+                Y -= V / 2
+            elif pivot == "tip":
+                X -= U
+                Y -= V
+            else:
+                raise Warning(f"Invalid pivot: {pivot}. Must be one of 'tail', 'middle', or 'tip'.")
+        if C is not None:
+            cmap = kwargs.get("cmap", "viridis")
+            kwargs["cmap"] = Colorbar(cmap=cmap, lower=_np.min(C), upper=_np.max(C))
+            if self._cmap_bar and self._cmap_bar != kwargs["cmap"]:
+                raise Warning("Multiple colormaps on same axis! Only one per axis is allowed.")
+            self._cmap_bar = kwargs["cmap"]
+            kwargs["C"] = C.flatten()
+        else:
+            kwargs["color"] = kwargs.get("color", kwargs.get("c", "k"))
+        kwargs["u"] = U
+        kwargs["v"] = V
+        if "width" in kwargs:
+            kwargs["line width"] = kwargs.pop("width")
+        settings = {}
+        settings["quiver"] = dict(u=r"\thisrow{u}", v=r"\thisrow{v}")
+        if "cmap" in kwargs:
+            settings["quiver"].update({"every arrow/.append style": "mapped color"})
+            settings["point meta"] = r"\thisrow{c}"
+        return self._plot(X, Y, **kwargs, settings=settings)
                         
     def semilogy(self, x, y, *args, **kwargs):
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
@@ -934,6 +995,123 @@ class BaseAxes:
             cum_weights = 1 - cum_weights
         return self.plot(x, cum_weights, **kwargs)
 
+    def _fft_core(self, x_win, n, sides, Fs) -> tuple[_np.ndarray, _np.ndarray]:
+        if sides == "onesided":
+            return _np.fft.rfft(x_win, n=n), _np.fft.rfftfreq(n, d=1.0 / Fs)
+        X, freqs = _np.fft.fft(x_win, n=n), _np.fft.fftfreq(n, d=1.0 / Fs)
+        return (_np.fft.fftshift(X), _np.fft.fftshift(freqs)) if sides == "twosided" else (X, freqs)
+
+    def _get_window(self, window, NFFT) -> _np.ndarray:
+        if window is None:
+            return _np.hanning(NFFT)
+        win = _np.asarray(window(_np.ones(NFFT)) if callable(window) else window)
+        if len(win) != NFFT:
+            raise ValueError(f"Window length ({len(win)}) must equal NFFT ({NFFT})")
+        return win
+
+    def _apply_detrend(self, s, detrend) -> _np.ndarray:
+        if detrend in (None, "none"):
+            return s
+        if detrend == "mean":
+            return s - _np.mean(s)
+        if detrend == "linear":
+            t = _np.arange(len(s), dtype=_np.float64)
+            return s - _np.polyval(_np.polyfit(t, s, 1), t)
+        if callable(detrend):
+            d = detrend(s)
+            assert isinstance(d, _np.ndarray) and d.shape == s.shape, "Detrending function must return an array of the same shape as input."
+            return d
+        raise ValueError(f"Unknown detrend option: {detrend}")
+
+    def _spect_helper(self, x, Fs=2.0, Fc=0.0, window=None, pad_to=None, sides="default"):
+        x = _np.asarray(x)
+        Fs, Fc, n_fft = float(Fs or 2.0), float(Fc or 0.0), pad_to or len(x)
+        sides = ("onesided" if _np.isrealobj(x) else "twosided") if sides == "default" else sides
+        win = self._get_window(window, len(x))
+        X, freqs = self._fft_core(x * win, n_fft, sides, Fs)
+        return X, freqs + Fc, win, sides, n_fft
+
+    def _plot_spectrum(self, name, x, mode, ylabel, Fs=2.0, Fc=0.0, window=None, pad_to=None, sides="default", scale=None, **kwargs):
+        kws = {"alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
+        kwargs = self._check_kwargs(name, kws, **kwargs)
+        X, freqs, win, sides, n_fft = self._spect_helper(x, Fs=Fs, Fc=Fc, window=window, pad_to=pad_to, sides=sides)
+        if mode == "mag":
+            y = _np.abs(X) / _np.abs(win).sum()
+            if sides == "onesided":
+                y[1 : None if n_fft % 2 else -1] *= 2.0
+            if scale == "dB":
+                y, ylabel = 20 * _np.log10(y), "Magnitude (dB)"
+        elif mode == "phase":
+            y = _np.unwrap(_np.angle(X))
+        else:  # angle
+            y = _np.angle(X)
+        self.set_ylabel(ylabel)
+        if isinstance(self, Axes):
+            self.set_xlabel("Frequency")
+        return y, freqs, self.plot(freqs, y, **kwargs)
+
+    def magnitude_spectrum(self, x, *, Fs=2.0, Fc=0.0, window=None, pad_to=None, sides="default", scale=None, **kwargs):
+        return self._plot_spectrum("magnitude_spectrum", x, "mag", "Magnitude (energy)", Fs, Fc, window, pad_to, sides, scale, **kwargs)
+
+    def phase_spectrum(self, x, *, Fs=2.0, Fc=0.0, window=None, pad_to=None, sides="default", **kwargs):
+        return self._plot_spectrum("phase_spectrum", x, "phase", "Phase (radians)", Fs, Fc, window, pad_to, sides, **kwargs)
+
+    def angle_spectrum(self, x, *, Fs=2.0, Fc=0.0, window=None, pad_to=None, sides="default", **kwargs):
+        return self._plot_spectrum("angle_spectrum", x, "angle", "Angle (radians)", Fs, Fc, window, pad_to, sides, **kwargs)
+
+    def _ft_helper(self, x, NFFT=256, Fs=2.0, Fc=0.0, detrend=None, window=None, noverlap=0, pad_to=None, sides="default", scale_by_freq=True, mode="psd", scale="default") -> tuple[_np.ndarray, _np.ndarray, float]:
+        x = _np.asarray(x)
+        sides = ("onesided" if _np.isrealobj(x) else "twosided") if sides == "default" else sides
+        step, n_fft = NFFT - noverlap, pad_to or NFFT
+        if step <= 0 or n_fft < NFFT:
+            raise ValueError("Invalid noverlap or pad_to value")
+        win = self._get_window(window, NFFT)
+        num_segments = (len(x) - noverlap) // step
+        if num_segments == 0:
+            raise ValueError("Not enough data to compute spectrum")
+        mode = "psd" if mode in (None, "default") else mode.lower()
+        cols = []
+        for i in range(num_segments):
+            seg = self._apply_detrend(x[i * step : i * step + NFFT], detrend)
+            X, _ = self._fft_core(seg * win, n_fft, sides, Fs)
+            if mode in ("psd", "spectrum", "magnitude"):
+                is_p = mode in ("psd", "spectrum")
+                sf = ((Fs if mode == "psd" and scale_by_freq else 1.0) * (_np.abs(win) ** 2).sum()) if is_p else _np.abs(win).sum()
+                val = ((_np.abs(X) ** 2) if is_p else _np.abs(X)) / sf
+                if sides == "onesided":
+                    val[1 : None if n_fft % 2 else -1] *= 2.0
+            elif mode in ("angle", "phase"):
+                val = _np.angle(X)
+            else:
+                raise ValueError(f"Unknown mode: {mode}")
+            cols.append(val)
+        Pxx_matrix = _np.column_stack(cols)
+        if mode == "phase":
+            Pxx_matrix = _np.unwrap(Pxx_matrix, axis=0)
+        scale = ("dB" if mode in ("psd", "spectrum") else "linear") if scale in (None, "default") else scale.lower()
+        if scale == "dB":
+            mult = 20.0 if mode == "magnitude" else 10.0
+            Pxx_matrix = mult * _np.log10(_np.maximum(Pxx_matrix, 1e-20))
+        _, freqs = self._fft_core(win, n_fft, sides, Fs)
+        return Pxx_matrix, freqs + Fc, step
+
+    def specgram(self, x, *, NFFT=256, Fs=2.0, Fc=0.0, detrend=None, window=None, noverlap=0, pad_to=None, sides="default", scale_by_freq=True, mode="psd", scale="default", cmap="viridis", **kwargs):
+        Pxx, freqs, step = self._ft_helper(x, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, mode=mode, scale=scale)
+        t = (_np.arange(Pxx.shape[1]) * step + (NFFT / 2.0)) / Fs
+        if not isinstance(self, Axes):
+            raise Warning("specgram is only supported on primary axes.")
+        extent = [t[0], t[-1], freqs[0], freqs[-1]] if len(t) > 1 else None
+        return Pxx, freqs, t, self.imshow(Pxx, cmap=cmap, origin="lower", aspect="auto", extent=extent, **kwargs)
+
+    def psd(self, x, *, NFFT=256, Fs=2.0, Fc=0.0, detrend=None, window=None, noverlap=0, pad_to=None, sides="default", scale_by_freq=True, **kwargs):
+        kws = {"alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
+        kwargs = self._check_kwargs("psd", kws, **kwargs)
+        Pxx, freqs, _ = self._ft_helper(x, NFFT=NFFT, Fs=Fs, Fc=Fc, detrend=detrend, window=window, noverlap=noverlap, pad_to=pad_to, sides=sides, scale_by_freq=scale_by_freq, mode="psd", scale="linear")
+        self.set_ylabel("Power Spectral Density (dB/Hz)")
+        if isinstance(self, Axes):
+            self.set_xlabel("Frequency (Hz)")
+        return Pxx, freqs, self.plot(freqs, 10 * _np.log10(_np.mean(Pxx, axis=1)), **kwargs)
+        
     def pie(self, x, *, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, labeldistance=1.1, radius=1, startangle=0, counterclock=True, wedgeprops=None, rotate_labels=False, normalize=True):
         kws = {"width"}
         kwargs = self._check_kwargs("pie: wedgeprops", kws, **wedgeprops) if wedgeprops else {}

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/src/tikzplot/axes.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Sequence, Tuple, Union, Literal
+from typing import Any, Optional, Sequence, Tuple, Union, Literal, Callable
 import numpy as np
 from .colorbar import Colorbar
 from .elements import Graph
@@ -85,6 +85,37 @@ class BaseAxes:
             Colorbar limits for scatter points, if color is given sequence of floats and cmap is given as string, otherwise ignored. If cmap is given as str and no vmin or vmax is provided, they will be set to the min and max of color sequence.
         """
         ...
+
+    def quiver(self, *args, pivot: Literal["tail", "middle", "tip"]="tail", scale:float=1.0, alpha: float = 1.0, color: Optional[Union[Sequence[ColorLike], ColorLike]] = ..., c: Optional[ColorLike] = ...,
+             linewidth: Optional[float]= ..., lw: Optional[float] = ..., cmap: Optional[Union[str, Colorbar]] = ..., width: Optional[float] = ...) -> Graph:
+        """
+        Draw a quiver plot to the selected axis.
+
+        Parameters
+        ----------
+        args : ArrayLike
+            Datapoints for quiver plot, (X, Y, U, V, C) or (U, V) for grid (thus 2, 4 or 5 args).
+
+        pivot: {"tail", "middle", "tip"}, optional
+            The part of the arrow that is at the grid point. Default is "tail".
+
+        scale: float, optional
+            Scale factor for arrows. Default is 1.0.
+
+        alpha: float, optional
+            Opacity
+
+        color or c: ColorLike, optional:
+            all matplotlib color formats (without X11/xkcd)
+
+        width or linewidth or lw: float, optional
+            Line width in pt
+
+        cmap: str or list (R, G, B), optional
+            Colormap for quiver arrows, if color is given as float or sequence of floats. Can be a colormap name or a Colorbar object.
+        """
+        ...
+
     def semilogy(self, x: ArrayLike = ..., y: ArrayLike = ..., base: Optional[float] = 10,  fmt: Optional[str] = ...,*, alpha: float = 1.0, color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ...,
              linestyle: Optional[LineStyle] = ..., ls: Optional[LineStyle] = ..., linewidth: Optional[float]= ..., lw: Optional[float] = ...,
              marker: Optional[MarkerStyle] = ..., markersize: Optional[float] = ..., ms: Optional[float] = ...,  label:Optional[str]=...) -> Graph:
@@ -734,6 +765,270 @@ class BaseAxes:
         """
         ...
 
+    def magnitude_spectrum(self, x: ArrayLike, *, Fs: float = 2.0, Fc: float = 0.0, window: Optional[Union[str, np.ndarray]] = None, pad_to: Optional[int] = None, sides: Literal["default", "onesided", "twosided"] = "default", scale: Literal["default", "linear", "dB"] = "default", fmt: Optional[str] = ..., alpha: float = 1.0, color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ..., linestyle: Optional[LineStyle] = ..., ls: Optional[LineStyle] = ..., linewidth: Optional[float]= ..., lw: Optional[float] = ..., marker: Optional[MarkerStyle] = ..., markersize: Optional[float] = ..., ms: Optional[float] = ...,  label:Optional[str]=...) -> tuple[Sequence[float], Sequence[float], Graph]:
+        """
+        Draw the magnitude spectrum of a signal to the selected axis.
+
+        Parameters
+        ----------
+        x: ArrayLike
+            Input signal for which the magnitude spectrum is computed.
+
+        Fs: float, optional
+            Sampling frequency of the input signal. Default is 2.0.
+
+        Fc: float, optional
+            Center frequency for the spectrum. Default is 0.0.
+
+        window: str or ndarray, optional
+            Window function to apply to the signal before computing the spectrum. If None, no windowing is applied.
+
+        pad_to: int, optional
+            Length to which the signal is zero-padded before computing the FFT. If None, no padding is applied.
+
+        sides: {"default", "onesided", "twosided"}, optional
+            Specifies whether to return a one-sided or two-sided spectrum. Default is "default".
+
+        scale: {"default", "linear", "dB"}, optional
+            Scale of the magnitude spectrum. Default is "default".
+
+        fmt: str, optional
+            Style format string for the plot.
+
+        alpha: float, optional
+            Opacity of the plot.
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            Color of the line and markers.
+
+        linestyle or ls: str, optional
+            Line style for the magnitude spectrum plot.
+
+        linewidth or lw: float, optional
+            Line width in points for the magnitude spectrum plot.
+
+        marker: str, optional
+            Marker style for the data points in the magnitude spectrum plot.
+
+        markersize or ms: float, optional
+            Size of the markers in points.
+
+        label: str, optional
+            Legend entry for the magnitude spectrum plot.
+        """
+        ...
+
+    def phase_spectrum(self, x: ArrayLike, *, Fs: float = 2.0, Fc: float = 0.0, window: Optional[Union[str, np.ndarray]] = None, pad_to: Optional[int] = None, sides: Literal["default", "onesided", "twosided"] = "default", fmt: Optional[str] = ..., alpha: float = 1.0, color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ..., linestyle: Optional[LineStyle] = ..., ls: Optional[LineStyle] = ..., linewidth: Optional[float]= ..., lw: Optional[float] = ..., marker: Optional[MarkerStyle] = ..., markersize: Optional[float] = ..., ms: Optional[float] = ...,  label:Optional[str]=...) -> tuple[Sequence[float], Sequence[float], Graph]:
+        """
+        Draw the phase spectrum of a signal to the selected axis.
+
+        Parameters
+        ----------
+        x: ArrayLike
+            Input signal for which the magnitude spectrum is computed.
+
+        Fs: float, optional
+            Sampling frequency of the input signal. Default is 2.0.
+
+        Fc: float, optional
+            Center frequency for the spectrum. Default is 0.0.
+
+        window: str or ndarray, optional
+            Window function to apply to the signal before computing the spectrum. If None, no windowing is applied.
+
+        pad_to: int, optional
+            Length to which the signal is zero-padded before computing the FFT. If None, no padding is applied.
+
+        sides: {"default", "onesided", "twosided"}, optional
+            Specifies whether to return a one-sided or two-sided spectrum. Default is "default".
+
+        fmt: str, optional
+            Style format string for the plot.
+
+        alpha: float, optional
+            Opacity of the plot.
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            Color of the line and markers.
+
+        linestyle or ls: str, optional
+            Line style for the magnitude spectrum plot.
+
+        linewidth or lw: float, optional
+            Line width in points for the magnitude spectrum plot.
+
+        marker: str, optional
+            Marker style for the data points in the magnitude spectrum plot.
+
+        markersize or ms: float, optional
+            Size of the markers in points.
+
+        label: str, optional
+            Legend entry for the magnitude spectrum plot.
+        """
+        ...
+
+    def angle_spectrum(self, x: ArrayLike, *, Fs: float = 2.0, Fc: float = 0.0, window: Optional[Union[str, np.ndarray]] = None, pad_to: Optional[int] = None, sides: Literal["default", "onesided", "twosided"] = "default", fmt: Optional[str] = ..., alpha: float = 1.0, color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ..., linestyle: Optional[LineStyle] = ..., ls: Optional[LineStyle] = ..., linewidth: Optional[float]= ..., lw: Optional[float] = ..., marker: Optional[MarkerStyle] = ..., markersize: Optional[float] = ..., ms: Optional[float] = ...,  label:Optional[str]=...) -> tuple[Sequence[float], Sequence[float], Graph]:
+        """
+        Draw the angle spectrum of a signal to the selected axis.
+
+        Parameters
+        ----------
+        x: ArrayLike
+            Input signal for which the magnitude spectrum is computed.
+
+        Fs: float, optional
+            Sampling frequency of the input signal. Default is 2.0.
+
+        Fc: float, optional
+            Center frequency for the spectrum. Default is 0.0.
+
+        window: str or ndarray, optional
+            Window function to apply to the signal before computing the spectrum. If None, no windowing is applied.
+
+        pad_to: int, optional
+            Length to which the signal is zero-padded before computing the FFT. If None, no padding is applied.
+
+        sides: {"default", "onesided", "twosided"}, optional
+            Specifies whether to return a one-sided or two-sided spectrum. Default is "default".
+
+        fmt: str, optional
+            Style format string for the plot.
+
+        alpha: float, optional
+            Opacity of the plot.
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            Color of the line and markers.
+
+        linestyle or ls: str, optional
+            Line style for the magnitude spectrum plot.
+
+        linewidth or lw: float, optional
+            Line width in points for the magnitude spectrum plot.
+
+        marker: str, optional
+            Marker style for the data points in the magnitude spectrum plot.
+
+        markersize or ms: float, optional
+            Size of the markers in points.
+
+        label: str, optional
+            Legend entry for the magnitude spectrum plot.
+        """
+        ...
+
+    def specgram(self, x: ArrayLike, *, NFFT: int = 256, Fs: float = 2.0, Fc: float = 0.0, detrend: Optional[Union[str, Callable]] = None, window: Optional[Union[str, np.ndarray]] = None, noverlap: int = 0, pad_to: Optional[int] = None, sides: Literal["default", "onesided", "twosided"] = "default", scale_by_freq: bool = True, mode: Literal["psd", "spectrum", "magnitude", "phase", "angle"] = "psd", scale: Literal["default", "linear", "dB"] = "default", cmap: str = "viridis", **kwargs) -> tuple[ArrayLike, ArrayLike, ArrayLike, Graph]:
+        """
+        Draw a spectrogram to the selected axis.
+
+        Parameters
+        ----------
+        x: ArrayLike
+            Input signal for which the spectrogram is computed.
+
+        NFFT: int, optional
+            The number of data points used in each block for the FFT. Default is 256.
+
+        Fs: float, optional
+            Sampling frequency of the input signal. Default is 2.0.
+
+        Fc: float, optional
+            Center frequency for the spectrum. Default is 0.0.
+
+        detrend: str or callable, optional
+            Specifies how to detrend each segment. If None, no detrending is applied.
+
+        window: str or ndarray, optional
+            Window function to apply to each segment before computing the FFT. If None, no windowing is applied.
+
+        noverlap: int, optional
+            The number of points of overlap between segments. Default is 0.
+
+        pad_to: int, optional
+            Length to which each segment is zero-padded before computing the FFT. If None, no padding is applied.
+
+        sides: {"default", "onesided", "twosided"}, optional
+            Specifies whether to return a one-sided or two-sided spectrum. Default is "default".
+
+        scale_by_freq: bool, optional
+            If True (default), scale the power spectral density by the frequency bin width.
+
+        mode: {"psd", "spectrum", "magnitude", "phase", "angle"}, optional
+            Specifies what type of spectrum to compute. Default is "psd".
+
+        scale: {"default", "linear", "dB"}, optional
+            Scale of the spectrogram. Default is "default".
+
+        cmap: str, optional
+            Colormap for the spectrogram. Default is "viridis".
+
+        kwargs: additional keyword arguments for imshow.
+        """
+        ...
+
+    def psd(self, x: ArrayLike, *, NFFT: int = 256, Fs: float = 2.0, Fc: float = 0.0, detrend: Optional[Union[str, Callable]] = None, window: Optional[Union[str, np.ndarray]] = None, noverlap: int = 0, pad_to: Optional[int] = None, sides: Literal["default", "onesided", "twosided"] = "default", scale_by_freq: bool = True, fmt: Optional[str] = ..., alpha: float = 1.0, color: Optional[ColorLike] = ..., c: Optional[ColorLike] = ..., linestyle: Optional[LineStyle] = ..., ls: Optional[LineStyle] = ..., linewidth: Optional[float]= ..., lw: Optional[float] = ..., marker: Optional[MarkerStyle] = ..., markersize: Optional[float] = ..., ms: Optional[float] = ...,  label:Optional[str]=...) -> tuple[np.ndarray, np.ndarray, Graph]:
+        """
+        Draw a power spectral density (PSD) plot to the selected axis.
+
+        Parameters
+        ----------
+        x: ArrayLike
+            Input signal for which the PSD is computed.
+
+        NFFT: int, optional
+            The number of data points used in each block for the FFT. Default is 256.
+
+        Fs: float, optional
+            Sampling frequency of the input signal. Default is 2.0.
+
+        Fc: float, optional
+            Center frequency for the spectrum. Default is 0.0.
+
+        detrend: str or callable, optional
+            Specifies how to detrend each segment. If None, no detrending is applied.
+
+        window: str or ndarray, optional
+            Window function to apply to each segment before computing the FFT. If None, no windowing is applied.
+
+        noverlap: int, optional
+            The number of points of overlap between segments. Default is 0.
+
+        pad_to: int, optional
+            Length to which each segment is zero-padded before computing the FFT. If None, no padding is applied.
+
+        sides: {"default", "onesided", "twosided"}, optional
+            Specifies whether to return a one-sided or two-sided spectrum. Default is "default".
+
+        scale_by_freq: bool, optional
+            If True (default), scale the power spectral density by the frequency bin width.
+
+        fmt: str, optional
+            Style format string for the plot.
+
+        alpha: float, optional
+            Opacity of the plot.
+
+        color or c: all matplotlib color formats (without X11/xkcd), optional
+            Color of the line and markers.
+
+        linestyle or ls: str, optional
+            Line style for the PSD plot.
+
+        linewidth or lw: float, optional
+            Line width in points for the PSD plot.
+
+        marker: str, optional
+            Marker style for the data points in the PSD plot.
+
+        markersize or ms: float, optional
+            Size of the markers in points.
+
+        label: str, optional
+            Legend entry for the PSD plot.
+        """
+        ...
+
     def pie(self, x: ArrayLike, *, explode: Optional[ArrayLike] = None, labels: Optional[Sequence[str]] = None, colors: Optional[Sequence[ColorLike]] = None, autopct: Optional[str] = None, pctdistance: float = 0.6, labeldistance: float = 1.1, radius: float = 1.0, startangle: float = 0.0, counterclock: bool = True, wedgeprops: Optional[dict] = None, rotate_labels: bool = False, normalize: bool = True) -> Pie:
         """
         Draw a pie chart to the selected axis.

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/src/tikzplot/elements.py

@@ -302,6 +302,8 @@ class BaseGraph:
                     self._p_dict[i] = self._st_dict[st]
                 opts["point meta"] = "explicit symbolic"
                 opts["scatter/classes"] = f"{{\n" + ',\n'.join(f"{v}={{{k}}}" for k,v in self._st_dict.items()) + "\n}"
+        if "quiver" in self._settings:
+            opts["-stealth"] = None
         self._style_str = ""
         for o in opts:
             if opts[o] is None:
@@ -475,6 +477,13 @@ class Graph(BaseGraph):
             self._st_dict = {}
             self._p_dict = {}
             self._colors = None
+        if "quiver" in self._settings:
+            self._u = self._style.pop("u", None)
+            self._v = self._style.pop("v", None)
+            self._c = None
+            if "cmap" in self._style and "C" in self._style:
+                self._has_color = True
+                self._c = self._style.pop("C", None)
         if "axvline" in settings or "axhline" in settings or "axvspan" in settings or "axhspan" in settings:
             self._x, self._y=coordinates
         elif isinstance(coordinates, tuple):
@@ -544,6 +553,10 @@ class Graph(BaseGraph):
                     cols.append("label")                
             if self._sizes is not None:
                     cols.append("size")
+        elif "quiver" in self._settings:
+            cols += ["u", "v"]
+            if self._c is not None:
+                cols.append("c")
         elif self._meta is not None:
             cols.append("meta")
         return " ".join(cols)
@@ -570,6 +583,11 @@ class Graph(BaseGraph):
                         line.append(self._p_dict[i])
                 if self._sizes is not None:
                     line.append(f"{self._sizes[i]:.9f} pt")
+            elif "quiver" in self._settings:
+                line.append(self._u[i])
+                line.append(self._v[i])
+                if self._c is not None:
+                    line.append(self._c[i])
             elif self._meta is not None:
                 line.append(str(self._meta[i]))
             rows.append(" ".join(str(v) for v in line))
@@ -840,6 +858,11 @@ class Graph(BaseGraph):
                         self._colors = self._colors[mask]
                     if self._sizes is not None:
                         self._sizes = self._sizes[mask]
+                elif "quiver" in self._settings:
+                    self._u = self._u[mask]
+                    self._v = self._v[mask]
+                    if self._c is not None:
+                        self._c = self._c[mask]
 
     def _check_equal(self, x,y):
         if self._classic:
@@ -918,6 +941,11 @@ class Graph(BaseGraph):
                                 self._colors = self._colors[mask]
                             if self._sizes is not None:
                                 self._sizes = self._sizes[mask]
+                        if "quiver" in self._settings:
+                            self._u = self._u[mask]
+                            self._v = self._v[mask]
+                            if self._c is not None:
+                                self._c = self._c[mask]
 
 class Graph3(BaseGraph):
     def __init__(self, axes, coordinates, settings={}, xerr=None, yerr=None, zerr=None, path_name=None, **style):

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/src/tikzplot/figure.py

@@ -268,7 +268,7 @@ class Figure:
             del self._axes[key]
             del ax
 
-    def colorbar(self, mappable, cax=None, location=None, orientation=None, shrink=1, pad=None, ticks=None, label=None):
+    def colorbar(self, mappable, ax=None, location=None, orientation=None, shrink=1, pad=None, ticks=None, label=None):
         horizontal = False
         if orientation is not None:
             if orientation == "horizontal":
@@ -282,7 +282,7 @@ class Figure:
                 location = "bottom"
             else:
                 location = "right"
-        cbar = Colorbar(mappable, axis=cax, location=location, horizontal=horizontal, rel_len=shrink, pad=pad, ticks=ticks, label=label)
+        cbar = Colorbar(mappable, axis=ax, location=location, horizontal=horizontal, rel_len=shrink, pad=pad, ticks=ticks, label=label)
         return cbar
     
     def _compute_group_spacing(self, cpy=None):

{tikzplot42-0.5.8 → tikzplot42-0.5.10}/src/tikzplot/figure.pyi

@@ -118,7 +118,7 @@ class Figure:
         """
         ...
 
-    def colorbar(self, mappable: Any, *, cax: Optional[Axes | Axes3] = None, location: Literal["right", "left", "top", "bottom"] | None = None, orientation: Literal["horizontal", "vertical"] | None = None, shrink: float = 1.0, pad: float |None= None, ticks: Sequence[float] | None = None, label: str | None = None) -> Colorbar:
+    def colorbar(self, mappable: Any, *, ax: Optional[Axes | Axes3] = None, location: Literal["right", "left", "top", "bottom"] | None = None, orientation: Literal["horizontal", "vertical"] | None = None, shrink: float = 1.0, pad: float |None= None, ticks: Sequence[float] | None = None, label: str | None = None) -> Colorbar:
         """
         Add a colorbar to the figure.
 
@@ -127,7 +127,7 @@ class Figure:
         mappable : Any
             The object to which the colorbar applies (e.g. imshow).
 
-        cax : Axes or Axes3, optional
+        ax : Axes or Axes3, optional
             The axes in which to draw the colorbar. If None, colorbar will not be shown.
 
         location : str, optional