@@ -12,6 +12,7 @@
 - Fixed `QwtGraphic.toPixmap(size)`, `QwtGraphic.toImage()` and `QwtGraphic.toImage(size)`, which raised a `TypeError` (possibly aborting the process, as the painter was still active on the destroyed pixmap or image) instead of rendering the graphic: they now render it like `QwtGraphic.toPixmap()` ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
 - Fixed `QwtPlotMarker.legendIcon` for markers with a symbol, which raised an `AssertionError` or a `TypeError`: such markers can now be shown in a legend ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
 - Fixed `QwtPlotGrid.make`, which raised a `TypeError` when only some of the minor pen arguments (`mincolor`, `minwidth`, `minstyle`) were given: each of them is now honored, the missing ones taking their documented default value ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
+- Fixed `QwtPowerTransform`, which raised a `ValueError` when drawing a curve on an axis with a power scale (curve data are mapped as NumPy arrays), and an `AttributeError` with NumPy < 2.0 (`numpy.pow` does not exist there): it now transforms scalars (with unchanged results) as well as NumPy arrays, with any supported NumPy version ([Issue #115](https://github.com/PlotPyStack/PythonQwt/issues/115))
 
 ## Version 0.16.3
 
 
@@ -10,20 +10,29 @@
 which made the API raise an exception or ignore some of its arguments.
 """
 
+import math
+
+import numpy as np
 import pytest
 from qtpy import QtCore as QC
 from qtpy import QtGui as QG
 from qtpy import QtWidgets as QW
 
 from qwt import (
     QwtLegend,
+    QwtLinearScaleEngine,
     QwtPlot,
+    QwtPlotCurve,
     QwtPlotGrid,
     QwtPlotItem,
     QwtPlotMarker,
+    QwtPlotRenderer,
+    QwtScaleMap,
     QwtSymbol,
 )
 from qwt.graphic import QwtGraphic
+from qwt.plot_curve import series_to_polyline
+from qwt.transform import QwtPowerTransform
 
 RED = QG.QColor(QC.Qt.red)
 
@@ -196,6 +205,105 @@ def test_grid_make_without_minor_pen():
     del app
 
 
+# ---------------------------------------------------------------------------
+# QwtPowerTransform
+# ---------------------------------------------------------------------------
+
+POWER_VALUES = (-9.0, -2.5, -1.0, 0.0, 0.25, 1.0, 4.0, 100.0)
+
+
+def _cpp_transform(value, exponent):
+    """Reference: QwtPowerTransform::transform of Qwt C++"""
+    if value < 0.0:
+        return -math.pow(-value, 1.0 / exponent)
+    return math.pow(value, 1.0 / exponent)
+
+
+def _cpp_inv_transform(value, exponent):
+    """Reference: QwtPowerTransform::invTransform of Qwt C++"""
+    if value < 0.0:
+        return -math.pow(-value, exponent)
+    return math.pow(value, exponent)
+
+
+@pytest.mark.parametrize("exponent", (2, 3.0, 0.5))
+def test_power_transform_scalars(exponent):
+    """Scalars are transformed as in Qwt C++, keeping their sign"""
+    transform = QwtPowerTransform(exponent)
+    for value in POWER_VALUES:
+        result = transform.transform(value)
+        assert np.ndim(result) == 0
+        assert result == pytest.approx(_cpp_transform(value, exponent))
+        result = transform.invTransform(value)
+        assert np.ndim(result) == 0
+        assert result == pytest.approx(_cpp_inv_transform(value, exponent))
+
+
+@pytest.mark.parametrize("exponent", (2, 3.0, 0.5))
+def test_power_transform_arrays(exponent):
+    """Arrays are transformed element-wise, and back"""
+    transform = QwtPowerTransform(exponent)
+    values = np.array(POWER_VALUES)
+    expected = [_cpp_transform(value, exponent) for value in POWER_VALUES]
+    np.testing.assert_allclose(transform.transform(values), expected)
+    expected = [_cpp_inv_transform(value, exponent) for value in POWER_VALUES]
+    np.testing.assert_allclose(transform.invTransform(values), expected)
+    roundtrip = transform.invTransform(transform.transform(values))
+    np.testing.assert_allclose(roundtrip, values, atol=1e-12)
+
+
+def test_power_transform_without_numpy_pow(monkeypatch):
+    """QwtPowerTransform does not need `numpy.pow` (added in NumPy 2.0)"""
+    monkeypatch.delattr(np, "pow", raising=False)
+    transform = QwtPowerTransform(2)
+    assert transform.transform(-9.0) == pytest.approx(-3.0)
+    assert transform.invTransform(-3.0) == pytest.approx(-9.0)
+
+
+def test_power_transform_scale_map():
+    """A scale map with a power transformation maps arrays like scalars"""
+    smap = QwtScaleMap()
+    smap.setTransformation(QwtPowerTransform(2))
+    smap.setScaleInterval(-100.0, 100.0)
+    smap.setPaintInterval(0.0, 400.0)
+    values = np.array(POWER_VALUES)
+    expected = [smap.transform(value) for value in POWER_VALUES]
+    np.testing.assert_allclose(smap.transform(values), expected)
+
+
+def test_power_transform_curve_rendering():
+    """A curve can be drawn on an axis with a power transformation"""
+    app = _ensure_app()  # keep a reference alive for the duration of the test
+    plot = QwtPlot()
+    plot.resize(400, 300)
+    engine = QwtLinearScaleEngine()
+    engine.setTransformation(QwtPowerTransform(2))
+    plot.setAxisScaleEngine(QwtPlot.yLeft, engine)
+    plot.setAxisScale(QwtPlot.yLeft, -100.0, 100.0)
+    x = np.linspace(-10.0, 10.0, 21)
+    curve = QwtPlotCurve.make(x, x * np.abs(x), plot=plot)
+    plot.replot()
+
+    xmap = plot.canvasMap(QwtPlot.xBottom)
+    ymap = plot.canvasMap(QwtPlot.yLeft)
+    polyline = series_to_polyline(xmap, ymap, curve.data(), 0, x.size - 1)
+    for index in range(x.size):
+        point = polyline[index]
+        sample = curve.data().sample(index)
+        assert point.x() == pytest.approx(xmap.transform(sample.x()))
+        assert point.y() == pytest.approx(ymap.transform(sample.y()))
+
+    image = QG.QImage(400, 300, QG.QImage.Format_ARGB32)
+    image.fill(QC.Qt.white)
+    painter = QG.QPainter(image)
+    try:
+        QwtPlotRenderer().render(plot, painter, QC.QRectF(0.0, 0.0, 400.0, 300.0))
+    finally:
+        painter.end()
+    plot.close()
+    del app
+
+
 if __name__ == "__main__":
     for name in ("toPixmap", "toImage"):
         test_graphic_conversion_default_size(name)
@@ -205,4 +313,6 @@ def test_grid_make_without_minor_pen():
         test_marker_legend_icon_with_symbol(size)
     test_marker_with_symbol_in_legend()
     test_grid_make_without_minor_pen()
+    test_power_transform_scale_map()
+    test_power_transform_curve_rendering()
     print("OK")
@@ -207,12 +207,14 @@ def copy(self):
 
 class QwtPowerTransform(QwtTransform):
     """
-    A transformation using `numpy.pow()`
+    A transformation using `numpy.power()`
 
     `QwtPowerTransform` preserves the sign of a value.
     F.e. a transformation with a factor of 2
     transforms a value of -3 to -9 and v.v. Thus `QwtPowerTransform`
     can be used for scales including negative values.
+
+    Values may be scalars or NumPy arrays (transformed element-wise).
     """
 
     def __init__(self, exponent):
@@ -223,33 +225,35 @@ def transform(self, value):
         """
         Transformation function
 
-        :param float value: Value
+        :param value: Value (scalar or NumPy array)
         :return: Modified value
 
         .. seealso::
 
             :py:meth:`invTransform()`
         """
-        if value < 0.0:
-            return -np.pow(-value, 1.0 / self.__exponent)
-        else:
-            return np.pow(value, 1.0 / self.__exponent)
+        return self.__signed_power(value, 1.0 / self.__exponent)
 
     def invTransform(self, value):
         """
         Inverse transformation function
 
-        :param float value: Value
+        :param value: Value (scalar or NumPy array)
         :return: Modified value
 
         .. seealso::
 
             :py:meth:`transform()`
         """
-        if value < 0.0:
-            return -np.pow(-value, self.__exponent)
-        else:
-            return np.pow(value, self.__exponent)
+        return self.__signed_power(value, self.__exponent)
+
+    @staticmethod
+    def __signed_power(value, exponent):
+        # Same as Qwt C++ (`value < 0.0 ? -pow(-value, e) : pow(value, e)`),
+        # element-wise for arrays: scalars give the same results as before
+        negative = np.less(value, 0.0)
+        result = np.power(np.where(negative, np.abs(value), value), exponent)
+        return np.where(negative, np.negative(result), result)[()]
 
     def copy(self):
         """