metrolopy 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

metrolopy/gummy.py

@@ -561,7 +561,6 @@ class gummy(Quantity,metaclass=MetaGummy):
         
         if isinstance(x,gummy):
             self._value = nummy(x.value)
-            self._value._fp = self._get_p
             self._unit = x._unit
             self._U = self._value.u
             self._value._name = x._value._name
@@ -580,7 +579,6 @@ class gummy(Quantity,metaclass=MetaGummy):
         
         if isinstance(x,ummy):
             self._value = nummy(x)
-            self._value._fp = self._get_p
             self._U = self._value.u
             self._k = 1
             self._pm = None
@@ -659,7 +657,6 @@ class gummy(Quantity,metaclass=MetaGummy):
                     u = u/type(u)(self._k)
 
         self._value = nummy(x,u=u,dof=dof,utype=utype,name=name)
-        self._value._fp = self._get_p
         
         self._U = None
         self._set_U(self._k,uunit)
@@ -704,10 +701,23 @@ class gummy(Quantity,metaclass=MetaGummy):
         Returns `True` if the gummy is an independent variable.  That is the 
         ummy has u > 0 and was not correlated with any other gummy's when it was 
         created or is perfectly correlated or anti-correlated (correlation 
-        coefficeint 1 or -1) with such an ummy.'
+        coefficeint 1 or -1) with such an ummy.
         """
         
         return self.value.isindependent
+    
+    @property
+    def independent(self):
+        """
+        `bool`, read-only
+
+        Returns `True` if the gummy is an independent variable.  That is the 
+        ummy has u > 0 and was not correlated with any other gummy's when it was 
+        created or is perfectly correlated or anti-correlated (correlation 
+        coefficeint 1 or -1) with such an ummy.  Identical to the 
+        isindependent property.
+        """
+        return self.value.isindependent
         
     @property
     def U(self):
@@ -839,7 +849,7 @@ class gummy(Quantity,metaclass=MetaGummy):
         `k` properties will affect `Usym`.
         """
         if not isinstance(self._U,Quantity):
-            return self._value.Usim
+            return self._value.Usim(self.p)
             
         if self.uunit_is_rel:
             x = self.xsim
@@ -892,7 +902,7 @@ class gummy(Quantity,metaclass=MetaGummy):
         but changing the `p`, `k`, or `cimethod` properties will affect the return
         value.
         """
-        return self._value.cisim
+        return self._value.cisim(self.p)
     
     @property
     def cimethod(self):
@@ -925,7 +935,7 @@ class gummy(Quantity,metaclass=MetaGummy):
         value = value.lower().strip()
         if value not in ['shortest','symmetric']:
             raise ValueError('cimethod ' + str(value) + ' is not recognized')
-        self.value._cimethod = value
+        self.value.cimethod = value
         
     @property
     def simdata(self):
@@ -963,17 +973,7 @@ class gummy(Quantity,metaclass=MetaGummy):
 
         Returns ``0.5*(gummy.Usim[0] + gummy.Usim[1])/gummy.usim``
         """
-        return self.value.ksim
-    
-    @property
-    def independent(self):
-        """
-        `bool`, read-only
-
-        Returns `False` if the owning gummy was created from a operation involving
-        other gummys or has zero uncertainty and `True` otherwise.
-        """
-        return self.value.isindependent
+        return self.value.ksim(self.p)
             
     @property
     def name(self):
@@ -1039,6 +1039,7 @@ class gummy(Quantity,metaclass=MetaGummy):
         Quantity.unit.fset(self,u)
         self._U = None
         self._set_U()
+        self._value.clear()
             
     @property
     def uunit(self):
@@ -2757,14 +2758,18 @@ class gummy(Quantity,metaclass=MetaGummy):
             x = self.x
             
         xd = _to_decimal(x,max_digits=self.max_digits)
-        with localcontext(prec=nsig + 2):
+        #with localcontext(prec=nsig + 2):
+        with localcontext() as ctx:
+            ctx.prec = nsig + 2
             ud = _to_decimal(u)*_to_decimal(self._k)
         
         elip = ''
         uexp = 0
         xexp = 0
         dp = 0
-        with localcontext(prec=self.max_digits):
+        #with localcontext(prec=self.max_digits):
+        with localcontext() as ctx:
+            ctx.prec = self.max_digits
             if ud == 0 or not ud.is_finite():
                 if style != 'xf':
                     style = 'x'
@@ -2869,7 +2874,9 @@ class gummy(Quantity,metaclass=MetaGummy):
                     style = 'pmi'
                 return tuple([style,xret] + uret)
 
-        with localcontext(prec=nsig + 2):
+        #with localcontext(prec=nsig + 2):
+        with localcontext() as ctx:
+            ctx.prec = nsig + 2
             if sim:
                 u = abs(_to_decimal(self.cisim[1] - self.cisim[0]))
             else:

metrolopy/nummy.py

@@ -111,7 +111,6 @@ class nummy(ummy):
 
     _cimethod = 'shortest'
     _bayesian = False # see the gummy bayesian property
-    _fp = None
     _nsim = None
     
     def __init__(self,x,u=0,dof=float('inf'),utype=None,name=None):
@@ -299,38 +298,35 @@ class nummy(ummy):
     def xsim(self):
         if not isinstance(self._dist,Distribution):
             return self._dist
-        return self.distribution.mean
+        return float(self.distribution.mean)
         
     @property
     def usim(self):
         if not isinstance(self._dist,Distribution):
             return 0
-        return self.distribution.stdev
+        return float(self.distribution.stdev)
         
-    @property
-    def cisim(self):
+    def cisim(self,p):
         if not isinstance(self._dist,Distribution):
             return [self._dist,self._dist]
         if self._cimethod == 'shortest':
-            return self.distribution.ci(self.p)
+            return [float(i) for i in self.distribution.ci(p)]
         else:
-            return self.distribution.cisym(self.p)
+            return [float(i) for i in self.distribution.cisym(p)]
               
-    @property
-    def Usim(self):
+    def Usim(self,p):
         if not isinstance(self._dist,Distribution):
             return 0
         x = self.distribution.mean
         
         if self._cimethod == 'shortest':
-            ci = self.distribution.ci(self.p)
+            ci = self.distribution.ci(p)
         else:
-            ci = self.distribution.cisym(self.p)
+            ci = self.distribution.cisym(p)
             
-        return (ci[1]-x,x-ci[0])
+        return (float(ci[1]-x),float(x-ci[0]))
         
-    @property
-    def ksim(self):
+    def ksim(self,p):
         """
         read-only
 
@@ -338,7 +334,8 @@ class nummy(ummy):
         """
         if self.usim == 0 or not isinstance(self._dist,Distribution):
             return float('inf')
-        return 0.5*(self.Usim[0] + self.Usim[1])/self.usim
+        usm = self.Usim(p)
+        return 0.5*(usm[0] + usm[1])/self.usim
         
     @property
     def isindependent(self):
@@ -385,12 +382,9 @@ class nummy(ummy):
         if value not in ['shortest','symmetric']:
             raise ValueError('cimethod ' + str(value) + ' is not recognized')
         self._cimethod = value
-        
-    @property
-    def p(self):
-        if self._fp is None:
-            return 0.68268949213708585
-        return self._fp()
+        if isinstance(self.distribution,Distribution):
+            self.distribution._ci = {}
+            self.distribution._cisym = {}
         
     @staticmethod
     def set_seed(seed):
@@ -564,7 +558,7 @@ class nummy(ummy):
         See the method `gummy.covariance(g)` for the corresponding result based
         on first order error propagation.
         """
-        return self._dist.covsim(g._dist)
+        return float(self._dist.covsim(g._dist))
         
     def correlation_sim(self,g):
         """

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
             

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
@@ -36,6 +39,10 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(_ku(2.1,Decimal(3.3)) == Decimal(float(2.1))*Decimal(3.3))
         
     def test_meta_properties(self):
+        """
+        Test class properties.
+
+        """
         a = uc.gummy.cimethod
         self.assertTrue(isinstance(a,str))
         uc.gummy.cimethod = 'symmetric'
@@ -123,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)
@@ -223,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)
@@ -240,6 +253,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(abs(c.U[1] - 4.4*1.1/3**2) < 1e-12)
         
     def test_set_U(self):
+        """
+        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'))
@@ -254,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'))
@@ -284,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)
@@ -352,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
@@ -371,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'
@@ -415,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')
@@ -428,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')
@@ -446,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='%'
@@ -459,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)
         
@@ -479,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
@@ -498,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
@@ -510,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
@@ -523,6 +578,9 @@ class TestGummy(unittest.TestCase):
         self.assertTrue(b.covariance(b) == 4)
         
     def test_correlation_sim(self):
+        """
+        Test gummy.correlation_sim
+        """
         a = uc.gummy(1,1)
         b = uc.gummy(1,2)
         c = a + b
@@ -535,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
@@ -548,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
@@ -564,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
@@ -580,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)
@@ -592,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)
@@ -600,16 +676,25 @@ 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')
@@ -620,6 +705,9 @@ class TestGummy(unittest.TestCase):
         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()

metrolopy/tests/test_operations.py

@@ -28,6 +28,10 @@ from metrolopy.tests.common import rand,make_gummy,make_number
 
 
 class TestOperations(unittest.TestCase):
+    """
+    Tests checking basic operations with `gummy` instances using random 
+    values.
+    """
     def binary_func(self,f,df,sim=False,exp=None,fionly=False,uexp=-6,allowazero=True,
                     allowbzero=True,allowlargeu=True):
         if sim:
@@ -104,6 +108,9 @@ class TestOperations(unittest.TestCase):
                 self.assertTrue(abs((g.correlation_sim(b)-g.correlation(b))/g.correlation(b)) < 0.1)
         
     def test_add(self,n=1000,sim=False):
+        """
+        Test gummy addition.
+        """
         def f(a,b):
             return a + b
         def df(ax,bx):
@@ -112,6 +119,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim)
             
     def test_sub(self,n=1000,sim=False):
+        """
+        Test gummy subtraction.
+        """
         def f(a,b):
             return a - b
         def df(ax,bx):
@@ -120,6 +130,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim)
             
     def test_mul(self,n=1000,sim=False):
+        """
+        Test gummy multiplication.
+        """
         def f(a,b):
             return a*b
         def df(ax,bx):
@@ -128,6 +141,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim)
             
     def test_div(self,n=1000,sim=False):
+        """
+        Test gummy division.
+        """
         def f(a,b):
             return a/b
         def df(ax,bx):
@@ -140,6 +156,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim,allowbzero=False,allowlargeu=lu)
             
     def test_pow(self,n=1000,sim=False):
+        """
+        Test gummy exponentiation.
+        """
         def f(a,b):
             return abs(a)**b
         def df(ax,bx):
@@ -153,6 +172,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim,exp=0,allowazero=False,allowlargeu=lu)
             
     def test_mod(self,n=1000,sim=False):
+        """
+        Test gummy mod.
+        """
         def f(a,b):
             return a%b
         def df(ax,bx):
@@ -161,6 +183,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim,fionly=True,allowazero=False)
         
     def test_abs(self,n=1000,sim=False):
+        """
+        Test gummy abs.
+        """
         def f(a,b):
             return abs(a)*abs(b)
         def df(ax,bx):
@@ -174,6 +199,9 @@ class TestOperations(unittest.TestCase):
                         allowbzero=lu)
             
     def test_neg(self,n=1000,sim=False):
+        """
+        Test gummy neg.
+        """
         def f(a,b):
             return (-a)*b
         def df(ax,bx):
@@ -182,6 +210,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim)
             
     def test_pos(self,n=1000,sim=False):
+        """
+        Test gummy pos.
+        """
         def f(a,b):
             return (+a)*b
         def df(ax,bx):
@@ -190,6 +221,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim)
             
     def test_sincos(self,n=1000,sim=False):
+        """
+        Test gummy metrolopy.sin + metrolopy.cos.
+        """
         def f(a,b):
             return uc.sin(a) + uc.cos(b)
         def df(ax,bx):
@@ -198,6 +232,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim)
             
     def test_npsincos(self,n=1000,sim=False):
+        """
+        Test gummy numpy.sin + numpy.cos.
+        """
         def f(a,b):
             return np.sin(a) + np.cos(b)
         def df(ax,bx):
@@ -206,6 +243,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim,fionly=True)
             
     def test_ap1sincos(self,n=1000,sim=False):
+        """
+        Test gummy.apply(numpy.sin) + gummy.apply(numpy.cos).
+        """
         def f(a,b):
             return uc.gummy.apply(np.sin,np.cos,a) + uc.gummy.napply(np.cos,b)
         def df(ax,bx):
@@ -214,6 +254,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim,fionly=True,exp=0,allowlargeu=False)
             
     def test_ap2sincos(self,n=1000,sim=False):
+        """
+        Test gummy.apply(numpy.sin + numpy.cos).
+        """
         def ff(a,b):
             return np.sin(a) + np.cos(b)
         def df(ax,bx):
@@ -225,6 +268,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim,fionly=True)
             
     def test_apnsincos(self,n=1000,sim=False):
+        """
+        Test gummy.napply(numpy.sin + numpy.cos).
+        """
         def ff(a,b):
             return np.sin(a) + np.cos(b)
         def df(ax,bx):
@@ -236,6 +282,9 @@ class TestOperations(unittest.TestCase):
             self.binary_func(f,df,sim=sim,fionly=True,exp=0,allowlargeu=False)
             
     def test_addxmul(self,n=1000):
+        """
+        Check that x+x+x+...+x == n*x for gummy values.
+        """
         def f(*x):
             r = x[0]
             for i in range(len(x)-1):
@@ -283,6 +332,9 @@ class TestOperations(unittest.TestCase):
                 self.assertTrue(abs(d.correlation(b) - 1) < 1e-14)
             
     def test_mulxpow(self,n=1000):
+        """
+        Check that x*x*x*...*x == x**n for gummy values.
+        """
         def f(*x):
             r = x[0]
             for i in range(len(x)-1):
@@ -336,6 +388,9 @@ class TestOperations(unittest.TestCase):
     
             
     def test_mulxnpow(self,n=1000):
+        """
+        Check that (1/x)*(1/x)*(1/x)*...*(1/x) == x**-n for gummy values.
+        """
         def f(*x):
             r = 1/x[0]
             for i in range(len(x)-1):

metrolopy/tests/test_ubreakdown.py

@@ -28,6 +28,9 @@ from metrolopy.tests.common import rand,make_gummy
 
 class TestUbreakdown(unittest.TestCase):
     def test_ubreakdown(self,n=None,prnt=False,budget=False):
+        """
+        Test gummy.ubreakdown and the budget class.
+        """
         uc.gummy.p_method = None
         
         if n is None:

metrolopy/ummy.py

@@ -152,7 +152,9 @@ def _to_decimal(x,max_digits=None):
     elif isinstance(x,Rational):
         if max_digits is None:
             max_digits = ummy.max_digits
-        with localcontext(prec=max_digits):
+        #with localcontext(prec=max_digits):
+        with localcontext() as ctx:
+            ctx.prec = max_digits
             try:
                 xd = Decimal(x.numerator)/Decimal(x.denominator)
             except:
@@ -627,7 +629,7 @@ class ummy(Dfunc,PrettyPrinter,Number,metaclass=MetaUmmy):
         """
         Returns the variance-covariance matrix of a list or array of ummys.
         """
-        return [[b.covariance(a) if isinstance(b,ummy) else 0 for b in gummys] 
+        return [[float(b.covariance(a)) if isinstance(b,ummy) else 0 for b in gummys] 
                 for a in gummys]
         
     @classmethod
@@ -754,7 +756,9 @@ class ummy(Dfunc,PrettyPrinter,Number,metaclass=MetaUmmy):
             dp = 0
             xd = _to_decimal(self._x,max_digits=self.max_digits)
             ud = _to_decimal(self.u)
-            with localcontext(prec=self.max_digits):
+            #with localcontext(prec=self.max_digits):
+            with localcontext() as ctx:
+                ctx.prec = self.max_digits
                 if ud == 0 or not ud.is_finite():
                     if xd.is_finite():
                         nm = False

metrolopy/version.py

@@ -20,4 +20,4 @@
 # You should have received a copy of the GNU General Public License along with 
 # MetroloPy. If not, see <http://www.gnu.org/licenses/>.
 
-__version__ = '1.0.0'
+__version__ = '1.0.2'

{metrolopy-1.0.0.dist-info → metrolopy-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metrolopy
-Version: 1.0.0
+Version: 1.0.2
 Summary: tools for dealing with measured quantities: uncertainty propagation and unit conversion
 Home-page: http://nrc-cnrc.github.io/MetroloPy/
 Author: Harold Parks, National Research Council Canada
@@ -41,7 +41,7 @@ tools for dealing with physical quantities:  uncertainty propagation and unit co
 
 ---
 
-MetroloPy is a pure python package and requires Python 3.5 or later and the SciPy stack (NumPy, SciPy and Pandas).  It looks best in a Jupyter Notebook.
+MetroloPy is a pure python package and requires Python 3.6 or later and the SciPy stack (NumPy, SciPy and Pandas).  It looks best in a Jupyter Notebook.
 
 Install MetroloPy with `pip install metrolopy`  or 
 `conda install -c conda-forge metrolopy`.
@@ -67,8 +67,8 @@ Physical quantities can then be represented in Python as `gummy` objects with an
 
 MetroloPy can do much more including Monte-Carlo uncertainty propagation, generating uncertainty budget tables, and curve fitting.  It can also handle expanded uncertainties, degrees of freedom, correlated quantities, and complex valued quantities. See:
 
-* [a tutorial](https://nrc-cnrc.github.io/MetroloPy/_build/html/_static/tutorial.html) (or  <a href="https://nrc-cnrc.github.io/MetroloPy/_build/html/_downloads/tutorial.ipynb" download> download the tutorial as Jupyter notebook</a>)
-* [the documentation](https://nrc-cnrc.github.io/MetroloPy/)
+* [a tutorial](https://nrc-cnrc.github.io/MetroloPy/_build/html/_static/tutorial.html) (or  <a href="https://nrc-cnrc.github.io/MetroloPy/_build/html/_downloads/tutorial.ipynb" target="_blank"> download the tutorial as Jupyter notebook</a>)
+* [the documentation](https://nrc-cnrc.github.io/MetroloPy/_build/html/index.html)
 * [the issues page on GitHub](https://github.com/nrc-cnrc/Metrolopy/issues)
 * [a list of the units built into MetroloPy](https://nrc-cnrc.github.io/MetroloPy/_static/units.html)
 * [a list of the physical constants built into MetroloPy](https://nrc-cnrc.github.io/MetroloPy/_static/constants.html)
@@ -79,14 +79,14 @@ MetroloPy can do much more including Monte-Carlo uncertainty propagation, genera
   previous versions, in a multi-step calculation, the effective degree of freedom 
   were calculated at each step based on the degrees of freedom calculated for the 
   previous step (using a modified Welch-Satterthwaite approximation).  Now 
-  effective degrees of freedom are alway calculated directly from the independent 
+  effective degrees of freedom are always calculated directly from the independent 
   variables using the Welch-Satterthwaite equation.
 
 * CODATA 2022 values instead of 2018 values are used in the Constants module.
 
 * The significance value in budget table has been redefined from
   (sensitivity coefficient * standard uncertainty/combined uncertainty) to the 
-  square of that value so that the significance value sum to one.
+  square of that value so that the significance values in a budget sum to one.
   
 * Units can now be raised to a fractional power and many other bug fixes.
   

{metrolopy-1.0.0.dist-info → metrolopy-1.0.2.dist-info}/RECORD

@@ -9,37 +9,37 @@ metrolopy/distributions.py,sha256=rh5qRRocXn9_JZ1zmhxCy2O3kwy6XtYIyPHyNxdqefo,48
 metrolopy/exceptions.py,sha256=N9IvZvNRBNLtKV-t-zYIpOj6SuKpnd6lZUckL8LEBuY,1774
 metrolopy/fit.py,sha256=cocdQjj13fIrj70cnibFcVYliqKbaGUr95-eAWDLNXY,101174
 metrolopy/functions.py,sha256=PIZ1nQwMzOunT6qjDr2Al26Robr8AE7NGGHnkEL_p2c,10057
-metrolopy/gummy.py,sha256=Gs8p63QUu-5tVV003pSf4lujU19anJDbGCx6eNTy5go,141425
+metrolopy/gummy.py,sha256=4zbOmhsid2sziOqy3ynMDJue3xGMCrH1R86iR7n7l3A,141759
 metrolopy/indexed.py,sha256=29Ev_S6noFLDem9jti_kiBWv_96WIShVhYNN_l-q2aI,8534
 metrolopy/license.txt,sha256=hOKIMVY_W-ijJs8Q2Xo7gf2LE_r88c7eYO3-n0FYyFs,33041
 metrolopy/logunit.py,sha256=Ap7HoJhWrByO9lEHboibubsXTwjFGgM044IQ_bA9nrQ,7468
 metrolopy/mean.py,sha256=l6thmupfEF2PGswAzEQBpgsluko9OK7YLiUeP4h507k,13185
 metrolopy/miscunits.py,sha256=4okSOTKFsXce1yQgVK1jy5s4VGCUGkm1ObBJ1R19YJE,20432
 metrolopy/nonlinearunit.py,sha256=lWImZ_dJRwP_uJGFRQgWeLDEIL_7PetgrJDgExJDSuc,8394
-metrolopy/nummy.py,sha256=MDUXgaGBxX7C3r9FNQvXmgaruxBfwXws4Co2cRD3Nmo,27675
+metrolopy/nummy.py,sha256=AokskJHQl3hzj9IB77YoH6LlY-FcUhebgXV8IGAyAvU,27690
 metrolopy/offsetunit.py,sha256=a8Y6njKImJpHcvNX4-mv2ZKnA1sy-5pz08LJBh0Bbzg,4096
 metrolopy/pmethod.py,sha256=pcMBFhP_6QzCqsHiLM_ADsoxMoTX733w038L6eaFU20,4033
 metrolopy/prefixedunit.py,sha256=rsG_AKWIignQVIrOsahjw0kgOA6NvC3iafu_tKoO7yM,10392
 metrolopy/printing.py,sha256=I_TVH3CWcwWxm82ER44v0_IP9oPUSYHTYR5pfWRdRNo,8993
 metrolopy/relunits.py,sha256=fPuzkx352bnI1_mCTDDVbKHZ1ifsvdgR0gBZ1s9uYfI,2174
 metrolopy/siunits.py,sha256=9eFc8N6namSeZCyqiMrkIcUvatFHiFwr4v05TKRMm5I,8611
-metrolopy/ummy.py,sha256=75tDYQNN8Z2hUOIzbZIpJFGoj_Ee8SGhmBhPIh9cbUc,76819
+metrolopy/ummy.py,sha256=Qx2pcqNsfxbb5ZuN9rCfdZ6ZAGevHa3kBrRB1_PwiqI,76985
 metrolopy/unit.py,sha256=_UF8WSHFbOyPZbyebW73jSHD2jO_RKg2_Z60smBhinM,64514
 metrolopy/unitparser.py,sha256=L-eCt_ubIy0rQEG9uttNnkBa3-BpkSnkHW9scHSHKmg,9015
 metrolopy/unitutils.py,sha256=2lw1JWo-xPgE42zIJP3fTsZIOtwDJqnq3Si9CTsIEuY,13802
 metrolopy/usunits.py,sha256=R1BdlW24DMdeq7YUpKgBk83YAibHEkWsu9ylMEW2qmU,11249
-metrolopy/version.py,sha256=yYgnYjR2yS7Fjnc3yFC0ScAVkAKwq2-jmg79NhZ-ncY,829
+metrolopy/version.py,sha256=mlx2kVkFVNnPS7nZ_M0Day_5iZSrF7YA59Fm9PBBc38,829
 metrolopy/tests/__init__.py,sha256=8xPi7YxTaZ1Z7AJwxsTgY82iOj9Ysv7VqU8gOWoF92E,259
 metrolopy/tests/common.py,sha256=-AUUXiz5vuORxpYDKdUkUG9j6jLRVp5fBGRlRTKI0kE,3474
-metrolopy/tests/test_complex.py,sha256=pSKujsTr8smV21_3JbPdeJxVVtgUqjPm6lOGw3-1NI0,7862
-metrolopy/tests/test_create.py,sha256=MPoYaqVSZSt69O7DMX-WN-E3B6LQ0VSizp635y80sxs,17951
-metrolopy/tests/test_gummy.py,sha256=h08Lu2iAj0mivP-ihm0DIAajxWnCqENo5fEvyMOfs9E,21695
-metrolopy/tests/test_misc.py,sha256=OsOdEoS67-0FnZ14orv9n3OqT9vjnvBGntdz9fQZKG0,4360
-metrolopy/tests/test_operations.py,sha256=i-fYbM20dOnJPIlvziUJkx9r_Ql5iVOVBFBxQJogppU,12987
-metrolopy/tests/test_ubreakdown.py,sha256=Dlv9EQUDMe3cAnktHvXpKvnApSGiyqvKPaKxzq610_M,13689
-metrolopy-1.0.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-metrolopy-1.0.0.dist-info/METADATA,sha256=J2ZxokmRITRaV8DAb_IfzAtTjYSVKv0hU6d-j9qZjck,5452
-metrolopy-1.0.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-metrolopy-1.0.0.dist-info/top_level.txt,sha256=TTY_Gf2M3yWScmUStgI-RYOc0YKVcr108GaTl4sedSo,10
-metrolopy-1.0.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-metrolopy-1.0.0.dist-info/RECORD,,
+metrolopy/tests/test_complex.py,sha256=D3pn1BMI4rvYXHDrEyTvAWfqHUe2-8cVDSB49VyUCp0,8388
+metrolopy/tests/test_create.py,sha256=gAo57tUYQh1p8DjB9dqBzXllTXDaZxfOIGp68WV3uA4,18007
+metrolopy/tests/test_gummy.py,sha256=Euejbmz2tA6m0wQbwsAajJYBgL8rhICZmEvUj7l27n0,23480
+metrolopy/tests/test_misc.py,sha256=YGMyJwAlCaggVDesvpzy9VPa4KnfhXBvdsJkoOc_mXY,4402
+metrolopy/tests/test_operations.py,sha256=O7v22xyS6pIUr57PiLAwTIULR8qNtjFgVoPKrRXmAJ4,14247
+metrolopy/tests/test_ubreakdown.py,sha256=xABI5N31jZ9aJMae85tUFPnGCowXnnuvwML5_v3ziPM,13768
+metrolopy-1.0.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+metrolopy-1.0.2.dist-info/METADATA,sha256=GQIPXZjnVcqsMjGuSVvoJe3H-iGzhfhiuW3TJ_4FcWA,5495
+metrolopy-1.0.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+metrolopy-1.0.2.dist-info/top_level.txt,sha256=TTY_Gf2M3yWScmUStgI-RYOc0YKVcr108GaTl4sedSo,10
+metrolopy-1.0.2.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+metrolopy-1.0.2.dist-info/RECORD,,