Renamed qwt.math to qwt._math (+ some simplifications)

Author: PierreRaybaut

qwt/math.py renamed to qwt/_math.py

@@ -1,68 +1,68 @@
-# -*- coding: utf-8 -*-
-#
-# Licensed under the terms of the Qwt License
-# Copyright (c) 2002 Uwe Rathmann, for the original C++ code
-# Copyright (c) 2015 Pierre Raybaut, for the Python translation/optimization
-# (see LICENSE file for more details)
-
-from .qt.QtCore import qFuzzyCompare
-
-import numpy as np
-
-
-def qwtFuzzyCompare(value1, value2, intervalSize):
-    eps = abs(1.e-6*intervalSize)
-    if value2 - value1 > eps:
-        return -1
-    elif value1 - value2 > eps:
-        return 1
-    else:
-        return 0
-
-def qwtFuzzyGreaterOrEqual(d1, d2):
-    return (d1 >= d2) or qFuzzyCompare(d1, d2)
-
-def qwtFuzzyLessOrEqual(d1, d2):
-    return (d1 <= d2) or qFuzzyCompare(d1, d2)
-
-def qwtSign(x):
-    if x > 0.:
-        return 1
-    elif x < 0.:
-        return -1
-    else:
-        return 0
-
-def qwtSqr(x):
-    return x**2
-
-def qwtFastAtan(x):
-    if x < -1.:
-        return -.5*np.pi - x/(x**2 + .28)
-    elif x > 1.:
-        return .5*np.pi - x/(x**2 + .28)
-    else:
-        return x/(1. + x**2*.28)
-
-def qwtFastAtan2(y, x):
-    if x > 0:
-        return qwtFastAtan(y/x)
-    elif x < 0:
-        d = qwtFastAtan(y/x)
-        if y >= 0:
-            return d + np.pi
-        else:
-            return d - np.pi
-    elif y < 0.:
-        return -.5*np.pi
-    elif y > 0.:
-        return .5*np.pi
-    else:
-        return 0.
-
-def qwtRadians(degrees):
-    return degrees * np.pi/180.
-
-def qwtDegrees(radians):
-    return radians * 180./np.pi
-
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the Qwt License
+# Copyright (c) 2002 Uwe Rathmann, for the original C++ code
+# Copyright (c) 2015 Pierre Raybaut, for the Python translation/optimization
+# (see LICENSE file for more details)
+
+from .qt.QtCore import qFuzzyCompare
+
+import numpy as np
+
+
+def qwtFuzzyCompare(value1, value2, intervalSize):
+    eps = abs(1.e-6*intervalSize)
+    if value2 - value1 > eps:
+        return -1
+    elif value1 - value2 > eps:
+        return 1
+    else:
+        return 0
+
+def qwtFuzzyGreaterOrEqual(d1, d2):
+    return (d1 >= d2) or qFuzzyCompare(d1, d2)
+
+def qwtFuzzyLessOrEqual(d1, d2):
+    return (d1 <= d2) or qFuzzyCompare(d1, d2)
+
+def qwtSign(x):
+    if x > 0.:
+        return 1
+    elif x < 0.:
+        return -1
+    else:
+        return 0
+
+def qwtSqr(x):
+    return x**2
+
+def qwtFastAtan(x):
+    if x < -1.:
+        return -.5*np.pi - x/(x**2 + .28)
+    elif x > 1.:
+        return .5*np.pi - x/(x**2 + .28)
+    else:
+        return x/(1. + x**2*.28)
+
+def qwtFastAtan2(y, x):
+    if x > 0:
+        return qwtFastAtan(y/x)
+    elif x < 0:
+        d = qwtFastAtan(y/x)
+        if y >= 0:
+            return d + np.pi
+        else:
+            return d - np.pi
+    elif y < 0.:
+        return -.5*np.pi
+    elif y > 0.:
+        return .5*np.pi
+    else:
+        return 0.
+
+def qwtRadians(degrees):
+    return degrees * np.pi/180.
+
+def qwtDegrees(radians):
+    return radians * 180./np.pi
+

qwt/plot_curve.py

@@ -15,7 +15,7 @@
 
 from .text import QwtText
 from .plot import QwtPlotItem, QwtPlotItem_PrivateData
-from .math import qwtSqr
+from ._math import qwtSqr
 from .graphic import QwtGraphic
 from .plot_series import (QwtPlotSeriesItem, QwtSeriesStore, QwtSeriesData,
                           QwtPointArrayData)

qwt/plot_grid.py

@@ -16,8 +16,7 @@
 from .scale_div import QwtScaleDiv
 from .plot import QwtPlotItem
 from .text import QwtText
-from .painter import QwtPainter
-from .math import qwtFuzzyGreaterOrEqual, qwtFuzzyLessOrEqual
+from ._math import qwtFuzzyGreaterOrEqual, qwtFuzzyLessOrEqual
 
 from .qt.QtGui import QPen
 from .qt.QtCore import Qt

qwt/scale_draw.py

@@ -22,7 +22,7 @@
 from .scale_div import QwtScaleDiv
 from .scale_map import QwtScaleMap
 from .text import QwtText
-from .math import qwtRadians
+from ._math import qwtRadians
 
 from .qt.QtGui import QPalette, QFontMetrics, QTransform
 from .qt.QtCore import (Qt, qFuzzyCompare, QLocale, QRectF, QPointF, QRect,

qwt/scale_engine.py

@@ -30,35 +30,34 @@
 from .interval import QwtInterval
 from .scale_div import QwtScaleDiv
 from .transform import QwtLogTransform
-from .math import qwtFuzzyCompare
+from ._math import qwtFuzzyCompare
 from .transform import QwtTransform
 
 from .qt.QtCore import qFuzzyCompare
 
+import sys
+import math
 import numpy as np
 
-DBL_MAX = np.finfo(float).max
+DBL_MAX = sys.float_info.max
 LOG_MIN = 1.0e-100
 LOG_MAX = 1.0e100
 
 
-def qwtLog(base, value):
-    return np.log(value)/np.log(base)
-
 def qwtLogInterval(base, interval):
-    return QwtInterval(qwtLog(base, interval.minValue()),
-                       qwtLog(base, interval.maxValue()))
+    return QwtInterval(math.log(interval.minValue(), base),
+                       math.log(interval.maxValue(), base))
 
 def qwtPowInterval(base, interval):
-    return QwtInterval(np.power(base, interval.minValue()),
-                       np.power(base, interval.maxValue()))
+    return QwtInterval(math.pow(base, interval.minValue()),
+                       math.pow(base, interval.maxValue()))
 
 def qwtStepSize(intervalSize, maxSteps, base):
     """this version often doesn't find the best ticks: f.e for 15: 5, 10"""
     minStep = divideInterval(intervalSize, maxSteps, base)
     if minStep != 0.:
         #  # ticks per interval
-        numTicks = np.ceil(abs(intervalSize/minStep))-1
+        numTicks = math.ceil(abs(intervalSize/minStep))-1
         #  Do the minor steps fit into the interval?
         if qwtFuzzyCompare((numTicks+1)*abs(minStep),
                            abs(intervalSize), intervalSize) > 0:
@@ -82,7 +81,7 @@ def ceilEps(value, intervalSize):
     """
     eps = EPS*intervalSize
     value = (value-eps)/intervalSize
-    return np.ceil(value)*intervalSize
+    return math.ceil(value)*intervalSize
 
 def floorEps(value, intervalSize):
     """
@@ -98,7 +97,7 @@ def floorEps(value, intervalSize):
     """
     eps = EPS*intervalSize
     value = (value+eps)/intervalSize
-    return np.floor(value)*intervalSize
+    return math.floor(value)*intervalSize
 
 def divideEps(intervalSize, numSteps):
     """
@@ -129,14 +128,15 @@ def divideInterval(intervalSize, numSteps, base):
     if v == 0.:
         return 0.
 
-    lx = qwtLog(base, abs(v))
-    p = np.floor(lx)
-    fraction = np.power(base, lx-p)
+    lx = math.log(abs(v), base)
+    p = math.floor(lx)
+    print("p:", p)
+    fraction = math.pow(base, lx-p)
     n = base
     while n > 1 and fraction <= n/2:
         n /= 2
 
-    stepSize = n*np.power(base, p)
+    stepSize = n*math.pow(base, p)
     if v < 0:
         stepSize = -stepSize
 
@@ -580,7 +580,7 @@ def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
         minStep = qwtStepSize(stepSize, maxMinorSteps, self.base())
         if minStep == 0.:
             return
-        numTicks = int(np.ceil(abs(stepSize/minStep))-1)
+        numTicks = int(math.ceil(abs(stepSize/minStep))-1)
         medIndex = -1
         if numTicks % 2:
             medIndex = numTicks/2
@@ -653,8 +653,8 @@ def autoScale(self, maxNumSteps, x1, x2, stepSize):
         if x1 > x2:
             x1, x2 = x2, x1
         logBase = self.base()
-        interval = QwtInterval(x1/np.power(logBase, self.lowerMargin()),
-                               x2*np.power(logBase, self.upperMargin()))
+        interval = QwtInterval(x1/math.pow(logBase, self.lowerMargin()),
+                               x2*math.pow(logBase, self.upperMargin()))
         interval = interval.limited(LOG_MIN, LOG_MAX)
         if interval.maxValue()/interval.minValue() < logBase:
             linearScaler = QwtLinearScaleEngine()
@@ -670,9 +670,9 @@ def autoScale(self, maxNumSteps, x1, x2, stepSize):
 
             if linearInterval.maxValue()/linearInterval.minValue() < logBase:
                 if stepSize < 0.:
-                    stepSize = -qwtLog(logBase, abs(stepSize))
+                    stepSize = -math.log(abs(stepSize), logBase)
                 else:
-                    stepSize = qwtLog(logBase, stepSize)
+                    stepSize = math.log(stepSize, logBase)
                 return x1, x2, stepSize
 
         logRef = 1.
@@ -785,13 +785,13 @@ def buildMajorTicks(self, interval, stepSize):
         width = qwtLogInterval(self.base(), interval).width()
         numTicks = min([int(round(width/stepSize))+1, 10000])
 
-        lxmin = np.log(interval.minValue())
-        lxmax = np.log(interval.maxValue())
+        lxmin = math.log(interval.minValue())
+        lxmax = math.log(interval.maxValue())
         lstep = (lxmax-lxmin)/float(numTicks-1)
 
         ticks = [interval.minValue()]
         for i in range(1, numTicks-1):
-            ticks += [np.exp(lxmin+float(i)*lstep)]
+            ticks += [math.exp(lxmin+float(i)*lstep)]
         ticks += [interval.maxValue()]
         return ticks
 
@@ -851,7 +851,7 @@ def buildMinorTicks(self, ticks, maxMinorSteps, stepSize):
             if numTicks > 2 and numTicks % 2:
                 mediumTickIndex = numTicks/2
 
-            minFactor = max([np.power(logBase, minStep), float(logBase)])
+            minFactor = max([math.pow(logBase, minStep), float(logBase)])
 
             for tick in ticks[QwtScaleDiv.MajorTick]:
                 for j in range(numTicks):

qwt/scale_map.py

@@ -13,7 +13,7 @@
    :members:
 """
 
-from .math import qwtFuzzyCompare
+from ._math import qwtFuzzyCompare
 
 from .qt.QtCore import QRectF, QPointF
 

qwt/tests/no_margin.py

@@ -100,6 +100,6 @@ def show_layout_details(self):
 if __name__ == '__main__':
     app = QApplication([])
     plot = TestPlot()
-    plot.resize(300, 1000)
+    plot.resize(300, 650)
     plot.show()
     app.exec_()