metrolopy 1.0.0__tar.gz → 1.0.1__tar.gz

{metrolopy-1.0.0 → metrolopy-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metrolopy
-Version: 1.0.0
+Version: 1.0.1
 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 → metrolopy-1.0.1}/README.md

@@ -4,7 +4,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`.
@@ -30,8 +30,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)
@@ -42,14 +42,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 → metrolopy-1.0.1}/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):

{metrolopy-1.0.0 → metrolopy-1.0.1}/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-1.0.0 → metrolopy-1.0.1}/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-1.0.0 → metrolopy-1.0.1}/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-1.0.0 → metrolopy-1.0.1}/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-1.0.0 → metrolopy-1.0.1}/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-1.0.0 → metrolopy-1.0.1}/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-1.0.0 → metrolopy-1.0.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-1.0.0 → metrolopy-1.0.1}/metrolopy/ummy.py

@@ -627,7 +627,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

{metrolopy-1.0.0 → metrolopy-1.0.1}/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.1'

{metrolopy-1.0.0 → metrolopy-1.0.1}/metrolopy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metrolopy
-Version: 1.0.0
+Version: 1.0.1
 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.