rustplotlib 3.0.0__tar.gz → 4.0.0__tar.gz

{rustplotlib-3.0.0 → rustplotlib-4.0.0}/Cargo.lock

@@ -1368,7 +1368,7 @@ dependencies = [
 
 [[package]]
 name = "rustplotlib"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "ab_glyph",
  "numpy",

{rustplotlib-3.0.0 → rustplotlib-4.0.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustplotlib"
-version = "3.0.0"
+version = "4.0.0"
 edition = "2021"
 readme = "README.md"
 

{rustplotlib-3.0.0 → rustplotlib-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustplotlib
-Version: 3.0.0
+Version: 4.0.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -87,7 +87,7 @@ plt.show()
 
 ## What's Implemented
 
-### 2D Plot Types (30+ types)
+### 2D Plot Types (40+ types)
 | Function | Description |
 |---|---|
 | `plot()` | Line plots with color, linestyle, linewidth, markers, markevery, labels, alpha, zorder |
@@ -118,7 +118,16 @@ plt.show()
 | `stairs()` | Step-wise constant function with edges |
 | `ecdf()` | Empirical cumulative distribution |
 | `triplot()` | Triangulation edge drawing |
-| `pcolormesh()` / `pcolor()` already listed above |
+| `hist2d()` | 2D histogram heatmap |
+| `specgram()` | Spectrogram (STFT-based) |
+| `acorr()` / `xcorr()` | Auto/cross correlation |
+| `psd()` | Power spectral density (Welch) |
+| `magnitude_spectrum()` | FFT magnitude |
+| `angle_spectrum()` / `phase_spectrum()` | FFT phase |
+| `cohere()` / `csd()` | Coherence / cross spectral density |
+| `semilogx()` / `semilogy()` / `loglog()` | Convenience log-scale plots |
+| `arrow()` | Arrow drawing |
+| `axline()` | Infinite line through point with slope |
 
 ### 3D Plot Types (7 types)
 | Function | Description |
@@ -144,6 +153,9 @@ plt.show()
 | `add_subplot(projection='3d')` | Add 3D subplot |
 | `clf()` / `cla()` / `close()` | Clear and close figures |
 | `gcf()` / `gca()` | Get current figure/axes |
+| `subplot2grid()` | Subplot at specific grid position |
+| `fig.add_gridspec()` | GridSpec from figure |
+| `fig.legend()` | Figure-level legend |
 
 ### Axes Customization
 | Function | Description |
@@ -172,6 +184,13 @@ plt.show()
 | `axhspan()` / `axvspan()` | Shaded horizontal/vertical regions |
 | `hlines()` / `vlines()` | Multiple reference lines with bounds |
 | `colorbar()` | Color scale bar for imshow/contour |
+| `get_xlim()` / `get_ylim()` | Get current axis limits (functional) |
+| `clear()` | Clear all artists from axes |
+| `ax.set(**kwargs)` | Set multiple properties at once |
+| `minor=True` in set_xticks/yticks | Minor tick support |
+| `bar_label()` | Value labels on bars |
+| `set_xlabel(color=...)` | Label color customization |
+| `title(loc='left')` | Title alignment |
 
 ### Output Formats
 | Method | Description |
@@ -421,13 +440,14 @@ Contributions are welcome! This is an open-source project under the MIT license.
 4. PRs require at least 1 review before merging
 
 **Project stats:**
-- **45+ Rust source files** — 15,000+ lines of native code
-- **23 Python modules** — 4,000+ lines of API
-- **37+ artist types** (30 2D + 7 3D)
+- **45+ Rust source files** — 16,000+ lines of native code
+- **23 Python modules** — 5,000+ lines of API
+- **47+ plot functions** (40 2D + 7 3D)
 - **70+ colormaps** (35 base + 35 reversed)
-- **228 tests** passing
-- **12 formatters + 10 locators**
-- **RGB/RGBA imshow** support
+- **262 tests** passing
+- **12 formatters + 10 locators** (functional)
+- **RGB/RGBA imshow**, bilinear interpolation, heatmap annotations
+- **Signal processing**: specgram, psd, acorr, xcorr, coherence
 - **Zero `unsafe` blocks**
 
 **Priority areas for contribution:**

{rustplotlib-3.0.0 → rustplotlib-4.0.0}/README.md

@@ -67,7 +67,7 @@ plt.show()
 
 ## What's Implemented
 
-### 2D Plot Types (30+ types)
+### 2D Plot Types (40+ types)
 | Function | Description |
 |---|---|
 | `plot()` | Line plots with color, linestyle, linewidth, markers, markevery, labels, alpha, zorder |
@@ -98,7 +98,16 @@ plt.show()
 | `stairs()` | Step-wise constant function with edges |
 | `ecdf()` | Empirical cumulative distribution |
 | `triplot()` | Triangulation edge drawing |
-| `pcolormesh()` / `pcolor()` already listed above |
+| `hist2d()` | 2D histogram heatmap |
+| `specgram()` | Spectrogram (STFT-based) |
+| `acorr()` / `xcorr()` | Auto/cross correlation |
+| `psd()` | Power spectral density (Welch) |
+| `magnitude_spectrum()` | FFT magnitude |
+| `angle_spectrum()` / `phase_spectrum()` | FFT phase |
+| `cohere()` / `csd()` | Coherence / cross spectral density |
+| `semilogx()` / `semilogy()` / `loglog()` | Convenience log-scale plots |
+| `arrow()` | Arrow drawing |
+| `axline()` | Infinite line through point with slope |
 
 ### 3D Plot Types (7 types)
 | Function | Description |
@@ -124,6 +133,9 @@ plt.show()
 | `add_subplot(projection='3d')` | Add 3D subplot |
 | `clf()` / `cla()` / `close()` | Clear and close figures |
 | `gcf()` / `gca()` | Get current figure/axes |
+| `subplot2grid()` | Subplot at specific grid position |
+| `fig.add_gridspec()` | GridSpec from figure |
+| `fig.legend()` | Figure-level legend |
 
 ### Axes Customization
 | Function | Description |
@@ -152,6 +164,13 @@ plt.show()
 | `axhspan()` / `axvspan()` | Shaded horizontal/vertical regions |
 | `hlines()` / `vlines()` | Multiple reference lines with bounds |
 | `colorbar()` | Color scale bar for imshow/contour |
+| `get_xlim()` / `get_ylim()` | Get current axis limits (functional) |
+| `clear()` | Clear all artists from axes |
+| `ax.set(**kwargs)` | Set multiple properties at once |
+| `minor=True` in set_xticks/yticks | Minor tick support |
+| `bar_label()` | Value labels on bars |
+| `set_xlabel(color=...)` | Label color customization |
+| `title(loc='left')` | Title alignment |
 
 ### Output Formats
 | Method | Description |
@@ -401,13 +420,14 @@ Contributions are welcome! This is an open-source project under the MIT license.
 4. PRs require at least 1 review before merging
 
 **Project stats:**
-- **45+ Rust source files** — 15,000+ lines of native code
-- **23 Python modules** — 4,000+ lines of API
-- **37+ artist types** (30 2D + 7 3D)
+- **45+ Rust source files** — 16,000+ lines of native code
+- **23 Python modules** — 5,000+ lines of API
+- **47+ plot functions** (40 2D + 7 3D)
 - **70+ colormaps** (35 base + 35 reversed)
-- **228 tests** passing
-- **12 formatters + 10 locators**
-- **RGB/RGBA imshow** support
+- **262 tests** passing
+- **12 formatters + 10 locators** (functional)
+- **RGB/RGBA imshow**, bilinear interpolation, heatmap annotations
+- **Signal processing**: specgram, psd, acorr, xcorr, coherence
 - **Zero `unsafe` blocks**
 
 **Priority areas for contribution:**

{rustplotlib-3.0.0 → rustplotlib-4.0.0}/ROADMAP.md

@@ -4,50 +4,51 @@ Goal: Full matplotlib reimplementation in Rust.
 
 ---
 
-## DONE — v2.0.0
+## DONE — v3.0.0
 
-### 2D Plot Types (26 implemented)
-- [x] plot, scatter, bar, barh, hist, imshow, fill_between, fill_betweenx, fill
+### 2D Plot Types (40+ implemented)
+- [x] plot, scatter, bar, barh, hist, imshow (RGB/RGBA + bilinear), fill_between, fill_betweenx, fill
 - [x] errorbar, step, pie, boxplot, violinplot, stem
 - [x] contour, contourf, hexbin, quiver, streamplot
 - [x] stackplot, broken_barh, eventplot, pcolormesh/pcolor, matshow, sankey
+- [x] spy, stairs, ecdf, triplot, hist2d, arrow, axline
+- [x] specgram, acorr, xcorr, psd, magnitude_spectrum, angle_spectrum, phase_spectrum
+- [x] cohere, csd, semilogx, semilogy, loglog, radar
 
 ### 3D Plot Types (7 implemented)
 - [x] plot3D, scatter3D, plot_surface, plot_wireframe, bar3d, plot_trisurf, contour3D
 
-### Drawing Elements (10 implemented)
-- [x] arrow, axhline, axvline, axhspan, axvspan, axline, hlines, vlines, annotate, text
+### Drawing Elements (12 implemented)
+- [x] arrow, axhline, axvline, axhspan, axvspan, axline, hlines, vlines, annotate, text, table, colorbar
 
 ### Rendering
 - [x] PNG raster (tiny-skia), Native SVG (vector), PDF, Interactive window, GIF animation
+- [x] bbox_inches='tight' (real whitespace cropping)
 
 ### Customization
 - [x] Log scale, twinx/twiny, spines, tick_params, zorder, hatch patterns
-- [x] Colorbar, 6 style themes, 70+ colormaps, custom fonts, rcParams (30+ keys)
-- [x] bbox_inches='tight', bilinear interpolation, title loc, multi-group plot
+- [x] 6 style themes, 70+ colormaps (+ reversed), custom fonts, rcParams (30+ keys)
+- [x] Bilinear interpolation, title loc, multi-group plot, image extent, RGB/RGBA imshow
 - [x] Aspect ratio, invert axes, axis off, subplot_mosaic, suptitle, subplots_adjust
+- [x] Minor ticks, label colors, get_xlim/get_ylim (functional), axes clear
+- [x] 12 formatters + 10 locators (functional)
 
 ### Compatibility Modules (23)
-- [x] pyplot, style, animation, widgets, font_manager, ticker, patches, colors
+- [x] pyplot (50+ functions), style, animation, widgets, font_manager, ticker, patches, colors
 - [x] dates, gridspec, backends, mpl_toolkits.mplot3d, cm, collections, lines
 - [x] text, transforms, patheffects, spines, axes, figure, cycler
 
 ### Data Integration
-- [x] Pandas, NumPy, NaN handling, dates, categorical axes, imread/imsave
+- [x] Pandas, NumPy, NaN handling, dates, categorical axes, imread/imsave, Jupyter inline
 
 ### Security
 - [x] Zero unsafe, path validation, dimension limits, no panics on user input
 
 ---
 
-## IN PROGRESS — v3.0.0
+## IN PROGRESS — v4.0.0
 
-### Missing Plot Types
-- [ ] `spy()` — sparsity pattern visualization
-- [ ] `specgram()` — spectrogram
-- [ ] `acorr()` / `xcorr()` — auto/cross correlation
-- [ ] `angle_spectrum()` / `magnitude_spectrum()` / `phase_spectrum()`
-- [ ] `cohere()` — coherence plot
+### Remaining Plot Types
 - [ ] `csd()` / `psd()` — cross/power spectral density
 - [ ] `ecdf()` — empirical cumulative distribution
 - [ ] `stairs()` — step plot with edges

{rustplotlib-3.0.0 → rustplotlib-4.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rustplotlib"
-version = "3.0.0"
+version = "4.0.0"
 description = "Matplotlib drop-in replacement powered by Rust"
 requires-python = ">=3.9"
 dependencies = ["numpy"]

{rustplotlib-3.0.0 → rustplotlib-4.0.0}/python/rustplotlib/pyplot.py

@@ -350,9 +350,11 @@ class AxesProxy:
         return self
 
     def set_title(self, title, fontsize=None, loc=None, **kwargs):
+        self._title_cache = str(title)
         self._fig.axes_set_title(self._id, str(title), fontsize, loc)
 
     def set_xlabel(self, label, fontsize=None, color=None, **kwargs):
+        self._xlabel_cache = str(label)
         color_str = None
         if color is not None:
             color_str = str(color)
@@ -362,6 +364,7 @@ class AxesProxy:
         self._fig.axes_set_xlabel(self._id, str(label), fontsize, color_str)
 
     def set_ylabel(self, label, fontsize=None, color=None, **kwargs):
+        self._ylabel_cache = str(label)
         color_str = None
         if color is not None:
             color_str = str(color)
@@ -749,6 +752,13 @@ class AxesProxy:
                     method(*val)
                 else:
                     method(val)
+            elif key == 'title':
+                self.set_title(val)
+            elif key == 'xlabel':
+                self.set_xlabel(val)
+            elif key == 'ylabel':
+                self.set_ylabel(val)
+        return self
 
     def twinx(self):
         twin_id = self._fig.axes_twinx(self._id)
@@ -871,10 +881,10 @@ class AxesProxy:
         pass
 
     def get_xlim(self):
-        return (0, 1)  # stub
+        return self._fig.axes_get_xlim(self._id)
 
     def get_ylim(self):
-        return (0, 1)  # stub
+        return self._fig.axes_get_ylim(self._id)
 
     def get_xaxis(self):
         return AxisProxy()
@@ -917,6 +927,68 @@ class AxesProxy:
     def has_data(self):
         return True
 
+    def clear(self):
+        """Clear all artists from this axes."""
+        self._fig.axes_clear(self._id)
+
+    def cla(self):
+        """Clear current axes (alias for clear)."""
+        self.clear()
+
+    def get_lines(self):
+        """Return list of Line2D artists in this axes."""
+        return []
+
+    def get_legend(self):
+        """Return the legend for this axes, or None."""
+        return None
+
+    def get_title(self):
+        """Return the axes title."""
+        return getattr(self, '_title_cache', '')
+
+    def get_xlabel(self):
+        """Return the x-axis label."""
+        return getattr(self, '_xlabel_cache', '')
+
+    def get_ylabel(self):
+        """Return the y-axis label."""
+        return getattr(self, '_ylabel_cache', '')
+
+    @property
+    def patches(self):
+        """Return list of Patch artists."""
+        return []
+
+    @property
+    def lines(self):
+        """Return list of Line2D artists."""
+        return []
+
+    @property
+    def texts(self):
+        """Return list of Text artists."""
+        return []
+
+    @property
+    def images(self):
+        """Return list of image artists."""
+        return []
+
+    @property
+    def collections(self):
+        """Return list of Collection artists."""
+        return []
+
+    @property
+    def containers(self):
+        """Return list of container artists."""
+        return []
+
+    def remove(self):
+        """Remove this axes from the figure."""
+        pass
+
     def can_pan(self):
         return False
 
@@ -1214,6 +1286,201 @@ class AxesProxy:
         """Set margins around data."""
         pass  # stub
 
+    def specgram(self, x, NFFT=256, Fs=2, noverlap=128, cmap='viridis', **kwargs):
+        """Plot a spectrogram."""
+        x = np.asarray(x)
+
+        # Compute STFT
+        noverlap = min(noverlap, NFFT - 1)  # ensure step >= 1
+        step = NFFT - noverlap
+        num_segments = (len(x) - NFFT) // step + 1
+
+        spec = np.zeros((NFFT // 2 + 1, num_segments))
+        window = np.hanning(NFFT)
+
+        for i in range(num_segments):
+            start = i * step
+            segment = x[start:start + NFFT] * window
+            fft_result = np.fft.rfft(segment)
+            spec[:, i] = np.abs(fft_result) ** 2
+
+        # Convert to dB
+        spec = 10 * np.log10(spec + 1e-10)
+
+        # Plot as imshow
+        freqs = np.fft.rfftfreq(NFFT, d=1.0 / Fs)
+        times = np.arange(num_segments) * step / Fs
+
+        self.imshow(spec.tolist(), cmap=cmap, origin='lower',
+                    extent=[times[0], times[-1], freqs[0], freqs[-1]])
+        self.set_xlabel('Time')
+        self.set_ylabel('Frequency')
+
+        return spec, freqs, times
+
+    def acorr(self, x, maxlags=None, **kwargs):
+        """Plot autocorrelation."""
+        x = np.asarray(x)
+        x = x - x.mean()
+
+        if maxlags is None:
+            maxlags = len(x) - 1
+        maxlags = min(maxlags, len(x) - 1)
+
+        # Full autocorrelation
+        corr = np.correlate(x, x, mode='full')
+        corr = corr / corr[len(x) - 1]  # normalize
+
+        # Extract lags
+        lags = np.arange(-maxlags, maxlags + 1)
+        mid = len(x) - 1
+        acorr_vals = corr[mid - maxlags:mid + maxlags + 1]
+
+        self.stem(lags.tolist(), acorr_vals.tolist(), **kwargs)
+        self.set_xlabel('Lag')
+        self.set_ylabel('Autocorrelation')
+
+        return lags, acorr_vals
+
+    def xcorr(self, x, y, maxlags=None, **kwargs):
+        """Plot cross-correlation."""
+        x = np.asarray(x) - np.mean(x)
+        y = np.asarray(y) - np.mean(y)
+
+        if maxlags is None:
+            maxlags = max(len(x), len(y)) - 1
+
+        corr = np.correlate(x, y, mode='full')
+        norm = np.sqrt(np.sum(x**2) * np.sum(y**2))
+        if norm > 0:
+            corr = corr / norm
+
+        mid = len(x) - 1
+        lags = np.arange(-maxlags, maxlags + 1)
+        xcorr_vals = corr[mid - maxlags:mid + maxlags + 1]
+
+        self.stem(lags.tolist(), xcorr_vals.tolist(), **kwargs)
+        self.set_xlabel('Lag')
+        self.set_ylabel('Cross-correlation')
+
+        return lags, xcorr_vals
+
+    def psd(self, x, NFFT=256, Fs=2, **kwargs):
+        """Plot power spectral density."""
+        x = np.asarray(x)
+
+        freqs = np.fft.rfftfreq(NFFT, d=1.0 / Fs)
+
+        # Welch's method
+        step = NFFT // 2
+        num_segments = (len(x) - NFFT) // step + 1
+        window = np.hanning(NFFT)
+
+        psd_vals = np.zeros(NFFT // 2 + 1)
+        for i in range(num_segments):
+            start = i * step
+            segment = x[start:start + NFFT] * window
+            fft_result = np.fft.rfft(segment)
+            psd_vals += np.abs(fft_result) ** 2
+
+        psd_vals /= num_segments
+        psd_db = 10 * np.log10(psd_vals + 1e-10)
+
+        self.plot(freqs.tolist(), psd_db.tolist(), **kwargs)
+        self.set_xlabel('Frequency')
+        self.set_ylabel('Power/Frequency (dB/Hz)')
+        self.grid(True)
+
+        return psd_vals, freqs
+
+    def magnitude_spectrum(self, x, Fs=2, **kwargs):
+        """Plot magnitude spectrum."""
+        x = np.asarray(x)
+        freqs = np.fft.rfftfreq(len(x), d=1.0 / Fs)
+        spectrum = np.abs(np.fft.rfft(x))
+        self.plot(freqs.tolist(), spectrum.tolist(), **kwargs)
+        self.set_xlabel('Frequency')
+        self.set_ylabel('Magnitude')
+        return spectrum, freqs
+
+    def angle_spectrum(self, x, Fs=2, **kwargs):
+        """Plot angle spectrum."""
+        x = np.asarray(x)
+        freqs = np.fft.rfftfreq(len(x), d=1.0 / Fs)
+        spectrum = np.angle(np.fft.rfft(x))
+        self.plot(freqs.tolist(), spectrum.tolist(), **kwargs)
+        self.set_xlabel('Frequency')
+        self.set_ylabel('Angle (radians)')
+        return spectrum, freqs
+
+    def phase_spectrum(self, x, Fs=2, **kwargs):
+        """Plot phase spectrum (alias for angle_spectrum)."""
+        return self.angle_spectrum(x, Fs=Fs, **kwargs)
+
+    def cohere(self, x, y, NFFT=256, Fs=2, **kwargs):
+        """Plot coherence between two signals."""
+        x = np.asarray(x)
+        y = np.asarray(y)
+        freqs = np.fft.rfftfreq(NFFT, d=1.0 / Fs)
+
+        # Simplified coherence
+        Pxx = np.abs(np.fft.rfft(x[:NFFT])) ** 2
+        Pyy = np.abs(np.fft.rfft(y[:NFFT])) ** 2
+        Pxy = np.abs(np.fft.rfft(x[:NFFT]) * np.conj(np.fft.rfft(y[:NFFT]))) ** 2
+
+        coh = Pxy / (Pxx * Pyy + 1e-10)
+
+        self.plot(freqs.tolist(), coh.tolist(), **kwargs)
+        self.set_xlabel('Frequency')
+        self.set_ylabel('Coherence')
+        self.set_ylim(0, 1)
+
+        return coh, freqs
+
+    def csd(self, x, y, NFFT=256, Fs=2, **kwargs):
+        """Plot cross spectral density."""
+        x = np.asarray(x)
+        y = np.asarray(y)
+        freqs = np.fft.rfftfreq(NFFT, d=1.0 / Fs)
+        Pxy = np.fft.rfft(x[:NFFT]) * np.conj(np.fft.rfft(y[:NFFT]))
+        self.plot(freqs.tolist(), (10 * np.log10(np.abs(Pxy) + 1e-10)).tolist(), **kwargs)
+        self.set_xlabel('Frequency')
+        self.set_ylabel('Cross Spectral Density (dB)')
+        return Pxy, freqs
+
+    def hist2d(self, x, y, bins=10, cmap='viridis', **kwargs):
+        """Plot a 2D histogram."""
+        x = np.asarray(x)
+        y = np.asarray(y)
+
+        if isinstance(bins, int):
+            bins_x = bins_y = bins
+        else:
+            bins_x, bins_y = bins
+
+        H, xedges, yedges = np.histogram2d(x, y, bins=[bins_x, bins_y])
+
+        self.imshow(H.T.tolist(), cmap=cmap, origin='lower',
+                    extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
+
+        return H, xedges, yedges
+
+    def semilogx(self, *args, **kwargs):
+        """Plot with log scaling on the x axis."""
+        self._fig.axes_set_xscale(self._id, 'log')
+        return self.plot(*args, **kwargs)
+
+    def semilogy(self, *args, **kwargs):
+        """Plot with log scaling on the y axis."""
+        self._fig.axes_set_yscale(self._id, 'log')
+        return self.plot(*args, **kwargs)
+
+    def loglog(self, *args, **kwargs):
+        """Plot with log scaling on both axes."""
+        self._fig.axes_set_xscale(self._id, 'log')
+        self._fig.axes_set_yscale(self._id, 'log')
+        return self.plot(*args, **kwargs)
+
     def get_figure(self):
         """Return the FigureProxy that owns this axes."""
         return FigureProxy(self._fig, [self])
@@ -1584,7 +1851,8 @@ class FigureProxy:
             return AxesProxy(self._fig, idx)
 
     def get_axes(self):
-        return self._axes
+        n = self._fig.num_axes()
+        return [AxesProxy(self._fig, i) for i in range(n)]
 
     def get_size_inches(self):
         return (6.4, 4.8)  # default
@@ -1612,7 +1880,8 @@ class FigureProxy:
 
     @property
     def axes(self):
-        return self._axes
+        n = self._fig.num_axes()
+        return [AxesProxy(self._fig, i) for i in range(n)]
 
     @property
     def number(self):
@@ -1632,6 +1901,17 @@ class FigureProxy:
     def align_ylabels(self, axs=None):
         pass
 
+    def legend(self, *args, **kwargs):
+        """Add a figure-level legend (applies to last axes)."""
+        n = self._fig.num_axes()
+        if n > 0:
+            kw = {}
+            if 'loc' in kwargs:
+                kw['loc'] = kwargs['loc']
+            if 'ncol' in kwargs:
+                kw['ncol'] = int(kwargs['ncol'])
+            self._fig.axes_legend(n - 1, kw)
+
 
 def _to_list(data):
     # Handle pandas Series/Index
@@ -2331,7 +2611,8 @@ def clf():
 
 def cla():
     """Clear current axes."""
-    close()
+    if _current_figure is not None and _current_axes_id is not None:
+        _current_figure.axes_clear(_current_axes_id)
 
 
 def gcf():
@@ -2589,3 +2870,70 @@ def bar_label(container, labels=None, fmt='%g', label_type='edge', fontsize=None
     """Add labels on bar chart bars (module-level)."""
     _gca().bar_label(container, labels=labels, fmt=fmt, label_type=label_type,
                      fontsize=fontsize, **kwargs)
+
+
+# --- Signal processing / spectral plots ---
+
+def specgram(x, NFFT=256, Fs=2, noverlap=128, cmap='viridis', **kwargs):
+    """Plot a spectrogram."""
+    return _gca().specgram(x, NFFT=NFFT, Fs=Fs, noverlap=noverlap, cmap=cmap, **kwargs)
+
+
+def acorr(x, maxlags=None, **kwargs):
+    """Plot autocorrelation."""
+    return _gca().acorr(x, maxlags=maxlags, **kwargs)
+
+
+def xcorr(x, y, maxlags=None, **kwargs):
+    """Plot cross-correlation."""
+    return _gca().xcorr(x, y, maxlags=maxlags, **kwargs)
+
+
+def psd(x, NFFT=256, Fs=2, **kwargs):
+    """Plot power spectral density."""
+    return _gca().psd(x, NFFT=NFFT, Fs=Fs, **kwargs)
+
+
+def magnitude_spectrum(x, Fs=2, **kwargs):
+    """Plot magnitude spectrum."""
+    return _gca().magnitude_spectrum(x, Fs=Fs, **kwargs)
+
+
+def angle_spectrum(x, Fs=2, **kwargs):
+    """Plot angle spectrum."""
+    return _gca().angle_spectrum(x, Fs=Fs, **kwargs)
+
+
+def phase_spectrum(x, Fs=2, **kwargs):
+    """Plot phase spectrum (alias for angle_spectrum)."""
+    return _gca().phase_spectrum(x, Fs=Fs, **kwargs)
+
+
+def cohere(x, y, NFFT=256, Fs=2, **kwargs):
+    """Plot coherence between two signals."""
+    return _gca().cohere(x, y, NFFT=NFFT, Fs=Fs, **kwargs)
+
+
+def csd(x, y, NFFT=256, Fs=2, **kwargs):
+    """Plot cross spectral density."""
+    return _gca().csd(x, y, NFFT=NFFT, Fs=Fs, **kwargs)
+
+
+def hist2d(x, y, bins=10, cmap='viridis', **kwargs):
+    """Plot a 2D histogram."""
+    return _gca().hist2d(x, y, bins=bins, cmap=cmap, **kwargs)
+
+
+def semilogx(*args, **kwargs):
+    """Plot with log scaling on the x axis."""
+    return _gca().semilogx(*args, **kwargs)
+
+
+def semilogy(*args, **kwargs):
+    """Plot with log scaling on the y axis."""
+    return _gca().semilogy(*args, **kwargs)
+
+
+def loglog(*args, **kwargs):
+    """Plot with log scaling on both axes."""
+    return _gca().loglog(*args, **kwargs)