metrolopy 0.6.5__py3-none-any.whl → 1.0.1__py3-none-any.whl

metrolopy/prefixedunit.py

@@ -25,6 +25,7 @@ Classes to automatically generate prefixed units from a base unit.
 """
 
 from .unit import Unit,Conversion
+from .ummy import MFraction
 
 class PrefixedUnit(Unit):    
     """PrefixedUnit(name,symbol,conversion=None,short_name=None,
@@ -40,26 +41,26 @@ class PrefixedUnit(Unit):
     will be generated. 
     """
     prefix_definitions = {
-                'yocto':[1e-24,'y',None,None,None],
-                'zepto':[1e-21,'z',None,None,None],
-                'atto':[1e-18,'a',None,None,None],
-                'femto':[1e-15,'f',None,None,None],
-                'pico':[1e-12,'p',None,None,None],
-                'nano':[1e-9,'n',None,None,None],
-                'micro':[1e-6,'\u03BC','μ',None,'u'],
-                'milli':[0.001,'m',None,None,None],
-                'centi':[0.01,'c',None,None,None],
-                'deci':[0.1,'d',None,None,None],
+                'yocto':[MFraction('1e-24'),'y',None,None,None],
+                'zepto':[MFraction('1e-21'),'z',None,None,None],
+                'atto':[MFraction('1e-18'),'a',None,None,None],
+                'femto':[MFraction('1e-15'),'f',None,None,None],
+                'pico':[MFraction('1e-12'),'p',None,None,None],
+                'nano':[MFraction('1e-9'),'n',None,None,None],
+                'micro':[MFraction('1e-6'),'\u03BC','μ',None,'u'],
+                'milli':[MFraction('0.001'),'m',None,None,None],
+                'centi':[MFraction('0.01'),'c',None,None,None],
+                'deci':[MFraction('0.1'),'d',None,None,None],
                 'deca':[10,'da',None,None,None],
                 'hecto':[100,'h',None,None,None],
                 'kilo':[1000,'k',None,None,None],
                 'mega':[1000000,'M',None,None,None],
-                'giga':[1e9,'G',None,None,None],
-                'tera':[1e12,'T',None,None,None],
-                'peta':[1e15,'P',None,None,None],
-                'exa':[1e18,'E',None,None,None],
-                'zetta':[1e21,'Z',None,None,None],
-                'yotta':[1e24,'Y',None,None,None],
+                'giga':[1000000000,'G',None,None,None],
+                'tera':[1000000000000,'T',None,None,None],
+                'peta':[1000000000000000,'P',None,None,None],
+                'exa': [1000000000000000000,'E',None,None,None],
+                'zetta':[MFraction('1e21'),'Z',None,None,None],
+                'yotta':[MFraction('1e24'),'Y',None,None,None],
                 }
     
     @staticmethod
@@ -223,13 +224,13 @@ class BinaryPrefixedUnit(PrefixedUnit):
     """
     prefix_definitions = {
                 'kilo':[1000,'k',None,None,None],
-                'mega':[1e6,'M',None,None,None],
-                'giga':[1e9,'G',None,None,None],
-                'tera':[1e12,'T',None,None,None],
-                'peta':[1e15,'P',None,None,None],
-                'exa':[1e18,'E',None,None,None],
-                'zetta':[1e21,'Z',None,None,None],
-                'yotta':[1e24,'Y',None,None,None],
+                'mega':[1000000,'M',None,None,None],
+                'giga':[1000000000,'G',None,None,None],
+                'tera':[1000000000000,'T',None,None,None],
+                'peta':[1000000000000000,'P',None,None,None],
+                'exa':[1000000000000000000,'E',None,None,None],
+                'zetta':[MFraction('1e21'),'Z',None,None,None],
+                'yotta':[MFraction('1e24'),'Y',None,None,None],
                 'kibi':[1024,'Ki',None,None,None],
                 'mebi':[1024**2,'Mi',None,None,None],
                 'gibi':[1024**3,'Gi',None,None,None],

metrolopy/relunits.py

@@ -24,8 +24,7 @@
 This module is loaded by the gummy.units module and is not intended be be
 imported directly.  Dimensionless units are defined here.
 """
-from .unit import Unit,Conversion,one
-from .ummy import MFraction
+from .unit import Unit,Conversion,one,MFraction
 
 class RatioUnit(Unit):
     """RatioUnit is used for dimensionless units like % where powers, e.g. %**2,

metrolopy/siunits.py

@@ -28,8 +28,8 @@ The most of the units here are from the SI Brochure, 9th edition.
 """
 
 from numpy import pi
-from .ummy import ummy,MFraction
-from .unit import Conversion,Unit
+from .ummy import ummy
+from .unit import Conversion,Unit,MFraction
 from .prefixedunit import PrefixedUnit
 from .offsetunit import OffsetUnit,OffsetConversion
 
@@ -112,8 +112,9 @@ with Unit._builtin():
     _degC = OffsetUnit('degree Celsius','\u00B0C',OffsetConversion(_K,273.15),
                latex_symbol='^{\\circ}C',ascii_symbol = 'degC',add_symbol=True,order=0,
                description='unit of temperature')
-    Unit.alias('degree C',_degC)
-    Unit.alias('deg C',_degC)
+    Unit.alias('degreeC',_degC)
+    Unit.alias('degree-C',_degC)
+    Unit.alias('deg-C',_degC)
     
     _lm = PrefixedUnit('lumen','lm',Conversion(_cd*_sr,1),add_symbol=True,order=0,
                        description='SI derived unit for luminous flux')
@@ -151,4 +152,5 @@ with Unit._builtin():
                           prefixes=['centi','deci','deca','hecto','kilo','mega',
                                     'giga','tera','peta','exa','zetta','yotta'],
                           description='unit of mass')
-    Unit.alias('metric ton',_tonne)
+    Unit.alias('metric ton',_tonne)
+    Unit.alias('metric-ton',_tonne)

metrolopy/tests/__init__.py

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
-from .test_create import *
-from .test_operations import *
-from .test_ubreakdown import *
-from .test_complex import *
-from .test_misc import *
-from .test_gummy import *
+from .test_create import TestCreate
+from .test_operations import TestOperations
+from .test_ubreakdown import TestUbreakdown
+from .test_complex import TestComplex
+from .test_misc import TestMisc
+from .test_gummy import TestGummy

metrolopy/tests/test_complex.py

@@ -78,6 +78,10 @@ def make_immy(prnt=False):
 
 
 class TestComplex(unittest.TestCase):
+    """
+    Tests for the `immy` and `jummy` classes.  Basic operations and
+    instance creation are tested using random values.
+    """
     def assert_ummy_close(self,u1,u2):
             self.assertTrue(abs(u1.correlation(u2)) > 1 - 1e-4)
             u1x = max(u1.x,u1.u,u2.x,u2.u)
@@ -94,6 +98,9 @@ class TestComplex(unittest.TestCase):
             self.assert_ummy_close(i1.imag,i2.imag)
     
     def test_immy_init(self,n=1000,prnt=False):
+        """
+        Test immy creation using the real,imag,r and phi keywords.
+        """
         for m in range(n):
             x,xr,xi = make_immy(prnt=prnt)
             
@@ -175,6 +182,9 @@ class TestComplex(unittest.TestCase):
                 self.assert_immy_close(c,cn)
         
     def test_immy_add(self,n=1000,prnt=False):
+        """
+        Test immy addition.
+        """
         self._test_immy_bop(lambda a,b: a + b,np.add,n,prnt)
         
         for m in range(10):
@@ -183,6 +193,9 @@ class TestComplex(unittest.TestCase):
             self.assertTrue(0 + i == i)
         
     def test_immy_sub(self,n=1000,prnt=False):
+        """
+        Test immy subtraction.
+        """
         self._test_immy_bop(lambda a,b: a - b,np.subtract,n,prnt)
         
         for m in range(10):
@@ -191,6 +204,9 @@ class TestComplex(unittest.TestCase):
             self.assertTrue(0 - i == -i)
         
     def test_immy_mul(self,n=1000,prnt=False):
+        """
+        Test immy multiplication.
+        """
         self._test_immy_bop(lambda a,b: a*b,np.multiply,n,prnt)
         
         for m in range(10):
@@ -203,6 +219,9 @@ class TestComplex(unittest.TestCase):
             self.assertTrue(immy(1)*i == i)
         
     def test_immy_div(self,n=1000,prnt=False):
+        """
+        Test immy division.
+        """
         self._test_immy_bop(lambda a,b: a/b,np.divide,n,prnt,allow_small=False)
         
         for m in range(10):
@@ -210,6 +229,9 @@ class TestComplex(unittest.TestCase):
             self.assertTrue(i/1 == i)
         
     def test_immy_pow(self,n=1000,prnt=False):
+        """
+        Test immy exponentiation.
+        """
         #_test_immy_bop(lambda a,b: a**b,np.power,n,prnt,allow_small=False)
         
         for m in range(10):

metrolopy/tests/test_create.py

@@ -9,6 +9,9 @@ from metrolopy.tests.common import rand,display
 
 class TestCreate(unittest.TestCase):
     def test_gummy_init(self,n=None,exception_on_warning=True,prnt=False,plot=False):
+        """
+        Test gummy creation.
+        """
         try:
             from scipy.stats import norm, t
             
@@ -161,8 +164,8 @@ class TestCreate(unittest.TestCase):
         
                     if rand.randint(10) == 0:
                         n = rand.randint(12)
-                        if bayesian and n > 0:
-                            dof = float('inf')
+                        #if bayesian and n > 0:
+                           # dof = float('inf')
                         if n == 0:
                             nm = g.name
                             g = uc.gummy(g)
@@ -292,10 +295,11 @@ class TestCreate(unittest.TestCase):
                         
                     self.assertTrue((g.x - x)/u < 1e-6)
                     
-                    if dof == float('inf'):
-                        self.assertTrue(g.dof == float('inf'))
-                    else:
-                        self.assertTrue((g.dof - dof)/dof < 1e-6)
+                    if not uc.gummy.bayesian:
+                        if dof == float('inf'):
+                            self.assertTrue(g.dof == float('inf'))
+                        else:
+                            self.assertTrue((g.dof - dof)/dof < 1e-6)
                     
                     if uunit is not None and uunit != unit:
                         self.assertTrue(g.uunit is uc.Unit.unit(uunit))

metrolopy/tests/test_gummy.py

@@ -28,6 +28,9 @@ import numpy as np
 import unittest
 
 class TestGummy(unittest.TestCase):
+    """
+    Various unit tests of gummy properties and methods.
+    """
     def test_ku(self):
         from metrolopy.gummy import _ku
         from decimal import Decimal
@@ -35,19 +38,11 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(_ku(2.1,3.3) == 2.1*3.3)
         self.assertTrue(_ku(2.1,Decimal(3.3)) == Decimal(float(2.1))*Decimal(3.3))
         
-    def test_lg10(self):
-        from metrolopy.gummy import _lg10
-        from mpmath import mpf,log10
-        from decimal import Decimal
-        from fractions import Fraction
-        import math
-        
-        self.assertTrue(_lg10(mpf(2.2)) == log10(mpf(2.2)))
-        self.assertTrue(_lg10(Decimal(2.2)) == Decimal(2.2).log10())
-        self.assertTrue(_lg10(2.2) == np.log10(2.2))
-        self.assertTrue(_lg10(Fraction(2,3)) == math.log10(float(Fraction(2,3))))
-        
     def test_meta_properties(self):
+        """
+        Test class properties.
+
+        """
         a = uc.gummy.cimethod
         self.assertTrue(isinstance(a,str))
         uc.gummy.cimethod = 'symmetric'
@@ -135,6 +130,9 @@ class TestGummy(unittest.TestCase):
         uc.gummy.thousand_spaces = ts
         
     def test_init(self):
+        """
+        Test gummy creation
+        """
         g = uc.gummy(1.2,3.4)
         self.assertTrue(g.x == 1.2)
         self.assertTrue(g.u == 3.4)
@@ -217,7 +215,7 @@ class TestGummy(unittest.TestCase):
         try:
             uc.gummy(3.3,1.3,unit='%',uunit='m')
             self.assertTrue(False)
-        except uc.NoUnitConversionFoundError:
+        except uc.IncompatibleUnitsError:
             pass
         
         gg = uc.gummy(3.3,1.4,unit='%',uunit=uc.one)
@@ -235,6 +233,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(gg.name == 'def')
         
     def test_U(self):
+        """
+        Test expanded uncertainty.
+        """
         a = uc.gummy(1.1,2.2)
         self.assertTrue(a.U == 2.2)
         b = uc.gummy(3,4.4)
@@ -252,7 +253,10 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(abs(c.U[1] - 4.4*1.1/3**2) < 1e-12)
         
     def test_set_U(self):
-        g = uc.gummy(1,1,k=2,unit='cm',uunit='mm')
+        """
+        Additional tests for expanded uncertainty.
+        """
+        g = uc.gummy(1.0,1.0,k=2,unit='cm',uunit='mm')
         self.assertTrue(g.U == 1)
         self.assertTrue(g.uunit is uc.unit('mm'))
         g.unit = 'm'
@@ -266,6 +270,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(c.U[1] == 4.4)
         
     def test_iset_U(self):
+        """
+        Additional tests for expanded uncertainty.
+        """
         g = uc.gummy(1)
         self.assertTrue(g._iset_U() == 0)
         self.assertTrue(g._iset_U(unit='m').unit is uc.unit('m'))
@@ -285,7 +292,7 @@ class TestGummy(unittest.TestCase):
         try:
             self.assertTrue(g._iset_U(unit='kg'))
             self.assertTrue(False)
-        except uc.NoUnitConversionFoundError:
+        except uc.IncompatibleUnitsError:
             pass
         
         g = uc.gummy(0,1,unit='m')
@@ -296,6 +303,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(g._iset_U(k=2) == 2)
         
     def test_Usim(self):
+        """
+        Test the gummy.Usim property
+        """
         g = uc.gummy(-8.5,1,unit='m')
         g.sim()
         self.assertTrue(abs(g.Usim[0] - 1) < 0.5)
@@ -364,16 +374,25 @@ class TestGummy(unittest.TestCase):
             self.assertTrue(g.simsorted[i+1] >= g.simsorted[i])
             
     def test_distribution(self):
+        """
+        Test gummy.distribution
+        """
         g = uc.gummy(1,1)
         self.assertTrue(isinstance(g.distribution,uc.Distribution))
        
     def test_ksim(self):
+        """
+        Test gummy.ksim
+        """
         g = uc.gummy(1,1)
         g.p = 0.9545
         g.sim()
         self.assertTrue(abs(g.ksim - 2) < 0.1)
         
     def test_independent(self):
+        """
+        Test gummy.independant
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(-2,2)
         c = a + b
@@ -383,6 +402,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(not d.independent)
         
     def test_name(self):
+        """
+        Test setting and getting gummy.name
+        """
         g = uc.gummy(1,1)
         self.assertTrue(g.name is None)
         g.name = 'abc'
@@ -427,6 +449,9 @@ class TestGummy(unittest.TestCase):
             pass
         
     def test_unit(self):
+        """
+        Test setting and getting gummy.unit
+        """
         g = uc.gummy(1,1,unit='m')
         self.assertTrue(g.unit is uc.unit('m'))
         self.assertTrue(str(g.unit) == 'm')
@@ -440,6 +465,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(g.u == 1000)
         
     def test_uunit(self):
+        """
+        Test setting and getting gummy.uunit
+        """
         g = uc.gummy(1,1)
         self.assertTrue(g.uunit is None)
         g = uc.gummy(1,1,unit='m',uunit='cm')
@@ -458,6 +486,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(g.uunit is None)
         
     def test_uunit_is_rel(self):
+        """
+        Test gummy.uunit_is_rel
+        """
         g = uc.gummy(1,1)
         self.assertTrue(not g.uunit_is_rel)
         g.uunit='%'
@@ -471,6 +502,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(g.uunit_is_rel)
         
     def test_k(self):
+        """
+        Test setting and getting gummy.k
+        """
         g = uc.gummy(1)
         self.assertTrue(g.k is None)
         
@@ -491,6 +525,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(abs(g.k - 1.96) < 0.01)
         
     def test_p(self):
+        """
+        Test setting and getting gummy.p
+        """
         uc.gummy.p_method = None
         g = uc.gummy(1,1)
         g.p = 0.95
@@ -510,6 +547,9 @@ class TestGummy(unittest.TestCase):
             pass
         
     def test_correlation(self):
+        """
+        Test gummy.correlation
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(1,2)
         c = a + b
@@ -522,6 +562,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(a.correlation(a) == 1)
         
     def test_covariance(self):
+        """
+        Test gummy.covariance
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(1,2)
         c = a + b
@@ -534,33 +577,10 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(a.covariance(a) == 1)
         self.assertTrue(b.covariance(b) == 4)
         
-    def test_correlation_matrix(self):
-        a = uc.gummy(1,1)
-        b = uc.gummy(1,2)
-        c = a + b
-        m = uc.gummy.correlation_matrix([a,b,c])
-        self.assertTrue(m[0][0] == m[1][1] == m[2,2] == 1)
-        self.assertTrue(m[0][1] == m[1][0] == 0)
-        self.assertTrue(abs(m[2][0] - 1/c.u) < 1e-4)
-        self.assertTrue(abs(m[0][2] - 1/c.u) < 1e-4)
-        self.assertTrue(abs(m[2][1] - 2/c.u) < 1e-4)
-        self.assertTrue(abs(m[1][2] - 2/c.u) < 1e-4)
-        
-    def test_covariance_matrix(self):
-        a = uc.gummy(1,1)
-        b = uc.gummy(1,2)
-        c = a + b
-        m = uc.gummy.covariance_matrix([a,b,c])
-        self.assertTrue(m[0][0] == 1)
-        self.assertTrue(m[1][1] == 4)
-        self.assertTrue(abs(m[2][2] - 5) < 1e-4)
-        self.assertTrue(m[0][1] == m[1][0] == 0)
-        self.assertTrue(abs(m[2][0] - 1) < 1e-4)
-        self.assertTrue(abs(m[0][2] - 1) < 1e-4)
-        self.assertTrue(abs(m[2][1] - 4) < 1e-4)
-        self.assertTrue(abs(m[1][2] - 4) < 1e-4)
-        
     def test_correlation_sim(self):
+        """
+        Test gummy.correlation_sim
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(1,2)
         c = a + b
@@ -573,6 +593,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(abs(a.correlation_sim(a) - 1) < 1e-6)
         
     def test_covariance_sim(self):
+        """
+        Test gummy.covariance_sim
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(1,2)
         c = a + b
@@ -586,6 +609,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(abs(b.covariance_sim(b) - 4) < 1e-1)
         
     def test_correlation_matrix(self):
+        """
+        Test gummy.correlation_matrix
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(1,2)
         c = a + b
@@ -602,6 +628,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue((m[1][2] - 2/c.u) < 1e-1)
         
     def test_covariance_matrix(self):
+        """
+        Test gummy.covariance_matrix
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(1,2)
         c = a + b
@@ -618,10 +647,16 @@ class TestGummy(unittest.TestCase):
         self.assertTrue((m[1][2] - 4) < 1e-1)
         
     def test_finfo(self):
+        """
+        Test gummy.finfo
+        """
         a = uc.gummy(1,1)
         self.assertTrue(a.finfo.rel_u == 0)
         
     def test_real(self):
+        """
+        Test gummy.real
+        """
         a = uc.gummy(1.1,0.3)
         b = a.real
         self.assertTrue(not a is b)
@@ -630,6 +665,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(a.correlation(b) == 1)
         
     def test_conjugate(self):
+        """
+        Test gummy.conjugate
+        """
         a = uc.gummy(1.1,0.3)
         b = a.conjugate()
         self.assertTrue(not a is b)
@@ -638,26 +676,38 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(a.correlation(b) == 1)
         
     def test_angle(self):
+        """
+        Test gummy.angle
+        """
         self.assertTrue(uc.gummy(1.1,0.3).angle() == 0)
         self.assertTrue(abs(abs(uc.gummy(-1.1,0.3).angle()) - np.pi) < 1e-10)
         
     def test_utype(self):
+        """
+        Test gummy.utype
+        """
         a = uc.gummy(1.2,1,1,utype='A')
         self.assertTrue(a.utype == 'A')
         b = uc.gummy(1.2,1,1,utype='xyz')
         self.assertTrue(b.utype == 'xyz')
         
     def test_ufrom(self):
+        """
+        Test gummy.ufrom
+        """
         a = uc.gummy(1.2,0.2,utype='A')
         b = uc.gummy(3.2,0.5,utype='A')
         c = uc.gummy(0.9,0.2,utype='B')
         d = a + b + c
         self.assertTrue(abs(d.ufrom('A') - np.sqrt(0.2**2+0.5**2)) < 1e-8)
-        uc.gummy.simulate([d,'A'])
-        self.assertTrue(abs(d.ufrom('A',sim=True) - np.sqrt(0.2**2+0.5**2)) < 1e-2)
+        uc.gummy.simulate([d,b])
+        self.assertTrue(abs(d.ufromsim('A') - np.sqrt(0.2**2+0.5**2)) < 1e-2)
         self.assertTrue(d.ufrom(c) == 0.2)
         
     def test_dof_from(self):
+        """
+        Test gummy.doffrom
+        """
         a = uc.gummy(1.2,0.2,dof=5,utype='A')
         b = uc.gummy(3.2,0.5,dof=7,utype='A')
         c = uc.gummy(0.9,0.2,utype='B')

metrolopy/tests/test_misc.py

@@ -29,7 +29,9 @@ import unittest
 
 
 class TestMisc(unittest.TestCase):
-
+    """
+    Miscellaneaus tests.
+    """
     def test_reduce(self):
         a = uc.gummy(12.367,0.22,unit='mm/m')
         a.reduce_unit()
@@ -103,6 +105,7 @@ class TestMisc(unittest.TestCase):
             return t.ppf(1-(1-con)/2, len(x)-1)*x.std(ddof=1)/np.sqrt(len(x))
     
         x = np.random.rand(5)
+        uc.gummy.bayesian = False
         g = uc.mean(x)
         g.p = 'ssd'
         self.assertTrue(abs(con-g.p) < 1e-6)