Move apply_si_prefix into analyticsClass.py (fossasia#124)

bessman · web-flow · commit 203948fcf7a8 · 2020-07-24T17:40:26.000+03:00
* Move and refactor applySIPrefix

* Add unit tests for apply_si_prefix
diff --git a/PSL/analyticsClass.py b/PSL/analyticsClass.py
@@ -1,8 +1,9 @@
-from __future__ import print_function
-import time
+import math
+from typing import Tuple
 
 import numpy as np
 
+
 class analyticsClass():
     """
     This class contains methods that allow mathematical analysis such as curve fitting
@@ -37,13 +38,6 @@ def __init__(self):
         else:
             self.signal = signal
 
-        try:
-            from PSL.commands_proto import applySIPrefix as applySIPrefix
-        except ImportError:
-            self.applySIPrefix = None
-        else:
-            self.applySIPrefix = applySIPrefix
-
     def sineFunc(self, x, a1, a2, a3, a4):
         return a4 + a1 * np.sin(abs(a2 * (2 * np.pi)) * x + a3)
 
@@ -259,11 +253,11 @@ def sineFitAndDisplay(self, chan, displayObject):
             if fitres:
                 amp, freq, offset, phase = fitres
                 if amp > 0.05: fit = 'Voltage=%s\nFrequency=%s' % (
-                    self.applySIPrefix(amp, 'V'), self.applySIPrefix(freq, 'Hz'))
+                    apply_si_prefix(amp, 'V'), apply_si_prefix(freq, 'Hz'))
         except Exception as e:
-            fires = None
+            fitres = None
 
-        if not fitres or len(fit) == 0: fit = 'Voltage=%s\n' % (self.applySIPrefix(np.average(chan.get_yaxis()), 'V'))
+        if not fitres or len(fit) == 0: fit = 'Voltage=%s\n' % (apply_si_prefix(np.average(chan.get_yaxis()), 'V'))
         displayObject.setValue(fit)
         if fitres:
             return fitres
@@ -278,7 +272,7 @@ def rmsAndDisplay(self, data, displayObject):
         Fits against a sine function, and writes to the object
         '''
         rms = self.RMS(data)
-        displayObject.setValue('Voltage=%s' % (self.applySIPrefix(rms, 'V')))
+        displayObject.setValue('Voltage=%s' % (apply_si_prefix(rms, 'V')))
         return rms
 
     def RMS(self, data):
@@ -298,3 +292,71 @@ def butter_notch_filter(self, data, lowcut, highcut, fs, order=5):
         b, a = self.butter_notch(lowcut, highcut, fs, order=order)
         y = lfilter(b, a, data)
         return y
+
+
+SI_PREFIXES = {k: v for k, v in zip(range(-24, 25, 3), "yzafpnµm kMGTPEZY")}
+SI_PREFIXES[0] = ""
+
+
+def frexp10(x: float) -> Tuple[float, int]:
+    """Return the base 10 fractional coefficient and exponent of x, as pair (m, e).
+
+    This function is analogous to math.frexp, only for base 10 instead of base 2.
+    If x is 0, m and e are both 0. Else 1 <= abs(m) < 10. Note that m * 10**e is not
+    guaranteed to be exactly equal to x.
+
+    Parameters
+    ----------
+    x : float
+        Number to be split into base 10 fractional coefficient and exponent.
+
+    Returns
+    -------
+    (float, int)
+        Base 10 fractional coefficient and exponent of x.
+
+    Examples
+    --------
+    >>> frexp10(37)
+    (3.7, 1)
+    """
+    if x == 0:
+        coefficient, exponent = 0.0, 0
+    else:
+        log10x = math.log10(abs(x))
+        exponent = int(math.copysign(math.floor(log10x), log10x))
+        coefficient = x / 10 ** exponent
+
+    return coefficient, exponent
+
+
+def apply_si_prefix(value: float, unit: str, precision: int = 2) -> str:
+    """Scale :value: and apply appropriate SI prefix to :unit:.
+
+    Parameters
+    ----------
+    value : float
+        Number to be scaled.
+    unit : str
+        Base unit of :value: (without prefix).
+    precision : int, optional
+        :value: will be rounded to :precision: decimal places. The default value is 2.
+
+    Returns
+    -------
+    str
+        "<scaled> <prefix><unit>", such that 1 <= <scaled> < 1000.
+
+    Examples
+    -------
+    apply_si_prefix(0.03409, "V")
+    '34.09 mV'
+    """
+    coefficient, exponent = frexp10(value)
+    si_exponent = exponent - (exponent % 3)
+    si_coefficient = coefficient * 10 ** (exponent % 3)
+
+    if abs(si_exponent) > max(SI_PREFIXES):
+        raise ValueError("Exponent out of range of available prefixes.")
+
+    return f"{si_coefficient:.{precision}f} {SI_PREFIXES[si_exponent]}{unit}"
diff --git a/PSL/commands_proto.py b/PSL/commands_proto.py
@@ -1,4 +1,5 @@
-import math, sys, time, struct
+import struct
+
 
 # allows to pack numeric values into byte strings
 Byte = struct.Struct("B")  # size 1
@@ -252,34 +253,6 @@
 TWELVE_BIT = Byte.pack(12)
 
 
-def applySIPrefix(value, unit='', precision=2):
-    neg = False
-    if value < 0.:
-        value *= -1
-        neg = True
-    elif value == 0.:
-        return '0 '  # mantissa & exponnt both 0
-    exponent = int(math.log10(value))
-    if exponent > 0:
-        exponent = (exponent // 3) * 3
-    else:
-        exponent = (-1 * exponent + 3) // 3 * (-3)
-
-    value *= (10 ** (-exponent))
-    if value >= 1000.:
-        value /= 1000.0
-        exponent += 3
-    if neg:
-        value *= -1
-    exponent = int(exponent)
-    PREFIXES = "yzafpnum kMGTPEZY"
-    prefix_levels = (len(PREFIXES) - 1) // 2
-    si_level = exponent // 3
-    if abs(si_level) > prefix_levels:
-        raise ValueError("Exponent out range of available prefixes.")
-    return '%.*f %s%s' % (precision, value, PREFIXES[si_level + prefix_levels], unit)
-
-
 '''
 def reverse_bits(x):
 	return int('{:08b}'.format(x)[::-1], 2)
@@ -311,5 +284,5 @@ def getLx(f1,f2,f3,Ccal):
 	b=(f1/f2)**2
 	c=(2*math.pi*f1)**2
 	return (a-1)*(b-1)/(Ccal*c)
-	
+
 '''
diff --git a/tests/test_analytics.py b/tests/test_analytics.py
@@ -0,0 +1,50 @@
+import unittest
+
+from PSL import analyticsClass
+
+
+class TestAnalytics(unittest.TestCase):
+    def test_frexp10(self):
+        input_value = 43.0982
+        expected_result = (4.30982, 1)
+        self.assertAlmostEqual(analyticsClass.frexp10(input_value), expected_result)
+
+    def test_apply_si_prefix_rounding(self):
+        input_value = {
+            "value": 7545.230053,
+            "unit": "J",
+        }
+        expected_result = "7.55 kJ"
+        self.assertEqual(analyticsClass.apply_si_prefix(**input_value), expected_result)
+
+    def test_apply_si_prefix_high_precision(self):
+        input_value = {
+            "value": -0.000002000008,
+            "unit": "A",
+            "precision": 6,
+        }
+        expected_result = "-2.000008 µA"
+        self.assertEqual(analyticsClass.apply_si_prefix(**input_value), expected_result)
+
+    def test_apply_si_prefix_low_precision(self):
+        input_value = {
+            "value": -1,
+            "unit": "V",
+            "precision": 0,
+        }
+        expected_result = "-1 V"
+        self.assertEqual(analyticsClass.apply_si_prefix(**input_value), expected_result)
+
+    def test_apply_si_prefix_too_big(self):
+        input_value = {
+            "value": 1e27,
+            "unit": "V",
+        }
+        self.assertRaises(ValueError, analyticsClass.apply_si_prefix, **input_value)
+
+    def test_apply_si_prefix_too_small(self):
+        input_value = {
+            "value": 1e-25,
+            "unit": "V",
+        }
+        self.assertRaises(ValueError, analyticsClass.apply_si_prefix, **input_value)
