metrolopy 0.6.3__tar.gz → 0.6.5__tar.gz

{metrolopy-0.6.3 → metrolopy-0.6.5}/PKG-INFO

@@ -1,12 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: metrolopy
-Version: 0.6.3
+Version: 0.6.5
 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
 Author-email: parksh@nrc.ca
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
@@ -18,8 +16,24 @@ Classifier: Intended Audience :: Education
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.5
 Description-Content-Type: text/markdown
-Provides-Extra: pretty
 License-File: LICENSE
+Requires-Dist: numpy>=1.13
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Provides-Extra: pretty
+Requires-Dist: IPython; extra == "pretty"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # MetroloPy
 
@@ -86,5 +100,3 @@ MetroloPy can do much more including Monte-Carlo uncertainty propagation, genera
 
 
 
-
-

{metrolopy-0.6.3 → metrolopy-0.6.5}/metrolopy/budget.py

@@ -1207,7 +1207,7 @@ class Budget(PrettyPrinter):
             if i == self.nx - 1 or i == self.nx+nt-1 or i == ndf-2:
                 txt += r'\hline'
                 txt += '\n'
-        txt += '\end{array}'
+        txt += '\\end{array}'
         return txt
 
     def _tohtml(self):

{metrolopy-0.6.3 → metrolopy-0.6.5}/metrolopy/dfunc.py

@@ -121,7 +121,6 @@ ddict = {np.sin: np.cos,
 
 fdict = {np.angle:  lambda x: x.angle(),
          np.around:  _f_around,
-         np.round_:  _f_around,
          np.heaviside:  _f_heaviside,
          np.absolute:  lambda x: abs(x),
          np.add:  _f_add,
@@ -154,6 +153,10 @@ fdict = {np.angle:  lambda x: x.angle(),
          np.isneginf:  lambda x: np.isneginf(x.x),
          np.isposinf:  lambda x: np.isposinf(x.x)
         }
+if np.lib.NumpyVersion(np.__version__) >= '1.25.0':
+    fdict[np.round] =  _f_around
+else:
+    fdict[np.round_] =  _f_around
 
 
 try_fconvert = True

{metrolopy-0.6.3 → metrolopy-0.6.5}/metrolopy/distributions.py

@@ -920,7 +920,7 @@ class UniformDist(Distribution):
                 if lower_limit >= upper_limit:
                     raise ValueError('lower_limit >= upper_limit')
                 self.center = (upper_limit + lower_limit)/2
-                self.half_width = upper_limit - lower_limit
+                self.half_width = (upper_limit - lower_limit)/2
         if upper_limit is not None:
             k += 1
             self.upper_limit = upper_limit

{metrolopy-0.6.3 → metrolopy-0.6.5}/metrolopy/fit.py

@@ -415,7 +415,7 @@ class _Fit:
             s = self.s
         else:
             s = self.sigma
-        return k*(np.sqrt(self.ypred(x).u + s**2))
+        return k*(np.sqrt(self.ypred(x).u**2 + s**2))
         
     
 class Fit(_Fit,PrettyPrinter):
@@ -2017,7 +2017,7 @@ class DoubleExpFit(Fit):
         return 'y = p(1)*exp(-x/p(2)) + p(3)*exp(-x/p(4)) + p(5)'
     
     def flatex(self):
-        return '$ y = p_{1}\exp(-x/p_{2}) + p_{3}\exp(-x/p_{4}) + p_{5} $'
+        return '$ y = p_{1}\\exp(-x/p_{2}) + p_{3}\\exp(-x/p_{4}) + p_{5} $'
     
     def fhtml(self):
         return '<i>y</i> = <i>p</i><sub>1</sub> exp(-<i>x</i>/<i>p</i><sub>2</sub>) + <i>p</i><sub>3</sub> exp(-<i>x</i>/<i>p</i><sub>4</sub>) + <i>p</i><sub>5</sub>'
@@ -2160,7 +2160,7 @@ class ExpFit(Fit):
         return 'y = p(1)*exp(x/p(2)) + p(3)'
     
     def flatex(self):
-        return '$ y = p_{1}\exp(x/p_{2}) + p_{3} $'
+        return '$ y = p_{1}\\exp(x/p_{2}) + p_{3} $'
     
     def fhtml(self):
         return '<i>y</i> = <i>p</i><sub>1</sub> exp(<i>x</i>/<i>p</i><sub>2</sub>) + <i>p</i><sub>3</sub>'

{metrolopy-0.6.3 → metrolopy-0.6.5}/metrolopy/gummy.py

@@ -1695,13 +1695,11 @@ class gummy(Quantity,metaclass=MetaGummy):
             else:
                 slashaxis = gummy.slashaxis
             
-        if isinstance(g,nummy):
-            if g.name is not None:
-                name = g.name
-            else:
-                name = None
-        else:
-            name = g
+        try:
+            name = g.name
+        except:
+            name = None
+
         if name == '':
             name = None
             
@@ -1721,7 +1719,10 @@ class gummy(Quantity,metaclass=MetaGummy):
                 name = str(name).replace(' ','\\,').strip()
                 xl += norm(name)
             else:
-                xl += str(name).strip()
+                try:
+                    xl += name.tolatex()
+                except:
+                    xl += str(name).strip()
         if symbol is not None:
             if xl != '':
                 if slashaxis:
@@ -2861,7 +2862,7 @@ class gummy(Quantity,metaclass=MetaGummy):
             return '{:.4f}'.format(x) + pct
         if x < 99.9999:
             return '{:.5f}'.format(x) + pct
-        return str(x) + ' %'
+        return str(x) + pct
         
     @staticmethod
     def _k_to_str(k):

{metrolopy-0.6.3 → metrolopy-0.6.5}/metrolopy/tests/__init__.py

@@ -1,7 +1,5 @@
 # -*- coding: utf-8 -*-
 
-from ..version import __version__
-
 from .test_create import *
 from .test_operations import *
 from .test_ubreakdown import *

metrolopy-0.6.5/metrolopy/tests/test_complex.py

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+
+# module test_complex
+
+# Copyright (C) 2019 National Research Council Canada
+# Author:  Harold Parks
+
+# This file is part of MetroloPy.
+
+# MetroloPy is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software 
+# Foundation, either version 3 of the License, or (at your option) any later 
+# version.
+
+# MetroloPy is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more 
+# details.
+
+# You should have received a copy of the GNU General Public License along with 
+# 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
+
+rand = np.random.RandomState()
+
+def make_immy(prnt=False):
+    if rand.randint(2):
+        imake = immy
+        make = ummy
+    else:
+        imake = jummy
+        make = gummy
+    r = 4*rand.rand() + 1
+    if rand.randint(2):
+        r = -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() + 0.01)*(abs(i))
+    c = (2*rand.rand() - 1)*ru*iu
+
+    cov = [[ru**2,c],[c,iu**2]]
+    real,imag = make.create([r,i],covariance_matrix=cov)
+    
+    if rand.randint(2):
+        ret = imake(real=real,imag=imag)
+    else:
+        if rand.randint(2):
+            ret = imake(real=r,imag=i,cov=cov)
+            assert abs(ret.real.covariance(ret.imag) - cov[0][1]) < 1e-6
+            if imake is immy:
+                real._ref = ret.real._ref
+                imag._ref = ret.imag._ref
+            else:
+                real.value._ref = ret.real.value._ref
+                imag.value._ref = ret.imag.value._ref
+        else:
+            r = np.sqrt(real**2 + imag**2)
+            phi = np.arctan2(imag,real)
+            ret = imake(r=r.x,phi=phi.x,cov=make.covariance_matrix([r,phi]))
+            assert abs(ret.real.covariance(ret.imag) - cov[0][1]) < 1e-6
+            if imake is immy:
+                real._ref = ret.real._ref
+                imag._ref = ret.imag._ref
+            else:
+                real.value._ref = ret.real.value._ref
+                imag.value._ref = ret.imag.value._ref
+                
+    if prnt:
+        display(ret)
+    
+    return (ret,real,imag)
+
+
+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:
+                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):
+                if rand.randint(2):
+                    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):
+                    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:
+                if rand.randint(2):
+                    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):
+                    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
+            
+                
+            cx = f(ax,bx)
+            
+            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('---')
+        
+                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)
+        
+    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()