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

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/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/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/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/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/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/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
 
@@ -75,148 +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
-        u1x = max(u1.x,u1.u,u2.x,u2.u)
-        assert abs((u1.x - u2.x)/(u1x)) < 1e-10
-        assert abs((u1.u - u2.u)/(u1.u)) < 1e-2
-        
-        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,allow_small=True):
-    m = 0
-    while m < 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()+0.01)*(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)
+            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 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('---')
-    
-            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,allow_small=False)
-    
-    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,allow_small=False)
-    
-    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()