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

metrolopy/budget.py

@@ -250,7 +250,7 @@ class Budget(PrettyPrinter):
         g.style = 'xf'
         if nsig is not None:
             g.nsig = nsig
-        return g.tostring(fmt)
+        return g.tostring(fmt,show_name=False)
     
     units_on_values = None
     show_s = True
@@ -828,9 +828,9 @@ class Budget(PrettyPrinter):
                         xst = 'xf'
                     
                 fvalues = [g.x for g in self._dfx['x']]
-                values = [g.tostring(style=xst,solidus=self.solidus,mulsep=self.mulsep) for g in self._dfx['x']]
-                hvalues = [g.tostring(fmt='html',style=xst,solidus=self.solidus,mulsep=self.mulsep) for g in self._dfx['x']]
-                lvalues = [g.tostring(fmt='latex',style=xst,solidus=self.solidus,mulsep=self.mulsep) for g in self._dfx['x']]
+                values = [g.tostring(style=xst,solidus=self.solidus,mulsep=self.mulsep,show_name=False) for g in self._dfx['x']]
+                hvalues = [g.tostring(fmt='html',style=xst,solidus=self.solidus,mulsep=self.mulsep,show_name=False) for g in self._dfx['x']]
+                lvalues = [g.tostring(fmt='latex',style=xst,solidus=self.solidus,mulsep=self.mulsep,show_name=False) for g in self._dfx['x']]
                 
                 if self.show_subtotals:
                     for t in self.type.values():
@@ -843,9 +843,9 @@ class Budget(PrettyPrinter):
                     fvalues.append(self._y.xsim)
                 else:
                     fvalues.append(self._y.x)
-                values.append(self._y.tostring(style=xst))
-                hvalues.append(self._y.tostring(fmt='html',style=xst))
-                lvalues.append(self._y.tostring(fmt='latex',style=xst))
+                values.append(self._y.tostring(style=xst,show_name=False))
+                hvalues.append(self._y.tostring(fmt='html',style=xst,show_name=False))
+                lvalues.append(self._y.tostring(fmt='latex',style=xst,show_name=False))
                 
                 if show_exu:
                     fvalues.append(None)
@@ -877,30 +877,30 @@ class Budget(PrettyPrinter):
                         ust = 'uf'
                     
                 fu = [g.u for g in self._dfx['x']]
-                u = [g.tostring(style=ust,solidus=self.solidus,mulsep=self.mulsep) for g in self._dfx['x']]
-                hu = [g.tostring(fmt='html',style=ust,solidus=self.solidus,mulsep=self.mulsep) for g in self._dfx['x']]
-                lu = [g.tostring(fmt='latex',style=ust,solidus=self.solidus,mulsep=self.mulsep) for g in self._dfx['x']]
+                u = [g.tostring(style=ust,solidus=self.solidus,mulsep=self.mulsep,show_name=False) for g in self._dfx['x']]
+                hu = [g.tostring(fmt='html',style=ust,solidus=self.solidus,mulsep=self.mulsep,show_name=False) for g in self._dfx['x']]
+                lu = [g.tostring(fmt='latex',style=ust,solidus=self.solidus,mulsep=self.mulsep,show_name=False) for g in self._dfx['x']]
                 
                 if self.show_subtotals:
                     for t in self.type.values():
                         fu.append(t[2].U)
-                        u.append(t[2].tostring(style=ust_g,solidus=self.solidus,mulsep=self.mulsep))
-                        hu.append(t[2].tostring(fmt='html',style=ust_g,solidus=self.solidus,mulsep=self.mulsep))
-                        lu.append(t[2].tostring(fmt='latex',style=ust_g,solidus=self.solidus,mulsep=self.mulsep))
+                        u.append(t[2].tostring(style=ust_g,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
+                        hu.append(t[2].tostring(fmt='html',style=ust_g,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
+                        lu.append(t[2].tostring(fmt='latex',style=ust_g,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
                             
                 fu.append(self._yu.U)
-                u.append(self._yu.tostring(style=ust,solidus=self.solidus,mulsep=self.mulsep))
-                hu.append(self._yu.tostring(fmt='html',style=ust,solidus=self.solidus,mulsep=self.mulsep))
-                lu.append(self._yu.tostring(fmt='latex',style=ust,solidus=self.solidus,mulsep=self.mulsep))
+                u.append(self._yu.tostring(style=ust,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
+                hu.append(self._yu.tostring(fmt='html',style=ust,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
+                lu.append(self._yu.tostring(fmt='latex',style=ust,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
                 if show_exu:
                     if self.sim:
                         g = gummy(self._y.x,self._y.ksim*self._y.usim,unit=self._y.unit)
                     else:
                         g = self._y
                     fu.append(g.U)
-                    u.append(g.tostring(style=ust_g,solidus=self.solidus,mulsep=self.mulsep))
-                    hu.append(g.tostring(fmt='html',style=ust_g,solidus=self.solidus,mulsep=self.mulsep))
-                    lu.append(g.tostring(fmt='latex',style=ust_g,solidus=self.solidus,mulsep=self.mulsep))
+                    u.append(g.tostring(style=ust_g,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
+                    hu.append(g.tostring(fmt='html',style=ust_g,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
+                    lu.append(g.tostring(fmt='latex',style=ust_g,solidus=self.solidus,mulsep=self.mulsep,show_name=False))
                     
                 cnm = cnmh = self.column_names.get(c)
                 if cnm is None:
@@ -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 += r'\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

@@ -915,12 +915,12 @@ class UniformDist(Distribution):
                 self.lower_limit = self.center - half_width 
         if lower_limit is not None:
             k += 1
-            self.lower_limit = upper_limit
+            self.lower_limit = lower_limit
             if upper_limit is not None:
                 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
@@ -1037,7 +1037,7 @@ class TriangularDist(Distribution):
         return self.mode
         
     def u(self):
-        return np.sqrt((self.lower_limit**2+self.upper_limit**2)/6)
+        return np.sqrt((self.left_width**2+self.right_width**2+self.left_width*self.right_width)/18)
         
 class ExponentialDist(Distribution):
     def __init__(self,scale=None,rate=None):

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

@@ -36,11 +36,11 @@ from .nummy import nummy
 from .exceptions import IncompatibleUnitsError,NoUnitConversionFoundError
 from .unit import Unit,one,Quantity
 from .distributions import Distribution,MultivariateDistribution
-from .pmethod import _Pmthd
+from .pmethod import _Pmthd,loc_from_k
 from .printing import MetaPrettyPrinter
 from math import isnan, isinf,log10
 from fractions import Fraction
-from numbers import Integral,Rational
+from numbers import Integral,Rational,Real,Complex
 
 
 try:
@@ -128,7 +128,7 @@ class MetaGummy(MetaPrettyPrinter):
         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.
@@ -504,6 +504,7 @@ class gummy(Quantity,metaclass=MetaGummy):
             self._value._fp = self._get_p
             self._unit = x._unit
             self._U = self._value._u
+            self._value._name = x._value._name
             self._k = 1
             self._pm = None
             self._set_k = True
@@ -526,21 +527,6 @@ class gummy(Quantity,metaclass=MetaGummy):
             self._set_k = True
             return
         
-        if isinstance(u,gummy):
-            uunit = u.unit
-            u = u.x
-        elif isinstance(u,Quantity):
-            uunit = u.unit
-            u = u.value
-        
-        if uunit is not None:
-            if u != 0:
-                uunit = Unit.unit(uunit)
-                if uunit is unit:
-                    uunit = None
-            else:
-                uunit = None
-            
         if p is not None:
             p = float(p)
             self._k = self._p_method.fptok(p,dof,gummy.bayesian)
@@ -560,9 +546,27 @@ class gummy(Quantity,metaclass=MetaGummy):
             if uunit is None:
                 self._U = _ku(self._k,self._value.u)
             else:
+                uunit = Unit.unit(uunit)
+                if uunit is unit:
+                    uunit = None
                 self._U = None
                 self._set_U(self._k,uunit)
             return
+        
+        if isinstance(u,gummy):
+            uunit = u.unit
+            u = u.x
+        elif isinstance(u,Quantity):
+            uunit = u.unit
+            u = u.value
+        
+        if uunit is not None:
+            if u != 0:
+                uunit = Unit.unit(uunit)
+                if uunit is unit:
+                    uunit = None
+            else:
+                uunit = None
 
         if uunit is not None and u != 0:
             U = Quantity(u,unit=uunit)
@@ -773,8 +777,9 @@ class gummy(Quantity,metaclass=MetaGummy):
         else:
             unit = self._U.unit
             x = float(self.unit.convert(self.xsim,unit))
-            ci = self.cisim          
-            return (ci[1] - x, x - ci[0])
+            ci1 = float(self.unit.convert(self.cisim[1],unit))
+            ci0 = float(self.unit.convert(self.cisim[0],unit))
+            return (ci1 - x, x - ci0)
         
         
     @property
@@ -884,19 +889,24 @@ class gummy(Quantity,metaclass=MetaGummy):
         return self.value.ksim
     
     @property
-    def independant(self):
+    def independent(self):
         """
         `bool`, read-only
 
         Returns `False` if the owning gummy was created from a operation involving
-        other gummys and `True` otherwise.
+        other gummys or has zero uncertainty and `True` otherwise.
         """
-        return self.value.independant
+        return self.value.independent
             
     @property
     def name(self):
         """
-        gets or sets an optional name for the gummy, may be `str` or `None`
+        gets or sets an optional name for the gummy, may be `str`, `None` or a
+        length four `tuple` of `str`.  If name is set to a length four tuple
+        the elements are, in order, the unicode name, the html name, the latex
+        name and the ASCII name.  Getting this property returns only the unicode
+        name not the full tuple.  Use the `get_name` method to get the name
+        in html, latex or ASCII format.
         """
         return self.value.name
     @name.setter
@@ -904,6 +914,23 @@ class gummy(Quantity,metaclass=MetaGummy):
         self.value.name = v
         
     def get_name(self,fmt='unicode',norm=None):
+        """
+
+        Parameters
+        ----------
+        fmt: The format, must be a `str` in {'unicode','html','latex','ascii'}.
+              The default is 'unicode'.
+        norm: An optional function which returns the name in nomral text.  This
+              function is applied to the name before it is returned if
+              fmt = 'latex', name has been set to single string, and the name
+              is more than one character long.  The default is 
+              '\\text{' + name + '}'.
+
+        Returns
+        -------
+        `str`, the name in the requested format.
+
+        """
         return self.value.get_name(fmt,norm)
     
     @property
@@ -1067,11 +1094,8 @@ class gummy(Quantity,metaclass=MetaGummy):
     def _get_p(self):
         #if self.u == 0:
             #return 1
-        if self._pm is not None:
-            if self._pm < 0:
-                return 0
-            return self._pm
-        self._pm = self._p_method.fktop(self._k,self.dof,self.bayesian)
+        if self._pm is None:
+            self._pm = self._p_method.fktop(self._k,self.dof,self.bayesian)
         if self._pm < 0:
                 return 0
         return self._pm
@@ -1115,6 +1139,9 @@ class gummy(Quantity,metaclass=MetaGummy):
         return self._get_p()
     @p.setter
     def p(self,v):
+        if isinstance(v,str) and v.strip().lower() == 'ssd':
+            self.p = loc_from_k(1)
+            return
         if v <= 0 or v >= 1:
             raise ValueError('p is not in the interval (0,1)')
         self._pm = v
@@ -1171,7 +1198,7 @@ class gummy(Quantity,metaclass=MetaGummy):
     def covariance_sim(self,gummy):
         """
         Returns the covariance, calculated from Monte-Carlo data, between the 
-        owning gummy and the gummy `g.`
+        owning gummy and the gummy `g`.
         
         See the method `gummy.covariance(g)` for the corresponding result based
         on first order error propagation.
@@ -1458,7 +1485,7 @@ class gummy(Quantity,metaclass=MetaGummy):
         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.
@@ -3173,78 +3200,117 @@ class gummy(Quantity,metaclass=MetaGummy):
         if isinstance(v,np.ndarray):
             return np.array(self) + v
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return jummy(self) + v
+        
         return super().__add__(v)
     
     def __radd__(self,v):
         if isinstance(v,np.ndarray):
             return v + np.array(self)
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return v + jummy(self)
+        
         return super().__radd__(v)
     
     def __sub__(self,v):
         if isinstance(v,np.ndarray):
             return np.array(self) - v
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return jummy(self) - v
+        
         return super().__sub__(v)
     
     def __rsub__(self,v):
         if isinstance(v,np.ndarray):
             return v - np.array(self)
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return v - jummy(self)
+        
         return super().__rsub__(v)
     
     def __mul__(self,v):
         if isinstance(v,np.ndarray):
             return np.array(self)*v
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return jummy(self)*v
+        
         return super().__mul__(v)
     
     def __rmul__(self,v):
         if isinstance(v,np.ndarray):
             return v*np.array(self)
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return v*jummy(self)
+        
         return super().__rmul__(v)
     
     def __truediv__(self,v):
         if isinstance(v,np.ndarray):
             return np.array(self)/v
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return jummy(self)/v
+        
         return super().__truediv__(v)
     
     def __rtruediv__(self,v):
         if isinstance(v,np.ndarray):
             return v/np.array(self)
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return v/jummy(self)
+        
         return super().__rtruediv__(v)
         
     def __pow__(self,v):
         if isinstance(v,np.ndarray):
             return np.array(self)**v
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return jummy(self)**v
+        
         return super().__pow__(v)
     
     def __rpow__(self,v):
         if isinstance(v,np.ndarray):
             return v**np.array(self)
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return v**jummy(self)
+        
         return super().__rpow__(v)
         
     def __floordiv__(self,v):
         if isinstance(v,np.ndarray):
             return np.array(self) // v
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return jummy(self) // v
+        
         return super().__floordiv__(v)
         
     def __rfloordiv__(self,v):
         if isinstance(v,np.ndarray):
             return v // np.array(self)
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return v // jummy(self)
+        
         return super().__rfloordiv__(v)
         
     def __mod__(self,v):
         if isinstance(v,np.ndarray):
             return np.array(self) % v
         
+        if isinstance(v,Complex) and not isinstance(v,Real):
+            return jummy(self) % v
+        
         return super().__mod__(v)
     
     def __rmod__(self,v):

metrolopy/mean.py

@@ -26,6 +26,7 @@ Some miscellaneous functions that are useful for uncertainty analysis.
 
 import numpy as np
 from .gummy import gummy
+from .distributions import TDist
 import datetime
 
 def autocorrelation(x):
@@ -181,7 +182,7 @@ def wmean(x,chi_correct=False):
         
     return ret
     
-def mean(x,n_sigma_trim=3,unit=1,ignore_nan=True,use_n_eff=None,bayesian=None):
+def mean(x,n_sigma_trim=3,unit=1,ignore_nan=True,use_n_eff=None):
     """
     Returns a gummy representing the mean of a float array.
     
@@ -211,7 +212,7 @@ def mean(x,n_sigma_trim=3,unit=1,ignore_nan=True,use_n_eff=None,bayesian=None):
         If bayesian is `False` the standard uncertainty of the returned
         gummy is s/sqrt(n) where s is the standard deviation of x and n is
         the the number of samples (or n_eff).  If bayesian is `True` then
-        the standard uncertainty is ((n-1)/(n-3))*s/sqrt(n).  If bayesian
+        the standard uncertainty is sqrt((n-1)/(n-3))*s/sqrt(n).  If bayesian
         is `None` then the value of `gummy.bayesian` will be used.  The
         default value is `None`.
     """
@@ -231,16 +232,11 @@ def mean(x,n_sigma_trim=3,unit=1,ignore_nan=True,use_n_eff=None,bayesian=None):
     if dof < 1:
         dof = 1
         
-    if bayesian is None:
-        bayesian = gummy.bayesian
-    if bayesian:
-        if dof <= 2:
-            raise ValueError('dof is ' + str(dof) + '; it must be > 2')
-        u = (dof/(dof - 2))*float(np.std(x,ddof=1))/np.sqrt(n)
-        return gummy(m,u,unit=unit)
-    else:
-        u = float(np.std(x,ddof=1))/np.sqrt(n)
-        return gummy(m,u,dof=dof,unit=unit)
+    u = float(np.std(x,ddof=1))/np.sqrt(n)
+    if gummy.bayesian:
+        u *= np.sqrt(dof/(dof-2))
+
+    return gummy(m,u,dof=dof,unit=unit)
     
 def sigma_trim(x, n_sigma = 3):
     """
@@ -288,7 +284,7 @@ def delta_diff(x):
     z[0::2] = -z[0::2]
     return z
 
-def delta_diff_mean(x,n_sigma=None,unit=1,bayesian=None):
+def delta_diff_mean(x,n_sigma=None,unit=1):
     """
     Returns a gummy representing the mean value and uncertainty of a delta 
     type difference taken on the data.  A delta type difference removes a 
@@ -313,7 +309,7 @@ def delta_diff_mean(x,n_sigma=None,unit=1,bayesian=None):
         If bayesian is `False` the standard uncertainty of the returned
         gummy is s/sqrt(n) where s is the standard deviation of x and n is
         the the number of samples (or n_eff).  If bayesian is `True` then
-        the standard uncertainty is ((n-1)/(n-3))*s/sqrt(n).  If bayesian
+        the standard uncertainty is sqrt((n-1)/(n-3))*s/sqrt(n).  If bayesian
         is `None` then the value of `gummy.bayesian` will be used.  The
         default value is `None`.
             
@@ -335,12 +331,8 @@ def delta_diff_mean(x,n_sigma=None,unit=1,bayesian=None):
     sd = np.std(diff,ddof=1)
     u = (np.sqrt(4*n-11)/(n-2))*sd
     dof = (4*n-11)**2/(41/2+16*(n-4))
-    
-    if bayesian is None:
-        bayesian = gummy.bayesian
-    if bayesian:
-        u = u*dof/(dof-2)
-        return gummy(mn,u,unit=unit)
+    if gummy.bayesian:
+        u *= np.sqrt(dof/(dof-2))
     
     return gummy(mn,u,dof=dof,unit=unit)