metrolopy 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

metrolopy/nummy.py

@@ -30,6 +30,7 @@ import numpy as np
 from .ummy import ummy
 from .distributions import (Distribution,TDist,NormalDist,MultivariateElement,
                             MultivariateDistribution,MultiNormalDist,MultiTDist)
+from .exceptions import NoSimulatedDataError
 from math import isinf,isfinite,isnan,sqrt
 
 def _bop(f,npf,s,b):    
@@ -57,6 +58,7 @@ 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):
         self._bayesian = nummy._bayesian
@@ -77,7 +79,7 @@ class nummy(ummy):
             
             if hasattr(x,'dof'):
                 if nummy._bayesian:
-                    u = float(x.u())*x.dof/(x.dof-2)
+                    u = float(x.u())*np.sqrt(x.dof/(x.dof-2))
                     dof = float('inf')
                 else:
                     u = float(x.u())
@@ -100,7 +102,7 @@ class nummy(ummy):
                 self._dist = NormalDist(x,u)
             else:
                 if nummy._bayesian:
-                    self._dist = TDist(x,u*(dof-2)/dof,dof)
+                    self._dist = TDist(x,u*np.sqrt((dof-2)/dof),dof)
                     self._dof = float('inf')
                 else:
                     self._dist = TDist(x,u,dof)
@@ -168,6 +170,10 @@ class nummy(ummy):
             raise ValueError('the name must be a string or a length 4 tuple of str')
             
     def get_name(self,fmt='unicode',norm=None):
+        fmt = fmt.strip().lower()
+        if fmt not in {'unicode','html','latex','ascii'}:
+            raise ValueError('fmt "' + str(fmt) + '" is not recognized')
+            
         if self._name is None:
             return None
         
@@ -181,7 +187,6 @@ class nummy(ummy):
                 return norm(self.name)
             return self._name
         
-        fmt = fmt.strip().lower()
         if fmt == 'unicode':
             return self._name[0]
         if fmt == 'html':
@@ -189,8 +194,7 @@ class nummy(ummy):
         if fmt == 'latex':
             return self._name[2]
         if fmt == 'ascii':
-            return self._name[0]
-        raise ValueError('fmt "' + str(fmt) + '" is not recognized')
+            return self._name[3]
     
     @property
     def bayesian(self):
@@ -219,7 +223,7 @@ class nummy(ummy):
         uncertainty should be the standard deviation of this distribution which
         is s*sqrt{(n-1)/[n*(n-3)]}.  Thus
 
-        u(bayesian) = [dof/(dof - 2)]*u(traditional)
+        u(bayesian) = sqrt[dof/(dof - 2)]*u(traditional)
 
         where dof = n - 1 and the "extra uncertainty" is incorporated directly
         into the standard uncertainty.
@@ -240,6 +244,7 @@ class nummy(ummy):
         if isinstance(nummys,nummy):
             nummys = [nummys]
         Distribution.simulate([g.distribution for g in nummys],n,ufrom)
+        nummy._nsim = n
         
     @property
     def simdata(self):
@@ -249,6 +254,10 @@ class nummy(ummy):
         Returns an array containing the Monte-Carlo simulation data.  A 
         `NoSimulatedDataError` is raised if no Monte-Carlo data is available.
         """
+        if not isinstance(self._dist,Distribution):
+            if nummy._nsim is None:
+                raise NoSimulatedDataError()
+            return np.full(nummy._nsim,self._dist)
         return self.distribution.simdata
         
     @property
@@ -259,18 +268,28 @@ class nummy(ummy):
         Returns a sorted array containing the Monte-Carlo simulation data.  A 
         `NoSimulatedDataError` is raised if no Monte-Carlo data is available.
         """
+        if not isinstance(self._dist,Distribution):
+            if nummy._nsim is None:
+                raise NoSimulatedDataError
+            return np.full(nummy._nsim,self._dist)
         return self.distribution.simsorted
         
     @property
     def xsim(self):
+        if not isinstance(self._dist,Distribution):
+            return self._dist
         return self.distribution.mean
         
     @property
     def usim(self):
+        if not isinstance(self._dist,Distribution):
+            return 0
         return self.distribution.stdev
         
     @property
     def cisim(self):
+        if not isinstance(self._dist,Distribution):
+            return [self._dist,self._dist]
         if self._cimethod == 'shortest':
             return self.distribution.ci(self.p)
         else:
@@ -278,6 +297,8 @@ class nummy(ummy):
               
     @property
     def Usim(self):
+        if not isinstance(self._dist,Distribution):
+            return 0
         x = self.distribution.mean
         
         if self._cimethod == 'shortest':
@@ -294,7 +315,7 @@ class nummy(ummy):
 
         Returns ``0.5*(gummy.Usim[0] + gummy.Usim[1])/gummy.usim``
         """
-        if self.usim == 0:
+        if self.usim == 0 or not isinstance(self._dist,Distribution):
             return float('inf')
         return 0.5*(self.Usim[0] + self.Usim[1])/self.usim
         
@@ -396,7 +417,7 @@ class nummy(ummy):
                 r._dist = NormalDist(s._x,s._u)
             else:
                 if r._bayesian:
-                    r._dist = TDist(s._x,s._u*(dof-2)/dof,dof)
+                    r._dist = TDist(s._x,s._u*np.sqrt((dof-2)/dof),dof)
                     r._dof = float('inf')
                 else:
                     r._dist = TDist(s._x,s._u,dof)
@@ -472,7 +493,7 @@ class nummy(ummy):
                 if nummy._bayesian:
                     dof = [float('inf')]*nd
                     for i,uu in u:
-                        u[i] *= x.dof[i]/(x.dof[i]-2)
+                        u[i] *= np.sqrt(x.dof[i]/(x.dof[i]-2))
                 else:
                     dof = x.dof
             else:
@@ -503,7 +524,7 @@ class nummy(ummy):
                 if hasattr(v,'dof'):
                     dof[i] = v.dof
                     if nummy._bayesian:
-                        u[i] = u[i]*v.dof/(v.dof-2)
+                        u[i] = u[i]*np.sqrt(v.dof/(v.dof-2))
                         dof[i] = float('inf')
             
         ret = super(nummy,cls).create(x,u,dof,correlation_matrix,covariance_matrix)
@@ -516,7 +537,7 @@ class nummy(ummy):
                     r._dist = NormalDist(x[i],u[i])
                 else:
                     if nummy._bayesian:
-                        r._dist = TDist(x,u[i]*(dof[i]-2)/dof[i],dof[i])
+                        r._dist = TDist(x,u[i]*np.sqrt((dof[i]-2)/dof[i]),dof[i])
                         r._dof = float('inf')
                     else:
                         r._dist = TDist(x,u[i],dof[i])

metrolopy/tests/__init__.py

@@ -1,9 +1,8 @@
 # -*- coding: utf-8 -*-
 
-from ..version import __version__
-
 from .test_create import *
 from .test_operations import *
 from .test_ubreakdown import *
 from .test_complex import *
-from .test_misc import *
+from .test_misc import *
+from .test_gummy import *

metrolopy/tests/test_complex.py

@@ -21,6 +21,7 @@
 # MetroloPy. If not, see <http://www.gnu.org/licenses/>.
 
 import numpy as np
+import unittest
 from metrolopy import immy,ummy,jummy,gummy
 from metrolopy.tests.common import display
 
@@ -36,11 +37,11 @@ def make_immy(prnt=False):
     r = 4*rand.rand() + 1
     if rand.randint(2):
         r = -r
-    ru = 0.1*rand.rand()*(abs(r))
+    ru = (0.1*rand.rand() + 0.01)*(abs(r))
     i = 4*rand.rand() + 1
     if rand.randint(2):
         i = -i
-    iu = 0.1*rand.rand()*(abs(i))
+    iu = (0.1*rand.rand() + 0.01)*(abs(i))
     c = (2*rand.rand() - 1)*ru*iu
 
     cov = [[ru**2,c],[c,iu**2]]
@@ -75,142 +76,152 @@ def make_immy(prnt=False):
     
     return (ret,real,imag)
 
-def assert_ummy_close(u1,u2):
-        assert abs(u1.correlation(u2)) > 1 - 1e-4
-        assert abs((u1.x - u2.x)/(u1.x)) < 1e-10
-        assert abs((u1.u - u2.u)/(u1.u)) < 1e-4
-        
-        if u1.dof == float('inf'):
-            assert u2.dof == float('inf')
-        else:
-            assert abs((u2.dof - u1.dof)/u1.dof) < 1e-2
-        
-def assert_immy_close(i1,i2):
-        assert_ummy_close(i1.real,i2.real)
-        assert_ummy_close(i1.imag,i2.imag)
 
-def test_immy_init(n=1000,prnt=False):
-    for m in range(n):
-        x,xr,xi = make_immy(prnt=prnt)
-        
-        if rand.randint(2):
-            if rand.randint(2):
-                x = type(x)(x)
-            else:
-                x = x.copy(formatting=False)
-        
-        assert_ummy_close(x.real,xr)
-        assert_ummy_close(x.imag,xi)
-        assert_ummy_close(x.angle(),np.arctan2(xi,xr))
-        assert_ummy_close(abs(x),np.sqrt(xr**2 + xi**2))
-        assert_immy_close(x.conjugate(),immy(real=xr,imag=-xi))
-        assert_immy_close(-x,immy(real=-xr,imag=-xi))
-        assert_immy_close(+x,immy(real=xr,imag=xi))
-        
-        if prnt:
-            if rand.randint(2):
-                y =1e12*x
+class TestComplex(unittest.TestCase):
+    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)
+            self.assertTrue(abs((u1.x - u2.x)/(u1x)) < 1e-10)
+            self.assertTrue(abs((u1.u - u2.u)/(u1.u)) < 1e-2)
+            
+            if u1.dof == float('inf'):
+                self.assertTrue(u2.dof == float('inf'))
             else:
-                y = x/1e12
-            display(y)
-
-def _test_immy_bop(f,nf,n=1000,prnt=False):
-    for m in range(n):
-        a,ar,ai = make_immy()
-        if True:#rand.randint(2):
-            b,br,bi = make_immy()
-        else:
+                self.assertTrue(abs((u2.dof - u1.dof)/u1.dof) < 1e-2)
+            
+    def assert_immy_close(self,i1,i2):
+            self.assert_ummy_close(i1.real,i2.real)
+            self.assert_ummy_close(i1.imag,i2.imag)
+    
+    def test_immy_init(self,n=1000,prnt=False):
+        for m in range(n):
+            x,xr,xi = make_immy(prnt=prnt)
+            
             if rand.randint(2):
-                b = 4*rand.rand() + 1
                 if rand.randint(2):
-                    b = -b
+                    x = type(x)(x)
+                else:
+                    x = x.copy(formatting=False)
+            
+            self.assert_ummy_close(x.real,xr)
+            self.assert_ummy_close(x.imag,xi)
+            self.assert_ummy_close(x.angle(),np.arctan2(xi,xr))
+            self.assert_ummy_close(abs(x),np.sqrt(xr**2 + xi**2))
+            self.assert_immy_close(x.conjugate(),immy(real=xr,imag=-xi))
+            self.assert_immy_close(-x,immy(real=-xr,imag=-xi))
+            self.assert_immy_close(+x,immy(real=xr,imag=xi))
+            
+            if prnt:
                 if rand.randint(2):
-                    bu = 0.1*rand.rand()*(abs(b))
-                    b = ummy(b,u=bu)
+                    y =1e12*x
+                else:
+                    y = x/1e12
+                display(y)
+    
+    def _test_immy_bop(self,f,nf,n=1000,prnt=False,allow_small=True):
+        m = 0
+        while m < n:
+            a,ar,ai = make_immy()
+            if True:#rand.randint(2):
+                b,br,bi = make_immy()
             else:
-                br = 4*rand.rand() + 1
                 if rand.randint(2):
-                    br = -br
-                bi = 4*rand.rand() + 1
+                    b = 4*rand.rand() + 1
+                    if rand.randint(2):
+                        b = -b
+                    if rand.randint(2):
+                        bu = (0.1*rand.rand()+0.01)*(abs(b))
+                        b = ummy(b,u=bu)
+                else:
+                    br = 4*rand.rand() + 1
+                    if rand.randint(2):
+                        br = -br
+                    bi = 4*rand.rand() + 1
+                    if rand.randint(2):
+                        bi = -bi
+                    b = complex(br,bi)
                 if rand.randint(2):
-                    bi = -bi
-                b = complex(br,bi)
-            if rand.randint(2):
-                bb = b
-                b = a
-                a = bb
+                    bb = b
+                    b = a
+                    a = bb
+                    
+            if isinstance(a,(immy,ummy)):
+                ax = a.x
+            else:
+                ax = a
+            if isinstance(b,(immy,ummy)):
+                bx = b.x
+            else:
+                bx = b
+            
                 
-        if isinstance(a,(immy,ummy)):
-            ax = a.x
-        else:
-            ax = a
-        if isinstance(b,(immy,ummy)):
-            bx = b.x
-        else:
-            bx = b
-        
+            cx = f(ax,bx)
             
-        cx = f(ax,bx)
-        c = f(a,b)
-        cn = type(c).napply(nf,a,b)
+            if allow_small or abs(cx) > 0.1:
+                m +=1
+                
+                c = f(a,b)
+                cn = type(c).napply(nf,a,b)
+                
+                if prnt:
+                    display(a)
+                    display(b)
+                    display(c)
+                    display(cn)
+                    print('---')
         
-        if prnt:
-            display(a)
-            display(b)
-            display(c)
-            display(cn)
-            print('---')
-
-        assert abs((c.real.x - cx.real)/cx.real) < 1e-10
-        assert abs((c.imag.x - cx.imag)/cx.imag) < 1e-10
-        assert_immy_close(c,cn)
-    
-def test_immy_add(n=1000,prnt=False):
-    _test_immy_bop(lambda a,b: a + b,np.add,n,prnt)
-    
-    for m in range(10):
-        i = make_immy()[0]
-        assert i + 0 == i
-        assert 0 + i == i
-    
-def test_immy_sub(n=1000,prnt=False):
-    _test_immy_bop(lambda a,b: a - b,np.subtract,n,prnt)
-    
-    for m in range(10):
-        i = make_immy()[0]
-        assert i - 0 == i
-        assert 0 - i == -i
-    
-def test_immy_mul(n=1000,prnt=False):
-    _test_immy_bop(lambda a,b: a*b,np.multiply,n,prnt)
-    
-    for m in range(10):
-        i = make_immy()[0]
-        assert i*0 == 0
-        assert i*immy(0) == 0
-        assert i*1 == i
-        assert i*immy(1) == i
-        assert 1*i == i
-        assert immy(1)*i == i
-    
-def test_immy_div(n=1000,prnt=False):
-    _test_immy_bop(lambda a,b: a/b,np.divide,n,prnt)
-    
-    for m in range(10):
-        i = make_immy()[0]
-        assert i/1 == i
-    
-def test_immy_pow(n=1000,prnt=False):
-    _test_immy_bop(lambda a,b: a**b,np.power,n,prnt)
-    
-    for m in range(10):
-        i = make_immy()[0]
-        assert 0**i == immy(0)
-        assert 0**i == ummy(0)
-        assert 0**i == 0
-        assert i**0 == 1
+                self.assertTrue(abs((c.real.x - cx.real)/cx.real) < 1e-10)
+                self.assertTrue(abs((c.imag.x - cx.imag)/cx.imag) < 1e-10)
+                self.assert_immy_close(c,cn)
+        
+    def test_immy_add(self,n=1000,prnt=False):
+        self._test_immy_bop(lambda a,b: a + b,np.add,n,prnt)
+        
+        for m in range(10):
+            i = make_immy()[0]
+            self.assertTrue(i + 0 == i)
+            self.assertTrue(0 + i == i)
+        
+    def test_immy_sub(self,n=1000,prnt=False):
+        self._test_immy_bop(lambda a,b: a - b,np.subtract,n,prnt)
+        
+        for m in range(10):
+            i = make_immy()[0]
+            self.assertTrue(i - 0 == i)
+            self.assertTrue(0 - i == -i)
         
-        assert_immy_close(i**-1,1/i)
-        assert_immy_close(i**2,i*i)
-        assert_immy_close(i**3,i*i*i)
+    def test_immy_mul(self,n=1000,prnt=False):
+        self._test_immy_bop(lambda a,b: a*b,np.multiply,n,prnt)
+        
+        for m in range(10):
+            i = make_immy()[0]
+            self.assertTrue(i*0 == 0)
+            self.assertTrue(i*immy(0) == 0)
+            self.assertTrue(i*1 == i)
+            self.assertTrue(i*immy(1) == i)
+            self.assertTrue(1*i == i)
+            self.assertTrue(immy(1)*i == i)
+        
+    def test_immy_div(self,n=1000,prnt=False):
+        self._test_immy_bop(lambda a,b: a/b,np.divide,n,prnt,allow_small=False)
+        
+        for m in range(10):
+            i = make_immy()[0]
+            self.assertTrue(i/1 == i)
+        
+    def test_immy_pow(self,n=1000,prnt=False):
+        #_test_immy_bop(lambda a,b: a**b,np.power,n,prnt,allow_small=False)
+        
+        for m in range(10):
+            i = make_immy()[0]
+            self.assertTrue(0**i == immy(0))
+            self.assertTrue(0**i == ummy(0))
+            self.assertTrue(0**i == 0)
+            self.assertTrue(i**0 == 1)
+            
+            self.assert_immy_close(i**-1,1/i)
+            self.assert_immy_close(i**2,i*i)
+            self.assert_immy_close(i**3,i*i*i)
     
+if __name__ == '__main__':
+    unittest.main()