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

metrolopy/ummy.py

@@ -2,7 +2,7 @@
 
 # module ummy
 
-# Copyright (C) 2019 National Research Council Canada
+# Copyright (C) 2025 National Research Council Canada
 # Author:  Harold Parks
 
 # This file is part of MetroloPy.
@@ -29,27 +29,29 @@ of gummy.
 """
 
 import numpy as np
-import weakref
 from collections import namedtuple
 from warnings import warn
-from math import isnan,isinf,log,log10,pi
+from math import isnan,isinf,log,pi,sqrt,copysign,floor
 from fractions import Fraction
-from numbers import Rational,Integral,Real,Complex
+from numbers import Rational,Integral,Real,Complex,Number
 from .printing import PrettyPrinter,MetaPrettyPrinter
 from .dfunc import Dfunc
 from .exceptions import UncertiantyPrecisionWarning
-from .unit import Unit,one,Quantity
+from .unit import Unit,one,Quantity,MFraction
+from decimal import Decimal,localcontext,InvalidOperation
+from abc import ABCMeta
 
 try:
-    from mpmath import mp,mpf,rational
+    from mpmath import mp,mpf
 except:
     mp = mpf = None
 
+
 _FInfo = namedtuple('_FIinfo','rel_u precision warn_u ')
 _iinfo = _FInfo(rel_u=0,precision=0,warn_u=0)
 _finfodict = {}
 def _getfinfo(x):
-    if isinstance(x,Rational):
+    if isinstance(x,Rational) or isinstance(x,Decimal):
         return (_iinfo,x)
     
     if mpf is not None and isinstance(x,mpf):
@@ -85,6 +87,11 @@ def _combu(a,b,c):
     # with 1 >= c >= -1,
     # this method avoids overflows or underflows when taking the squares
     
+    if b == 0:
+        return a
+    if a == 0:
+        return b
+    
     if isnan(a) or isnan(b):
         try:
             return type(a)('nan')
@@ -93,39 +100,37 @@ def _combu(a,b,c):
     
     if abs(b) > abs(a):
         a,b = b,a
-    if b == 0:
-        return abs(a)
         
     r = b/a
     x = 1 + r**2 + 2*c*r
     
     if x < 0:
         if x < -1e6:
-            # something horrible happened, should only get here due to a bug
+            # something horrible happened, a bug must have generated a value of
+            # for c that allows this
             raise FloatingPointError('u is sqrt of ' + str(a**2*x))
-        # maybe possibly get here due to a floating point rounding error somewhere
+        # maybe possibly get here due to a floating point rounding error
         return 0
     
-    return abs(a)*x**0.5     
+    if hasattr(x,'sqrt'):
+        return abs(a)*x.sqrt()
+    return abs(a)*x**0.5   
 
 def _isscalar(x):
+    if isinstance(x,str):
+        return True
     try:
         len(x)
         return False
     except:
         return True
-    
-def _floor(x):
-    if x < 0:
-        return int(x) - 1
-    return int(x)
 
-def _sign(x):
-    if x < 0:
-        return -1
-    return 1
+def sign(x):
+    return copysign(1,x)
 
 def _format_exp(fmt,xp):
+    if xp == 0:
+        return ''
     if fmt == 'html':
         ex = ' &times; 10<sup>' + str(xp) + '</sup>'
     elif fmt == 'latex':
@@ -137,8 +142,175 @@ def _format_exp(fmt,xp):
         ex += str(xp)
     return ex
 
+def _to_decimal(x,max_digits=None):
+    # called from the ummy and gummy tostring methods to convert x and u values.
+    # The Decimal data type has some convinent methods for rounding numbers to
+    # show a given number of significant figures.
+    
+    if mpf is not None and isinstance(x,mpf):
+         xd = Decimal(mp.nstr(x,n=mp.dps))
+    elif isinstance(x,Rational):
+        if max_digits is None:
+            max_digits = ummy.max_digits
+        with localcontext(prec=max_digits):
+            try:
+                xd = Decimal(x.numerator)/Decimal(x.denominator)
+            except:
+                try:
+                    xd = Decimal(str(x.numerator))/Decimal(str(x.denominator))
+                except:
+                    xd = Decimal(float(x.numerator))/Decimal(float(x.denominator))
+    else:
+        try:
+            xd = Decimal(x)
+        except:
+            try:
+                xd = Decimal(str(x))
+            except:
+                xd = Decimal(float(x))
+    return xd
+
+def _decimal_str(x,fmt='unicode',rtrim=False,dplace=0,dalign=None,th_spaces=True):
+    # string formats a Decimal number, putting digits in groups of three
+    # separated by spaces if necessary
+    
+    if x.is_nan():
+        return 'nan'
+    if x.is_infinite() and x > 0:
+        if fmt == 'html':
+            return '&infin;'
+        if fmt == 'latex':
+            return r'\infty'
+        if fmt == 'ascii':
+            return 'inf'
+        return '\u221E'
+    if x.is_infinite() and x < 0:
+        if fmt == 'html':
+            return '-&infin;'
+        if fmt == 'latex':
+            return r'-\infty'
+        if fmt == 'ascii':
+            return '-inf'
+        return '-\u221E'
+    
+    s,d,e = x.as_tuple()
+    
+    if dalign is not None:
+        dplace = len(d) + e - 1 - dalign
+        
+    if rtrim:
+        if dplace is not None and dplace > 0:
+            dp = dplace
+        else:
+            dp = 0
+            
+        i = len(d)
+        while i > dp + 1 and d[i-1] == 0:
+            i -= 1
+        if i != len(d):
+            d = d[:i]
+            
+    if dplace is None:
+        th_spaces = False
+    else:
+        th_spaces &= (dplace > 3 or len(d) - dplace > 5)
+        if dplace < 0:
+            d = (0,)*(-dplace) + d
+            dplace = 0
+        elif x != 0 and dplace > len(d) - 1:
+            d = d + (0,)*(dplace - len(d) + 1)
+        
+    if th_spaces:
+        if fmt == 'html':
+            sp = '&thinsp;'
+        elif fmt == 'latex':
+            sp = r'\,'
+        else:
+            sp = ' '
+        
+    if s and x != 0:
+        txt = '-'
+    else:
+        txt = ''
+    
+    for i in range(len(d)):
+        if i > 0 and dplace is not None:
+            if i == dplace + 1:
+                txt += '.'
+            elif th_spaces and (i - dplace - 1) % 3 == 0:
+                txt += sp
+        txt += chr(48 + d[i])
+    
+    return txt
+                
+def _xtype(x):
+    # this is used when type conversions are needed, e.g. to convert float 
+    # correlations or uncertainties to Decimal when dealing with ummy's
+    # with Decimal x values.
+    
+    if isinstance(x,np.ndarray):
+        tp = x.dtype.type
+    else:
+        tp = type(x)
+    if not issubclass(tp,Number):
+        return float
+    if issubclass(tp,Integral):
+        return MFraction.fromnum
+    return tp
+
+def _combrd(xl,du):
+    ret = _udict(xl[0]._ref)
+    for r in ret:
+        #ret[r] *= sign(xl[0]._u)*du[0]
+        ret[r] *= du[0]
+
+    for i in range(len(xl) - 1):
+        c = sign(xl[i+1]._u)*du[i+1]
+        for k,v in xl[i+1]._ref.items():
+            f = v*c
+            if k in ret:
+                ret[k] += f
+            else:
+                ret[k] = f
+    
+    n = sum([i**2 for i in ret.values()])
+    if abs(n-1) > ummy.correlation_tolerance:
+        n = sqrt(n)
+        for k,v in ret.items():
+            ret[k] /= n
+        
+    for k,v in list(ret.items()):
+        x = ret[k]
+        if x < -1 + ummy.correlation_tolerance:
+            return _udict(((k,-1),))
+        elif x > 1 - ummy.correlation_tolerance:
+            return _udict(((k,1),))
+        elif abs(ret[k]) < ummy.correlation_tolerance:
+            del ret[k]
+                
+    return ret
+
+
+# Correlations between ummy's are stored in a _udict instance.  
+# The keys in the _udict are _UmmyRef instances that reprensent independent 
+# variables and store the dof and utype of the variable.  The values are the 
+# correlation of the ummy with those independent variables (to within a sign) 
+# and are also equal to the deriviative of the ummy with respect to each of 
+# those variables divided by the combined standard uncertainty of the ummy.
+class _udict(dict):
+    pass
 
-class ummy(Dfunc,PrettyPrinter):
+class _UmmyRef:
+    __slots__ = 'dof','utype'
+    def __init__(self,dof=None,utype=None,dist=None):
+        self.dof = dof
+        self.utype = utype
+
+
+class MetaUmmy(MetaPrettyPrinter,ABCMeta):
+    pass
+
+class ummy(Dfunc,PrettyPrinter,Number,metaclass=MetaUmmy):
     max_dof = 10000 # any larger dof will be rounded to float('inf')
     nsig = 2 # The number of digits to quote the uncertainty to
     thousand_spaces = True # If true spaces will be placed between groups of three digits.
@@ -155,7 +327,12 @@ class ummy(Dfunc,PrettyPrinter):
     # rounding errors
     rounding_u = False
     
-    max_digits = 15
+    max_digits = 20
+    
+    # correlations with absolute values smaller that this are rounded to
+    # zero and correlations samaller than -1 + correlation_tolerance or
+    # bigger than 1 - correlation_tolerance are rounded to -1 or 1 respectively.
+    correlation_tolerance = 1e-14
     
     def __init__(self,x,u=0,dof=float('inf'),utype=None):
         if isinstance(x,Quantity):
@@ -165,26 +342,25 @@ class ummy(Dfunc,PrettyPrinter):
              self._copy(x,self,formatting=False)
              return
          
-        try:
-            float(x)
-        except TypeError:
-            raise TypeError('x must be a real number')
-            
-        try:
-            float(u)
-            if not isnan(u) and u < 0:
-                raise TypeError()
-        except TypeError:
-            raise TypeError('u must be a real number >= 0')
-            
-        if u == 0:
-            dof = float('inf')
-            utype = None
-            
+        # MFractions convert implicitly to Decimal or mpf
         if isinstance(x,Fraction):
-            x = MFraction(x)
+            x = MFraction(x) 
         if isinstance(u,Fraction):
             u = MFraction(u)
+            
+        # sometimes numpy.array of shape () appear and cause problems
+        if isinstance(x,np.ndarray):
+            x = x.item()
+        if isinstance(u,np.ndarray):
+            u = u.item()
+            
+        try:
+            float(x)
+            hash(x)
+        except TypeError:
+            raise TypeError('x must be a real number') from None
+        except ValueError:
+            raise ValueError('x must be a real number') from None
                 
         if self.rounding_u and not isinstance(x,Rational):
             finfo,x = _getfinfo(x)
@@ -193,10 +369,6 @@ class ummy(Dfunc,PrettyPrinter):
             else:
                 u = _combu(u,float(abs(x)*finfo.rel_u),0)
             
-            #uinfo = _getfinfo(u)[0]
-            #if uc < uinfo.warn_u and u is not 0:
-                #warn('a gummy/ummy was defined with an uncertainty too small to be accurately represented by a float\nuncertainty values may contain significant numerical errors',UncertiantyPrecisionWarning)
-            
             self._finfo = finfo
         else:
             self._finfo = None
@@ -205,29 +377,80 @@ class ummy(Dfunc,PrettyPrinter):
         self._x = x
         self._u = u
         
-        self._refs = 1
-        if not isinf(u) and not isnan(u) and u > 0:
-            if isinstance(dof,_GummyRef):
+        if not isinf(u) and not isnan(u) and u != 0:
+            if isinstance(dof,_udict):
+                # If the ummy has been created from a mathematical operation
+                # between other ummy's then correlations with the independent 
+                # variables are stored in the _udict.  The keys in the _udict
+                # are _UmmyRef instances that represent independent 
+                # variables and store the dof and utype of the variable.  The
+                # values are the correlation of the ummy with those independent
+                # variables (to within a sign) and are also equal to the
+                # deriviative of the ummy with respect to each of those variables
+                # divided by self._u.  The actual value of the
+                # dof property will be computed with the W-S apporoximation.
+                # u may be negative indicating that it is sharing a _ref 
+                # _udict with another ummy and has correlation = -1 with that 
+                # ummy: e.g. if the ummy is the result of the operation 1 - x
+                # we don't bother to create a new _udict for the ummy, we just
+                # use x._ref with self._u having the opposite sign from x._u.
                 self._ref = dof
-                self._refs = utype
+                
+                # _dof and _utype are set to None for now and will be computed
+                # if and when the dof and utype properties are called for the
+                # first time.
+                self._dof = None
+                self._utype = None
             else:
+                # The ummy represents an independent variable, that is u > 0
+                # and it is not (at this moment) correlated with any other
+                # ummy's.  
+                    
                 try:
-                    if isinstance(dof,Integral):
-                        dof = int(dof)
+                    float(u)
+                    hash(u)
+                    if not isnan(u) and u < 0:
+                        raise ValueError()
+                except TypeError:
+                    raise TypeError('u must be a real number >= 0') from None
+                except ValueError:
+                    raise ValueError('u must be a real number >= 0') from None
+                    
+                try:
+                    if dof > self.max_dof:
+                        dof = float('inf')
                     else:
-                        dof = float(dof)
-                    if dof <= 0 or isnan(dof):
-                        raise TypeError()
+                        if isinstance(dof,Integral):
+                            dof = int(dof)
+                        else:
+                            dof = float(dof)
+                        if dof <= 0 or isnan(dof):
+                            raise ValueError()
+                except ValueError:
+                    raise ValueError('dof must be a real number > 0') from None
                 except TypeError:
-                    raise TypeError('dof must be a real number > 0')
-                if dof > self.max_dof:
-                    dof = float('inf')
+                    raise TypeError('dof must be a real number > 0') from None
+                if utype is not None and not isinstance(utype,str):
+                    raise TypeError('utype must be str or None')
+                
+                self._dof = dof
+                if utype is None:
+                    self._utype = [None]
+                else:
+                    self._utype = [utype]
                     
-                self._ref = _GummyRef(dof)
-                if utype is not None:
-                    GummyTag.set_tag(self,utype)
+                # create an _UmmyRef to represent the actual independent 
+                # variable and create a _udict with one entry defining 
+                # the correlation with that _UmmyRef to be 1
+                self._ref = _udict(((_UmmyRef(dof,utype),1),))
         else:
+            # if u == 0, then the ummy will have no correlation with any
+            # independent variables, no utype and the dof property will return
+            # float('inf')
+            
             self._ref = None
+            self._dof = None
+            self._utype = [None]
         
     @property
     def x(self):
@@ -235,7 +458,7 @@ class ummy(Dfunc,PrettyPrinter):
         
     @property
     def u(self):
-        return self._u
+        return abs(self._u)
         
     @property
     def dof(self):
@@ -246,30 +469,71 @@ class ummy(Dfunc,PrettyPrinter):
         ummy is based on.  If the ummy was created as the result of an 
         operation between two or more other gummys, then the dof is the effective
         number of degrees of freedom calculated using the Welch-Satterthwaite 
-        approximation.  Caution:  A variation of the the  Welch-Satterthwaite
-        approximation is used that takes into account correlations, see
-        [R. Willink, Metrologia, 44, 340 (2007)].  However correlations are
-        not handled perfectly.  So if accurate dof calculations are need, care
-        should be taken to ensure that correlations are not generated in
-        intermediate calculations.
+        approximation.
         """
+        if self._dof is not None:
+            return self._dof
+        
         if self._ref is None:
-            return float('inf')
-        if self._ref.dof < 1:
-            # Occasionally correlations can result in a _dof less than 1;
-            # see the _get_dof method.
-            return 1
-        return self._ref.dof
+            self._dof = float('inf')
+        else:
+            # if _dof has not been set yet, calculate it using the 
+            # Welch-Satterthwaite approximation and store the result in 
+            # self._dof.  self._ref is a dictionary and the keys are _UmmyRef
+            # instances representing the indedpendent variables and store the
+            # dof for those variables.  The values are the correlations of 
+            # self with those independent variables and these correlations
+            # are equal to the derivative of self with respect to each 
+            # independent variable divided by self.u.
+            
+            rdof = 0
+            for k,v in self._ref.items():
+                if k.dof is not None:
+                    rdof += v**4/k.dof
+            if rdof > 0:
+                rdof = 1/rdof
+                if rdof > self.max_dof:
+                    rdof = float('inf')
+                elif rdof < 1:
+                    rdof = 1
+                self._dof = rdof
+            else:
+                self._dof = float('inf')
+
+        return self._dof
     
     @property
-    def _dof(self):
-        if self._ref is None:
-            return float('inf')
-        return self._ref.dof
-    @_dof.setter
-    def _dof(self,v):
-        if self._ref is not None:
-            self._ref.dof = v
+    def utype(self):
+        """
+        `str`, `None` or a list containing strings and possibly `None`
+    
+        An arbitrary string value labeling the uncertainty type or or a 
+        list of types if the gummy was constructed from independent
+        variables with different utypes.
+        """
+        if self._utype is None:
+            # if _utype has not been set yet, go through all the independent 
+            # variables in self._ref and put all the utypes found in a set.
+            self._utype = []
+            for k in self._ref:
+                if k.utype not in self._utype:
+                    self._utype.append(k.utype)
+                
+        if len(self._utype) == 1:
+            return self._utype[0]
+        return self._utype
+
+    @property
+    def isindependent(self):
+        """
+        `bool`, read-only
+
+        Returns `True` if the ummy is an independent variable.  That is the 
+        ummy has u > 0 and was not correlated with any other ummy's when it was 
+        created or is perfectly correlated or anti-correlated (correlation 
+        coefficeint 1 or -1) with such an ummy.'
+        """
+        return (self._ref is not None) and len(self._ref) == 1
     
     @property
     def finfo(self):
@@ -278,16 +542,17 @@ class ummy(Dfunc,PrettyPrinter):
         return self._finfo
         
     @staticmethod
-    def _copy(s,r,formatting=True,tofloat=False):
+    def _copy(s,r,formatting=True,totype=None):
         # copies attributes of s to r
-        if tofloat:
-            r._x = float(s._x)
-            r._u = float(s._u)
+        if totype is not None:
+            r._x = totype(s._x)
+            r._u = totype(s._u)
         else:
             r._x = s._x
             r._u = s._u
         r._ref = s._ref
-        r._refs = s._refs
+        r._dof = s._dof
+        r._utype = s._utype
         r._finfo = s._finfo
 
         if formatting:
@@ -296,24 +561,24 @@ class ummy(Dfunc,PrettyPrinter):
             if s.thousand_spaces != type(r).thousand_spaces:
                 r.thousand_spaces = s.thousand_spaces
     
-    def copy(self,formatting=True,tofloat=False):
+    def copy(self,formatting=True,totype=None):
         """
         Returns a copy of the ummy.  If the `formatting` parameter is
         `True` the display formatting information will be copied and if
         `False` the display formatting will be set to the default for a
-        new gummy.  The default for `formatting` is `True`.  If tofloat
-        is true the x and u properties will be converted to float values
+        new gummy.  The default for `formatting` is `True`.  If totype
+        is defined the x and u properties will be converted to type `totype`
         before copying.
         """
         r = type(self).__new__(type(self))
-        self._copy(self,r,formatting=formatting,tofloat=tofloat)
+        self._copy(self,r,formatting=formatting,totype=totype)
         return r
         
     def tofloat(self):
         """
-        Returns a copy of the gummy with x an u converted to floats.
+        Returns a copy of the gummy with x an u converted to `float`.
         """
-        return self.copy(formatting=False,tofloat=True)
+        return self.copy(formatting=False,totype=float)
     
     def splonk(self):
         """
@@ -327,21 +592,27 @@ class ummy(Dfunc,PrettyPrinter):
         """
         Returns the correlation coefficient between `self` and `g`.
         """
-        if not isinstance(g,ummy):
+        if not isinstance(g,ummy) or self._ref is None or g._ref is None:
             return 0
-        if self._ref is None or g._ref is None:
+        
+        c = sign(self._u)*sign(g._u)*sum(g._ref[k]*v for k,v in self._ref.items() if k in g._ref)
+                
+        if abs(c) < ummy.correlation_tolerance:
             return 0
-        return (self._refs*g._refs)*self._ref.cor(g._ref)
+        if c < -1 + ummy.correlation_tolerance:
+            return -1
+        if c > 1 - ummy.correlation_tolerance:
+            return 1
+            
+        return float(c)
         
     def covariance(self,g):
         """
         Returns the covariance between `self` and `g`.
         """
-        if not isinstance(g,ummy):
-            return 0
-        if self._ref is None or g._ref is None:
-            return 0
-        return self._u*g._u*(self._refs*g._refs)*self._ref.cor(g._ref)
+        if isinstance(g,ummy):
+            return self.u*g.u*self.correlation(g)
+        return 0
         
     @staticmethod
     def correlation_matrix(gummys):
@@ -358,62 +629,9 @@ class ummy(Dfunc,PrettyPrinter):
         """
         return [[b.covariance(a) if isinstance(b,ummy) else 0 for b in gummys] 
                 for a in gummys]
-                                
-    @staticmethod
-    def _set_correlation_matrix(gummys, matrix):
-        n = len(gummys)
-        m = np.asarray(matrix)
-        
-        if not np.allclose(m.T,m,atol = 10*_GummyRef._cortol):
-            raise ValueError('the correlation matrix is not symmetric')
-        e,v = np.linalg.eigh(m)
-        if any(e <= -_GummyRef._cortol):
-            raise ValueError('the correlation matrix is not positive semi-definate')
-            
-        if m.shape != (n,n):
-            raise ValueError('matrix must have shape len(gummys) x len(gummys)')
-        
-        # Check that the diagonal elements are 1 (leaving room for rounding errors).
-        for i in range(n):
-            if abs(m[i][i] - 1.0) > 0.01:
-                raise ValueError('correlation matrix diagonal elements must be 1')
-            
-        # Set the correlations using the off diagonal elements.
-        for i in range(0,n):
-            for j in range ((i+1),n):
-                if m[i][j] != 0:
-                    if gummys[i]._ref is not None and gummys[j]._ref is not None:
-                        gummys[i]._ref.set_cor(gummys[j],m[i][j])
-                    else:
-                        raise ValueError('constants cannot have a non-zero correlation')
-                    
-    @staticmethod
-    def _set_covariance_matrix(gummys, matrix):
-        n = len(gummys)
-        try:
-            assert len(matrix) == n
-            for r in matrix:
-                assert len(r) == n
-        except:
-            raise ValueError('the covariance matrix must be a square matrix of the same length as gummys')
-        
-        # Set the u of each gummy using the diagonal of the matrix.
-        for i in range(n):
-            if matrix[i][i] == 0:
-                gummys[i]._u = 0
-                gummys[i]._ref = None
-            else:
-                if gummys[i]._ref is None:
-                    gummys[i]._ref = _GummyRef()
-                gummys[i]._u = matrix[i][i]**0.5
-        
-        # Set the correlations
-        m = [[e/(gummys[i]._u*gummys[j]._u) for j,e in enumerate(r)]
-             for i,r in enumerate(matrix)]
-        ummy._set_correlation_matrix(gummys,m)
         
     @classmethod
-    def create(cls,x,u=None,dof=None,correlation_matrix=None,
+    def create(cls,x,u=None,dof=None,utype=None,correlation_matrix=None,
                covariance_matrix=None):
         """
         A class method that creates a list of (possibly) correlated ummys.
@@ -447,84 +665,162 @@ class ummy(Dfunc,PrettyPrinter):
         a list of ummys
         """
        
-            
+        n = len(x)
         if covariance_matrix is not None:
             if correlation_matrix is not None:
                 raise TypeError('correlation_matrix and covariance_matrix cannot both be specified')
+            try:
+                u = [sqrt(covariance_matrix[i][i]) for i in range(n)]
+            except ValueError:
+                raise ValueError('the diagonal elements of the covariance matrix must be positive real numbers')
+            except IndexError:
+                raise ValueError('covariance must have shape len(gummys) x len(gummys)')
+            correlation_matrix = [[covariance_matrix[i][j]/(u[i]*u[j]) for i in range(n)] for j in range(n)]
+        else:
+            if u is None:
+                u = [0]*n
+            elif _isscalar(u):
+                u = [u]*n
+            
+        if correlation_matrix is not None:
+            if not _isscalar(dof):
+                if any(i != dof[0] for i in dof):
+                    raise TypeError('dof cannot be set individually of a correlation of covariance matrix is specified')
+                dof = dof[0]
+            if not _isscalar(utype):
+                if any(i != utype[0] for i in utype):
+                    raise TypeError('utype cannot be set individually of a correlation of covariance matrix is specified')
+                utype = utype[0]
                 
-        n = len(x)
-        if u is None:
-            u = [0]*n
-        elif _isscalar(u):
-            u = [u]*n
-        if dof is None:
-            dof = [float('inf')]*n
-        elif _isscalar(dof):
-            dof = [dof]*n
+            m = np.asarray(correlation_matrix)
             
-        ret = [cls(x[i],u=u[i],dof=dof[i]) for i in range(n)]
+            if not np.allclose(m.T,m,atol = sqrt(ummy.correlation_tolerance)):
+                raise ValueError('the correlation matrix is not symmetric')
+                
+            if m.shape != (n,n):
+                raise ValueError('the correlation matrix must have shape len(gummys) x len(gummys)')
             
-        if correlation_matrix is not None:
-            cls._set_correlation_matrix(ret, correlation_matrix)
+            for i in range(n):
+                if abs(m[i][i] - 1.0) > sqrt(ummy.correlation_tolerance):
+                    raise ValueError('correlation matrix diagonal elements must be 1')
+                    
+            # The correlated values can be constructed from a linear combination
+            # of indepedent variables with coefficients equal to the matrix
+            # square root of the correlation matrix.
+            val,vec = np.linalg.eig(m)
+            
+            # Round eigenvalues very close to zero to zero, allowing for small
+            # negative values that may appear due to the finite numerical 
+            # precision.
+            for i in range(n):
+                if val[i] < -ummy.correlation_tolerance:
+                    raise ValueError('the correlation matrix is not positive semi-definate')
+                if val[i] < ummy.correlation_tolerance:
+                    val[i] = 0
+            
+            # matrix sqaure root of m        
+            sqrtm = vec*np.sqrt(val)@np.linalg.inv(vec) 
+            
+            ind = [_UmmyRef(dof,utype) for _ in range(n)]
+            idof = [_udict(((ind[j],float(sqrtm[i][j])) for j in range(n))) 
+                    for i in range(n)]
+                        
+            ret = [cls(x[i],u=u[i],dof=idof[i]) for i in range(n)]
+            
+        else:
+            if dof is None:
+                dof = [float('inf')]*n
+            elif _isscalar(dof):
+                dof = [dof]*n
+                
+            if utype is None or isinstance(utype,str):
+                utype = [utype]*n
         
-        if covariance_matrix is not None:
-            cls._set_covariance_matrix(ret, covariance_matrix)
+            ret = [cls(x[i],u=u[i],dof=dof[i],utype=utype[i]) for i in range(n)]
             
         return ret
         
     def tostring(self,fmt='unicode',nsig=None,**kwds):
         if nsig is None:
             nsig = self.nsig
+        if nsig > self.max_digits - 2:
+            nsig = self.max_digits - 2
+        if nsig < 1:
+            nsig = 1
             
-        x = float(self._x)
         try:
-            xabs = abs(x)
-           
-            if xabs != 0 and not isinf(xabs) and not isnan(xabs):
-                xexp = _floor(log10(xabs))
-            else:
-                xexp = None
-                
-            u = float(self.u)
-            
-            if self._u == 0 or isnan(self._u) or isinf(self._u):
-                if xexp is None:
-                    return str(self._x)
+            uexp = 0
+            xexp = 0
+            dp = 0
+            xd = _to_decimal(self._x,max_digits=self.max_digits)
+            ud = _to_decimal(self.u)
+            with localcontext(prec=self.max_digits):
+                if ud == 0 or not ud.is_finite():
+                    if xd.is_finite():
+                        nm = False
+                        nd = self.max_digits
+                        if self.finfo is not None and self.finfo.precision > 0 and self.finfo.precision <= nd:
+                            nd = self.finfo.precision
+                            nm = True
+                        xd = round(xd,nd-xd.adjusted()-1)
+                        if xd == 0:
+                            xexp = 0
+                        else:
+                            xexp = xd.adjusted()
+                            
+                        if self._x == xd or nm:
+                            xd = xd.normalize()
                 else:
-                    if (((self.sci_notation is None and (xexp > self.sci_notation_high or xexp < self.sci_notation_low)) 
-                        or self.sci_notation) ):
-                        xtxt = self._format_mantissa(fmt,x*10**(-xexp),
-                                                     self.finfo.precision)
-                        etxt = _format_exp(fmt,xexp)
-                        return xtxt + etxt
+                    ud = round(ud,nsig-ud.adjusted()-1)
+                    ud = round(ud,nsig-ud.adjusted()-1) # round again in case 9 round up to 10 in the last line
+                    uexp = ud.adjusted()
+        
+                    if xd.is_finite():
+                        try:
+                            xd = xd.quantize(ud)
+                        except InvalidOperation:
+                            xd = round(xd,self.max_digits-xd.adjusted()-1)
+                            xexp = xd.adjusted()
+                                
+                        if abs(xd) < abs(ud):
+                            dp = xd.adjusted() - uexp
+                            xexp = uexp
+                        else:
+                            xexp = xd.adjusted()
                     else:
-                        return self._format_mantissa(fmt,x,
-                                                     self.finfo.precision)
-                    
-            uabs = abs(u)
-            if uabs != 0:
-                uexp = _floor(log10(uabs))
-                
-            if xexp is None:
-                xp = uexp
+                        xexp = uexp
+                        
+            scin = False
+            if self.sci_notation is None:
+                if xexp > self.sci_notation_high or xexp < self.sci_notation_low:
+                    scin = True
             else:
-                xp = max(xexp,uexp)
+                scin = self.sci_notation
+            if xexp > self.max_digits - 1:
+                scin = True
+            elif xexp < 0 and len(xd.as_tuple().digits) + self.sci_notation_low > self.max_digits - 1:
+                scin = True
+            elif ud.is_finite() and ud != 0 and xd.is_finite() and (xd.as_tuple()[2] > 0 or len(xd.as_tuple()[1]) < nsig):
+                scin = True
+
+            if not scin:
+                xexp = 0
                 
-            psn = (uexp - nsig + 1 > 0)
-            
-            if (((self.sci_notation is None and (xp > self.sci_notation_high or xp < self.sci_notation_low)) 
-                        or self.sci_notation) or psn or (xexp is not None and (uexp > xexp and xexp == 0))):
-                xtxt = self._format_mantissa(fmt,x*10**(-xp),-uexp+xp+nsig-1)
-                etxt = _format_exp(fmt,xp)
+            if xexp == 0:
+                txt =_decimal_str(xd,dalign=0,fmt=fmt)
             else:
-                xtxt = self._format_mantissa(fmt,x,-uexp+nsig-1)
-                etxt = ''
+                txt = _decimal_str(xd,dplace=dp,fmt=fmt)
                 
-            if nsig <= 0:
-                return xtxt + etxt
-    
-            utxt = self._format_mantissa(fmt,u*10**(-uexp),nsig-1,parenth=True)
-            return xtxt + '(' + utxt + ')' + etxt
+            if xd.is_finite():
+                if ud != 0:
+                    txt += '(' + _decimal_str(ud,dplace=None,fmt=fmt) + ')'
+                txt += _format_exp(fmt,xexp)
+            else:
+                if ud != 0:
+                    txt += '(' + _decimal_str(ud,dplace=None,fmt=fmt)
+                    txt += _format_exp(fmt,xexp) + ')'
+            return txt
+       
         except:
             try:
                 return(str(self.x) + '{' + str(self.u) + '}' + '??')
@@ -533,114 +829,9 @@ class ummy(Dfunc,PrettyPrinter):
                     return(str(self.x) + '{??}')
                 except:
                     return('??')
-          
-    def _format_mantissa(self,fmt,x,sig,parenth=False):            
-        try:
-            if isnan(x):
-                return 'nan'
-            if isinf(x) and x > 0:
-                if fmt == 'html':
-                    return '&infin;'
-                if fmt == 'latex':
-                    return r'\infty'
-                if fmt == 'ascii':
-                    return 'inf'
-                return '\u221E'
-            if isinf(x) and x < 0:
-                if fmt == 'html':
-                    return '-&infin;'
-                if fmt == 'latex':
-                    return r'-\infty'
-                if fmt == 'ascii':
-                    return '-inf'
-                return '-\u221E'
-        except:
-            pass
         
-        ellipses = ''
-        if isinstance(x,Rational) and sig is None:
-            if x == int(x):
-                s = str(int(x))
-            else:
-                xf = float(x)
-                e = 15 - _floor(log10(abs(xf)))
-                if e < 0:
-                    e = 0
-                n = 10**e*x
-                if int(n) != n:
-                    ellipses = '...'
-                s = str(round(xf,e))
-        elif sig is None:
-            s = str(x)
-        else:
-            if x != 0 and self.max_digits is not None:
-                if mpf is not None and isinstance(x,mpf):
-                    em = _floor(mp.log10(abs(x)))
-                else:    
-                    em = _floor(log10(abs(float(x))))
-                e = self.max_digits - em
-                if e < 0:
-                    e = 0
-                if sig > e and sig > 0:
-                    ellipses = '...'
-                    sig = e
-            if sig < 0:
-                sig = 0
-            if mpf is not None and isinstance(x,mpf):
-                s = mp.nstr(x,n=sig+1,strip_zeros=False)
-            else:
-                s = round(float(x),sig)
-                s = ('{:.' + str(sig) + 'f}').format(s)
-        
-        if parenth:
-            s = s.replace('.','')
-            s = s.lstrip('0')
-            if len(s) == 0:
-                s = '0'
-            return s
-        elif self.thousand_spaces:
-            # Now insert spaces every three digits
-            if fmt == 'html':
-                sp = '&thinsp;'
-            elif fmt == 'latex':
-                sp = r'\,'
-            else:
-                sp = ' '
-                
-            d = s.find('.')
-            if d != -1:
-                i = d + 1
-                while i < len(s) and s[i].isdigit():
-                    i += 1
-                nr = i - d - 1
-            else:
-                nr = 0
-                d = len(s)
-                
-            i = d - 1
-            while i > 0 and s[i].isdigit():
-                i -= 1
-            nl = d - i - 1
-            
-            if nr <= 4 and nl <= 4:
-                return s + ellipses
-                
-            s = list(s)    
-            if nr > 4:
-                for i in range(int(nr/3)):
-                    s.insert(d + i + (i+1)*3 + 1, sp)
-            if nl > 4:
-                for i in range(int(nl/3)):
-                    s.insert(d - (i+1)*3, sp)
-                    
-            s = ''.join(s)
-            if s.endswith(sp):
-                s = s[:-(len(sp))]
-                
-        return s + ellipses
-        
-    @classmethod
-    def _get_dof(cls,dof1,dof2,du1,du2,c):
+    #@classmethod
+    #def _get_dof(cls,dof1,dof2,du1,du2,c):
         # Use the Welch-Satterhwaite approximation to combine dof1 and dof2.
         # See [R. Willink, Metrologia, 44, 340 (2007)] concerning the use
         # of the Welch-Satterwaite approximation with correlated values.
@@ -653,23 +844,21 @@ class ummy(Dfunc,PrettyPrinter):
         # d = (du1**2 + c*du1*du2)**2/dof1 + (du2**2 + c*du1*du2)**2/dof2
         # Willink's formula is used in the _apply method but not here.
         
-        d = du1**4/dof1 + du2**4/dof2
-        d += 2*c**2*(((du1 + du2)**4 - du1**4 - du2**4)/
-                     ((1 - 2*c + 2*c**2)*(dof1+dof2)))
+        #d = du1**4/dof1 + du2**4/dof2
+        #d += 2*c**2*(((du1 + du2)**4 - du1**4 - du2**4)/
+                     #((1 - 2*c + 2*c**2)*(dof1+dof2)))
 
-        if d == 0:
-            return float('inf')
+        #if d == 0:
+            #return float('inf')
         
-        r = 1/d
-        if r > cls.max_dof:
-            return float('inf')
+        #r = 1/d
+        #if r > cls.max_dof:
+            #return float('inf')
         
-        #if r < -1e-6:
-            #raise ValueError('dof is negative')
-        if r < 0:
-            r = 1
+        #if r < 0:
+            #r = 1
         
-        return r
+        #return r
     
     @classmethod
     def _apply(cls,function,derivative,*args,fxdx=None):
@@ -682,57 +871,62 @@ class ummy(Dfunc,PrettyPrinter):
         if len(args) == 1:
             d = [d]
             
-        ad = [(a,a.u*p) for a,p in zip(args,d) 
-              if isinstance(a,ummy) and a._u != 0]
+        xtype = _xtype(fx)
+            
+        try:
+            ad = [(a,a._u*p) for a,p in zip(args,d) 
+                  if isinstance(a,ummy) and a._u != 0]
+        except TypeError:
+            ad = [(a,xtype(a._u)*p) for a,p in zip(args,d) 
+                  if isinstance(a,ummy) and a._u != 0]
         if len(ad) == 0:
             return cls(fx)
         args,du = list(map(list, zip(*ad)))
             
         if len(args) == 1:
-            refs = -args[0]._refs if du[0] < 0 else args[0]._refs
-            r = cls(fx,u=abs(du[0]),dof=args[0]._ref,utype=refs)
+            r = cls(fx,u=du[0],dof=args[0]._ref)
             return r
         
         maxdu = max(abs(a) for a in du)
         if maxdu == 0:
             return cls(fx)
-        dun = [d/maxdu for d in du]
+        try:
+            dun = [d/maxdu for d in du]
+        except TypeError:
+            dun = [xtype(d)/xtype(maxdu) for d in du]
         
         u = sum(d**2 for d in dun)
-        u += 2*sum(args[i].correlation(args[j])*dun[i]*dun[j] 
-                 for i in range(len(args)) for j in range(i+1,len(args)))
+        try:
+            u += 2*sum(sum(args[i]._ref[k]*v for k,v in args[j]._ref.items() 
+                           if k in args[i]._ref)*dun[i]*dun[j] 
+                       for i in range(len(args)) for j in range(i+1,len(args)))
+        except TypeError:
+            u += 2*sum(xtype(sum(args[i]._ref[k]*v for k,v in args[j]._ref.items() 
+                                 if k in args[i]._ref))*dun[i]*dun[j] 
+                       for i in range(len(args)) for j in range(i+1,len(args)))
         
         if not isnan(u):
             if u < 0:
                 if u < -1e6:
-                    # something horrible happened, should only get here due to a bug
+                    # something horrible and unexpected happened
                     raise FloatingPointError('u is sqrt of ' + str(maxdu**2*u))
                 u = 0
                 
-            u = u**0.5
+            if hasattr(u,'sqrt'):
+                u = u.sqrt()
+            else:
+                u = u**0.5
             u = maxdu*u
             
         if u == 0 or isnan(u):
             return cls(fx)
         
-        du = [d/u for d in du]
-        dof = float('inf')
-        if any(not isinf(a._dof) for a in args):
-            dm = sum(sum(args[i].correlation(args[j])*du[i]*du[j] 
-                         for i in range(len(du)))**2/args[j]._dof 
-                         for j in range(len(du)))
-            if dm > 0:
-                dof = 1/dm
-                
-        r = cls(fx,u=u,dof=dof)
-        
-        rl = {a._ref for a in args}
-        for i,a in enumerate(args):
-            s = sum(a.correlation(args[j])*du[j] for j in range(len(du)))
-            a._ref.combl(r,float(a._refs*s),float(a._refs*du[i]),rl)
-            if r._ref in rl:
-                break
-        r._check_cor()
+        try:
+            du = [float(d/u) for d in du]
+        except TypeError:
+            du = [float(xtype(d)/xtype(u)) for d in du]
+            
+        r = cls(fx,u=u,dof=_combrd(args,du))
             
         return r
         
@@ -752,35 +946,80 @@ class ummy(Dfunc,PrettyPrinter):
 
         return cls._apply(function,lambda *x: d,*args,fxdx=fxx)
     
-    def _check_cor(self):
-        if self._ref is None:
-            return
-        
-        rl = list(self._ref._cor.items())
-        for k,v in rl:
-            if k is not None:
-                if abs(v) > 1.01:
-                    raise ValueError('abs(correlation) > 1')
-                if abs(v) < _GummyRef._cortol:
-                    del k._cor[self._ref]
-                    del self._ref._cor[k]
-                    return
-                if v > _GummyRef._cortolp:
-                    k.copyto(self,1)
-                    return
-                if v < _GummyRef._cortoln:
-                    k.copyto(self,-1)
-                    return
-                
-    def _combc(self,a,b,dua,dub,c):
-        dua = float(dua)
-        dub = float(dub)
-
-        a._ref.combl(self,c*dub*a._refs + dua*a._refs,dua*a._refs)
-        if self._ref is not a._ref:
-            b._ref.combl(self,c*dua*b._refs + dub*b._refs,dub*b._refs,[a._ref])
-            if self._ref is not b._ref:
-                self._check_cor()   
+    def _aop(self,b,f,d1,d2):
+        # computes the result of a binary operation f(self,b).  d1 and d2 are 
+        # the derivatives with respect to self and b respectively.
+        
+        # correlation between self and b (/sign(self._u)*sign(b._u))
+        if not isinstance(b,ummy) or b._ref is None or self._ref is None:
+            c = 0
+        else:
+            c = sum(b._ref[k]*v for k,v in self._ref.items() if k in b._ref)
+            
+        x = f(self._x,b._x)
+        try:
+            dua = d1(self._x,b._x)*self._u
+            dub = d2(self._x,b._x)*b._u
+            u = _combu(dua,dub,c) # combined standard uncertainty
+        except TypeError:
+            # e.g. if self.x and b.x are Decimal we may need to convert the
+            # correlation c which is float to Decimal
+            xtype = _xtype(x)
+            dua = d1(self._x,b._x)*xtype(self._u)
+            dub = d2(self._x,b._x)*xtype(b._u)
+            u = _combu(dua,dub,xtype(c))
+            
+        # some special cases where we don't need to bother to work out all the
+        # correlations with the independent variables
+        if u == 0:
+            return type(b)(x)
+        
+        if self._u == 0:
+            return type(b)(x,u=u,dof=b._ref)
+        
+        if b._u == 0:
+            return type(b)(x,u=u,dof=self._ref)
+        
+        if self._ref is b._ref:
+            s = sign(dua + dub)
+            return type(b)(x,u=s*u,dof=self._ref)
+        
+        # not a special case, so combine the correlation dictionaries of self 
+        # and b
+        
+        dua = float(dua/u)
+        dub = float(dub/u)
+       
+        ref = _udict(((k,dua*v) for k,v in self._ref.items()))
+        for k,v in b._ref.items():
+            if k in ref:
+                ref[k] += v*dub
+            else:
+                ref[k] = v*dub
+            
+        # check that sum squared correlations add to 1 in case rounding errors
+        # have accumulated
+        n = sum([i**2 for i in ref.values()])
+        if abs(n-1) > ummy.correlation_tolerance:
+            n = sqrt(n)
+            for k,v in ref.items():
+                ref[k] /= n
+            
+        # round correlations to 1, -1 or 0 if within correlation_tolerance of 
+        # these values
+        for k,v in list(ref.items()):
+            c = ref[k]
+            if c < -1 + ummy.correlation_tolerance:
+                ref = _udict(((k,1),))
+                u = -u
+                break
+            elif c > 1 - ummy.correlation_tolerance:
+                ref = _udict(((k,1),))
+                break
+            elif abs(c) < ummy.correlation_tolerance:
+                del ref[k]
+        
+        return type(b)(x,u=u,dof=ref)
                 
     def __add__(self,b):
         if isinstance(b,np.ndarray):
@@ -792,33 +1031,12 @@ class ummy(Dfunc,PrettyPrinter):
             return immy(self) + b
         
         if not isinstance(b,ummy):
-            return type(self)(self._x + b,self._u,dof=self._ref,utype=self._refs)
-    
-        c = self.correlation(b)
-        x = self._x + b._x
-        u = _combu(self._u,b._u,c)
+            return type(self)(self._x + b,u=self._u,dof=self._ref)
         
-        if u == 0:
-            return type(b)(x)
-        
-        if self._u == 0:
-            return type(b)(x,u,dof=b._ref,utype=b._refs)
-        
-        if b._u == 0:
-            return type(b)(x,u,dof=self._ref,utype=self._refs)
-        
-        dua = self._u/u
-        dub = b._u/u
-        if not isinf(self._ref.dof) or not isinf(b._ref.dof):
-            dof = self._get_dof(self._dof,b._dof,dua,dub,c)
-        else:
-            dof = float('inf')
-            
-        r = type(b)(x,u=u,dof=dof)
-    
-        r._combc(self,b,dua,dub,c)
-        
-        return r
+        return self._aop(b,
+                         lambda x1,x2:x1 + x2,
+                         lambda x1,x2:1,
+                         lambda x1,x2:1)
     
     def __radd__(self,b):
         if isinstance(b,np.ndarray):
@@ -830,7 +1048,7 @@ class ummy(Dfunc,PrettyPrinter):
         if isinstance(b,ummy):
             return b.__add__(self)
         
-        return type(self)(self._x + b,self._u,dof=self._ref,utype=self._refs)
+        return type(self)(self._x + b,u=self._u,dof=self._ref)
     
     def __sub__(self,b):
         if isinstance(b,np.ndarray):
@@ -843,33 +1061,12 @@ class ummy(Dfunc,PrettyPrinter):
             return immy(self) - b
         
         if not isinstance(b,ummy):
-            return type(self)(self._x - b,self._u,dof=self._ref,utype=self._refs)
-            
-        c = self.correlation(b)
-        x = self._x - b._x
-        u = _combu(self._u,-b._u,c)
+            return type(self)(self._x - b,u=self._u,dof=self._ref)
             
-        if u == 0:
-            return type(b)(x)
-        
-        if self._u == 0:
-            return type(b)(x,u,dof=b._ref,utype=-b._refs)
-        
-        if b._u == 0:
-            return type(b)(x,u,dof=self._ref,utype=self._refs)
-        
-        dua = self._u/u
-        dub = -b._u/u
-        if not isinf(self._ref.dof) or not isinf(b._ref.dof):
-            dof = self._get_dof(self._dof,b._dof,dua,dub,c)
-        else:
-            dof = float('inf')
-        
-        r = type(b)(x,u=u,dof=dof)
-        
-        r._combc(self,b,dua,dub,c)
-
-        return r
+        return self._aop(b,
+                         lambda x1,x2:x1 - x2,
+                         lambda x1,x2:1,
+                         lambda x1,x2:-1)
     
     def __rsub__(self,b):
         if isinstance(b,np.ndarray):
@@ -881,7 +1078,7 @@ class ummy(Dfunc,PrettyPrinter):
         if isinstance(b,ummy):
             return b.__sub__(self)
         
-        r = type(self)(b - self._x,self._u,dof=self._ref,utype=-self._refs)
+        r = type(self)(b - self._x,u=-self._u,dof=self._ref)
         return r
     
     def __mul__(self,b):
@@ -895,38 +1092,20 @@ class ummy(Dfunc,PrettyPrinter):
             return immy(self)*b
         
         if not isinstance(b,ummy):
-            refs = -self._refs if b < 0 else self._refs
-            return type(self)(self._x*b,abs(self._u*b),dof=self._ref,utype=refs)
-                                        
-        c = self.correlation(b)
-        x = self._x*b._x
-        dua = b._x*self._u
-        dub = self._x*b._u
-        u = _combu(dua,dub,c)
-            
-        if u == 0:
-            return type(b)(x)
-        
-        if self._u == 0:
-            refs = -b._refs if self._x < 0 else b._refs
-            return type(b)(x,u,dof=b._ref,utype=refs)
-        
-        if b._u == 0:
-            refs = -self._refs if b._x < 0 else self._refs
-            return type(b)(x,u,dof=self._ref,utype=refs)
-        
-        dua = dua/u
-        dub = dub/u
-        if not isinf(self._ref.dof) or not isinf(b._ref.dof):
-            dof = self._get_dof(self._dof,b._dof,dua,dub,c)
-        else:
-            dof = float('inf')
-            
-        r = type(b)(x,u=u,dof=dof)
-        
-        r._combc(self,b,dua,dub,c)
-
-        return r
+            x = self._x*b
+            try:
+                ub = self._u*b
+            except TypeError:
+                if isinstance(x,Integral):
+                    ub = MFraction.fromnum(self._u)*b
+                else:
+                    ub = type(x)(self._u)*b
+            return type(self)(x,u=ub,dof=self._ref)
+              
+        return self._aop(b,
+                         lambda x1,x2:x1*x2,
+                         lambda x1,x2:x2,
+                         lambda x1,x2:x1)
     
     def __rmul__(self,b):
         if isinstance(b,np.ndarray):
@@ -938,8 +1117,12 @@ class ummy(Dfunc,PrettyPrinter):
         if isinstance(b,ummy):
             return b.__mul__(self)
         
-        refs = -self._refs if b < 0 else self._refs
-        return type(self)(self._x*b,abs(self._u*b),dof=self._ref,utype=refs)
+        x = self._x*b
+        try:
+            ub = self._u*b
+        except TypeError:
+            ub = _xtype(x)(self._u)*b
+        return type(self)(x,u=ub,dof=self._ref)
     
     def __truediv__(self,b):
         if isinstance(b,np.ndarray):
@@ -958,10 +1141,12 @@ class ummy(Dfunc,PrettyPrinter):
                 x = MFraction(self._x,b)
             else:
                 x = self._x/b
-            refs = -self._refs if b < 0 else self._refs
-            return type(self)(x,abs(self._u/b),dof=self._ref,utype=refs)
+            try:
+                ub = self._u/b
+            except TypeError:
+                ub = _xtype(x)(self._u)/b
+            return type(self)(x,ub,dof=self._ref)
                 
-        c = self.correlation(b)
         if b._x == 0:
             raise ZeroDivisionError('division by zero')
         else:
@@ -971,34 +1156,10 @@ class ummy(Dfunc,PrettyPrinter):
             else:
                 x = self._x/b._x
             
-        dua = self._u/b._x
-        dub = -(self._x*b._u/b._x)/b._x
-        
-        u = _combu(dua,dub,c)
-        
-        if u == 0:
-            return type(b)(x)
-        
-        if self._u == 0:
-            refs = b._refs if self._x < 0 else -b._refs
-            return type(b)(x,u,dof=b._ref,utype=refs)
-        
-        if b._u == 0:
-            refs = -self._refs if b._x < 0 else self._refs
-            return type(b)(x,u,dof=self._ref,utype=refs)
-        
-        dua = dua/u
-        dub = dub/u
-        if not isinf(self._ref.dof) or not isinf(b._ref.dof):
-            dof = self._get_dof(self._dof,b._dof,dua,dub,c)
-        else:
-            dof = float('inf')
-            
-        r = type(b)(x,u=u,dof=dof)
-        
-        r._combc(self,b,dua,dub,c)
-
-        return r
+        return self._aop(b,
+                         lambda x1,x2:x1/x2,
+                         lambda x1,x2:1/x2,
+                         lambda x1,x2:-x1/x2**2)
     
     def __rtruediv__(self,b):
         if isinstance(b,np.ndarray):
@@ -1018,9 +1179,11 @@ class ummy(Dfunc,PrettyPrinter):
                 x = MFraction(b,self._x)
             else:
                 x = b/self._x
-        u = abs(b*self._u/self._x**2)
-        refs = self._refs if b < 0 else -self._refs
-        return type(self)(x,u,dof=self._ref,utype=refs)
+        try:
+            ub = -b*self._u/self._x**2
+        except TypeError:
+            ub = -b*_xtype(x)(self._u)/self._x**2
+        return type(self)(x,ub,dof=self._ref)
     
     def __pow__(self,b):
         if isinstance(b,np.ndarray):
@@ -1042,57 +1205,30 @@ class ummy(Dfunc,PrettyPrinter):
                 x = MFraction(1,self._x**-b)
             else:
                 x = self._x**b
-            u = abs(b*self._x**(b-1)*self._u)
-            if self._x < 0:
-                sgn = int(-((-1)**b))
-            else:
-                sgn = 1
-            if b < 0:
-                sgn = -sgn
-            return type(self)(x,u,dof=self._ref,utype=sgn*self._refs)
+            try:
+                ub = b*self._x**(b-1)*self._u
+            except TypeError:
+                ub = b*self._x**(b-1)*_xtype(x)(self._u)
+            return type(self)(x,ub,dof=self._ref)
 
         if self._x <= 0:
             raise ValueError('a negative or zero value cannot raised to a power which has an uncertainty')            
                 
-        c = self.correlation(b)
         if (isinstance(self._x,Integral) and 
                 isinstance(b._x,Integral) and b._x < 0):
-            x = MFraction(1,self._x**-b._x)
+            f = lambda x1,x2:MFraction(1,x1**-x2)
         else:
-            x = self._x**b._x
-        dua = b._x*self._x**(b._x-1)*self._u
-        lgx = log(self._x)
-        
-        # don't exactly remember why I did this,
-        # but it causes problems if x is int.
-        #try:
-            #lgx = type(self._x)(lgx)
-        #except:
-            #pass
-            
-        dub = lgx*self._x**b._x*b._u
-        u = _combu(dua,dub,c)
-        
-        if u == 0:
-            return type(b)(x)
-        
-        if self._u == 0:
-            refs = -b._refs if self._x < 0 else b._refs
-            return type(b)(x,u,dof=b._ref,utype=refs)
+            f = lambda x1,x2:x1**x2
         
-        dua = dua/u
-        dub = dub/u
-        
-        if not isinf(self._ref.dof) or not isinf(b._ref.dof):
-            dof = self._get_dof(self._dof,b._dof,dua,dub,c)
+        if hasattr(self._x,'ln'):
+            lgx = self._x.ln()   
         else:
-            dof = float('inf')
+            lgx = log(self._x)
             
-        r = type(b)(x,u=u,dof=dof)
-        
-        r._combc(self,b,dua,dub,c)
-
-        return r
+        return self._aop(b,
+                         f,
+                         lambda x1,x2:x2*x1**(x2 - 1),
+                         lambda x1,x2:lgx*x1**x2)
     
     def __rpow__(self,b):
         if isinstance(b,np.ndarray):
@@ -1118,18 +1254,16 @@ class ummy(Dfunc,PrettyPrinter):
         if b < 0:
             raise ValueError('a negative number cannot raised to a power which has an uncertainty')
             
-        lgb = log(b)
-        
-        # don't exactly remember why I did this,
-        # but it causes problems if x is int.
-        #try:
-            #lgb = type(b)(lgb)
-        #except:
-            #pass
+        if hasattr(b,'ln'):
+            lgb = b.ln()
+        else:
+            lgb = log(b)
             
-        u = abs(b**self._x*lgb*self._u)
-        refs = -self._refs if b < 0 else self._refs
-        return type(self)(x,u,dof=self._ref,utype=refs)
+        try:
+            ub = b**self._x*lgb*self._u
+        except TypeError:
+            ub = b**self._x*lgb*_xtype(x)(self._u)
+        return type(self)(x,ub,dof=self._ref)
     
     def _nprnd(self,f):
         return type(self)(f(self._x))
@@ -1144,7 +1278,7 @@ class ummy(Dfunc,PrettyPrinter):
         if isinstance(b,Complex) and not isinstance(b,Real):
             return immy(self) // b
         
-        return self._truediv(b)._nprnd(_floor)
+        return self.__truediv__(b)._nprnd(floor)
         
     def __rfloordiv__(self,b):
         if isinstance(b,np.ndarray):
@@ -1156,7 +1290,7 @@ class ummy(Dfunc,PrettyPrinter):
         if isinstance(b,ummy):
             return b.__floordiv__(self)
         
-        return self._rtruediv(b)._nprnd(_floor)
+        return self.__rtruediv__(b)._nprnd(floor)
         
     def __mod__(self,b):
         if isinstance(b,np.ndarray):
@@ -1169,7 +1303,7 @@ class ummy(Dfunc,PrettyPrinter):
             return immy(self) % b
         
         ret = ummy._apply(lambda x1,x2: x1%x2,
-                          lambda x1,x2: (1, _sign(x2)*abs(x1//x2)),self,b)
+                          lambda x1,x2: (1,copysign(abs(x1//x2),x2)),self,b)
         return type(self)(ret)
         
     def __rmod__(self,b):
@@ -1180,14 +1314,20 @@ class ummy(Dfunc,PrettyPrinter):
             return b.__mod__(self)
         
         ret = ummy._apply(lambda x1,x2: x1%x2,
-                          lambda x1,x2: (1, _sign(x2)*abs(x1//x2)),b,self)
+                          lambda x1,x2: (1,copysign(abs(x1//x2),x2)),b,self)
         return type(self)(ret)
+    
+    def __divmod__(self,b):
+        return (self//b,self%b)
+    
+    def __rdivmod__(self,b):
+        return (b//self,b%self)
         
     def __neg__(self):
         r = self.copy(formatting=False)
         r._x = -self._x
         if self._ref is not None:
-            r._refs = -self._refs
+            r._u = -self._u
         return r
         
     def __pos__(self):
@@ -1198,7 +1338,7 @@ class ummy(Dfunc,PrettyPrinter):
         if self._x < 0:
             r._x = -self._x
             if self._ref is not None:
-                r._refs = -self._refs
+                r._u = -self._u
         return r
     
     def __eq__(self,v):
@@ -1208,7 +1348,7 @@ class ummy(Dfunc,PrettyPrinter):
         if isinstance(v,ummy):
             if self.u == 0 and v.u == 0:
                 return self._x == v._x
-            if self._ref is v._ref and self._refs == v._refs:
+            if self.correlation(v) == 1:
                 return self.x == v.x and self.u == v.u
             return False
         
@@ -1216,16 +1356,77 @@ class ummy(Dfunc,PrettyPrinter):
             return self.x == v
         
         return False
+    
+    def __ne__(self, v):
+        return not self == v
         
-    #def __float__(self):
-        #return float(self.x)
+    def __lt__(self, v):
+        if self.u != 0:
+            raise TypeError('an ummy with non-zero uncertainty cannot be ordered')
+        return self.x < v
+    
+    def __le__(self, v):
+       if self.u != 0:
+           raise TypeError('an ummy with non-zero uncertainty cannot be ordered')
+       return self.x <= v
         
-    #def __int__(self):
-        #return int(self.x)
+    def __gt__(self, v):
+        if self.u != 0:
+            raise TypeError('an ummy with non-zero uncertainty cannot be ordered')
+        return self.x > v
         
-    #def __complex__(self):
-        #return complex(self.x)
+    def __ge__(self, v):
+        if self.u != 0:
+            raise TypeError('an ummy with non-zero uncertainty cannot be ordered')
+        return self.x >= v
+        
+    def __float__(self):
+        if self.u != 0:
+            raise TypeError('an ummy with non-zero uncertainty cannot be converted to float')
+        return float(self.x)
+    
+    def __int__(self):
+        if self.u != 0:
+            raise TypeError('an ummy with non-zero uncertainty cannot be converted to int')
+        return int(self.x)
+        
+    def __complex__(self):
+        if self.u != 0:
+            raise TypeError('an ummy with non-zero uncertainty cannot be converted to complex')
+        return complex(self.x)
     
+    def __bool__(self):
+        return self != 0
+    
+    #def __trunc__(self):
+        #try:
+            #return self.x.__trunc__()
+        #except:
+            #return float(self.x).__trunc__()
+        
+    #def __floor__(self):
+        #try:
+            #return self.x.__floor__()
+        #except:
+            #return float(self.x).__floor__()
+        
+    #def __ceil__(self):
+        #try:
+            #return self.x.__ceil__()
+        #except:
+            #return float(self.x).__ceil__()
+        
+    #def __round__(self,ndigits=None):
+        #try:
+            #ret = round(self.x,ndigits)
+        #except:
+            #ret = round(float(self.x),ndigits)
+        
+        #if ndigits is None:
+            #return ret
+        #else:
+            #return type(self)(ret)
+        
     @property
     def real(self):
         return self
@@ -1243,46 +1444,48 @@ class ummy(Dfunc,PrettyPrinter):
         else:
             return type(self)(pi)
         
-    @property
-    def utype(self):
-        """
-        `str` or `None`
-
-        An arbitrary string value labeling the uncertainty type.
-        """
-        if self._ref is None or self._ref._tag is None:
-            return None
-        return self._ref._tag.name
+    def __hash__(self):
+        if self._ref is None:
+            return hash(self.x)
+        s = sign(self._u)
+        return hash((tuple((k,s*v) for k,v in self._ref.items()),self.x,self.u))
+    
+    def _ufromrefs(self,x):
+        if self._ref is None:
+            return dict()
         
-    @staticmethod
-    def _toummylist(x):
-        if isinstance(x,ummy):
-           return [x]
-        elif isinstance(x,GummyTag):
-            return x.get_values()
-        elif isinstance(x,str):
-            t = GummyTag.tags.get(x)
-            if t is None:
-                return []
-            x = t.get_values()
-            return x
-        elif hasattr(x,'value') and isinstance(x.value,ummy):
-            return [x.value]
-        
-        xl = []
-        for e in x:
-            if hasattr(e,'value') and isinstance(e.value,ummy):
-                xl.append(e.value)
-            elif isinstance(e,ummy):
-                xl.append(e)
-            elif isinstance(e,GummyTag):
-                xl += e.get_values()
-            elif isinstance(e,str):
-                t = GummyTag.tags.get(e)
-                if t is not None:
-                    xl += t.get_values()
-        return xl
+        if isinstance(x,ummy) or isinstance(x,str) or isinstance(x,Quantity):
+            x = [x]
         
+        x = [i.value if isinstance(i,Quantity) else i for i in x]
+            
+        d = dict()
+        for g in x:
+            if isinstance(g,str):
+                for k in self._ref:
+                    if k.utype == g:
+                        if k in d:
+                            d[k] += 1
+                        else:
+                            d[k] = 1
+            elif isinstance(g,ummy):
+                for k,v in g._ref.items():
+                    if k in d:
+                        d[k] += v**2
+                    else:
+                        d[k] = v**2
+                    
+        for k,v in list(d.items()):
+            if k in self._ref and v > 0:
+                if v > 1:
+                    d[k] = self._ref[k]**2
+                else:
+                    d[k] *= self._ref[k]**2
+            else:
+                del d[k]
+                    
+        return d
+            
         
     def ufrom(self,x):
         """
@@ -1308,29 +1511,31 @@ class ummy(Dfunc,PrettyPrinter):
         >>>  d.ufrom('A')
         0.53851648071345048
         """
-        x = ummy._toummylist(x)
-        x = [i for i in x if self.correlation(i) != 0]
-        if len(x) == 0:
-            return 0
+       
+        #x = ummy._toummylist(x)
+        #x = [i for i in x if self.correlation(i) != 0]
+        #if len(x) == 0:
+            #return 0
 
-        v = ummy.correlation_matrix(x)
+        #v = ummy.correlation_matrix(x)
             
-        b = [self.correlation(z) for z in x]
-        s = np.linalg.lstsq(v,b,rcond=None)[0]
-        u = 0
-        
-        d = [i*self.u/j.u for i,j in zip(s,x)]
-        for i in range(len(x)):
-            for j in range(len(x)):
-                u += d[i]*d[j]*x[i].correlation(x[j])*x[i].u*x[j].u
+        #b = [self.correlation(z) for z in x]
+        #s = np.linalg.lstsq(v,b,rcond=None)[0]
+        #u = 0
+        
+        #d = [i*self.u/j.u for i,j in zip(s,x)]
+        #for i in range(len(x)):
+            #for j in range(len(x)):
+                #u += d[i]*d[j]*x[i].correlation(x[j])*x[i].u*x[j].u
                 
-        return u**0.5
+        #return u**0.5
+        
+        return float(self.u*np.sqrt(sum(v for v in self._ufromrefs(x).values())))
         
     def doffrom(self,x):
         """
         Gets the degrees of freedom contributed from particular ummys or
-        utypes if all other free variables are held fixed.  Caution:  any
-        correlations in the calculations can cause errors in dof calculations.
+        utypes if all other free variables are held fixed.
         
         Parameters
         ----------
@@ -1351,193 +1556,43 @@ class ummy(Dfunc,PrettyPrinter):
         >>>  d.doffrom('A')
         9.0932962619709627
         """
-        x = ummy._toummylist(x)
-        x = [i for i in x if self.correlation(i) != 0]
-        if len(x) == 0:
-            return float('inf')
+        #x = ummy._toummylist(x)
+        #x = [i for i in x if self.correlation(i) != 0]
+        #if len(x) == 0:
+            #return float('inf')
             
-        v = ummy.correlation_matrix(x)
-        b = [self.correlation(z) for z in x]
-        s = np.linalg.lstsq(v,b,rcond=None)[0]
-        d = [i*self.u/j.u for i,j in zip(s,x)]
-        usq = 0
-        dm = 0
-        for i in range(len(x)):
-            for j in range(len(x)):
-                usqi = d[i]*d[j]*x[i].correlation(x[j])*x[i].u*x[j].u
-                usq += usqi
-                dm += usqi**2/x[i].dof
+        #v = ummy.correlation_matrix(x)
+        #b = [self.correlation(z) for z in x]
+        #s = np.linalg.lstsq(v,b,rcond=None)[0]
+        #d = [i*self.u/j.u for i,j in zip(s,x)]
+        #usq = 0
+        #dm = 0
+        #for i in range(len(x)):
+            #for j in range(len(x)):
+                #usqi = d[i]*d[j]*x[i].correlation(x[j])*x[i].u*x[j].u
+                #usq += usqi
+                #dm += usqi**2/x[i].dof
                 
-        if dm == 0:
+        #if dm == 0:
+           # return float('inf')
+        #dof = usq**2/dm
+        #if dof > ummy.max_dof:
+            #return float('inf')
+        #if dof < 1:
+            #return 1
+        #return dof
+        
+        dof = sum(v**2/k.dof for k,v in self._ufromrefs(x).items() if k.dof is not None)
+        if dof > 0:
+            dof = sum(v for v in self._ufromrefs(x).values())**2/dof
+        else:
             return float('inf')
-        dof = usq**2/dm
         if dof > ummy.max_dof:
             return float('inf')
         if dof < 1:
             return 1
-        return dof
-        
-        
-class _GummyRef:
-    # Instances of this class are hashable unlike gummys, so we can use this in 
-    # a gummy's ._cor weak key dictionary and a GummyTag's .values weak set.
-
-    _cortol = 1e-15 # correlations smaller than this are rounded to zero
-    _cortolp = 1 - 1e-15 # correlations larger than this are rounded to 1
-    _cortoln = -1 + 1e-15 # correlations smaller than this are rounded to -1
-    
-    def __init__(self,dof=float('inf')):
-        self._cor = weakref.WeakKeyDictionary()
-        self._tag = None
-        self._tag_refs = []
-        self._tag_deps = []
-        self.dof = dof
-        
-    def cor(self,ref):
-        if ref is self:
-            return 1
-        c = self._cor.get(ref)
-        if c is None:
-            return 0
-        else:
-            return c
-            
-    def set_cor(self,g,c):
-        # We allow input values slighly greater than 1 without raising an 
-        # exception to give room for rounding errors (but values greater than
-        # 1 will be rounded to 1 below).
-        
-        if abs(c) > 1.01:
-            raise ValueError('abs(c) > 1')
-            
-        if abs(c) < _GummyRef._cortol:
-            if g._ref in self._cor:
-                del self._cor[g._ref]
-                del g._ref._cor[self]
-            return
-        
-        if c > _GummyRef._cortolp:
-            self.copyto(g,1)
-            return
-            
-        if c < _GummyRef._cortoln:
-            self.copyto(g,-1)
-            return
-        
-        # We can't let an ummy with a utype die and be collected with the garbage
-        # if it is correlated with a living ummy in case ufrom() or doffrom() is 
-        # called with the utype as an argument.  So we add a strong reference 
-        # pointing to the utyped ummy to the GummyRef of all other ummys that 
-        # are correlated with it.
-        if self._tag is not None:
-            g._ref._tag_deps.append(self.get_tag_ref())
-        elif len(self._tag_deps) > 0:
-            g._ref._tag_deps += self._tag_deps
-        
-        self._cor[g._ref] = c
-        g._ref._cor[self] = c
-            
-    def add_cor(self,g,c):
-        if c == 0:
-            return
-        v = self._cor.get(g._ref)
-        if v is None:
-            v = c
-        else:
-            v += c
-        self._cor[g._ref] = v
-        g._ref._cor[self] = v
-        
-    @staticmethod
-    def check_cor(r):
-        a = list(r._ref._cor.items())
-        for k,v in a:
-            if k is not None:
-                if abs(v) > 1.01:
-                    raise ValueError('abs(correlation) > 1')
-                if abs(v) < _GummyRef._cortol:
-                    del k._cor[r._ref]
-                    del r._ref._cor[k]
-                    return
-                if v > _GummyRef._cortolp:
-                    k.copyto(r,1)
-                    return
-                if v < _GummyRef._cortoln:
-                    k.copyto(r,-1)
-                    return
-                
-    def copyto(self,g,refs=1):
-        g._ref = self
-        g._refs = refs
-        if self._tag is not None:
-            self._tag_refs.append(weakref.ref(g))
-            
-    def combl(self,g,c1,c2,rl=None):
-        self.set_cor(g,c1)
-        if g._ref is not self:
-            a = list(self._cor.items())
-            for k,v in a:
-                if k is not None and k is not g._ref:
-                    if rl is None or not any(i is k for i in rl):
-                        k.add_cor(g,c2*v)
-                        
-    def get_tag_ref(self):
-        try:
-            ret = self._tag_refs[-1]()
-            while ret is None:
-                # The GummyRef may be shared by several copys of the original
-                # ummy.  Find one that is still alive.
-                self._tag_refs.pop()
-                ret = self._tag_refs[-1]()
-            return ret
-        except IndexError:
-            return None
-            
-
-class GummyTag:
-    # Do not create GummyTag objects directly.  A GummyTag instance is created
-    # each time a gummy instance with a new and unique utype parameter is created.
-
-    tags = weakref.WeakValueDictionary()
-        
-    @staticmethod
-    def set_tag(g,tag):
-        if isinstance(tag,str):
-            tag = tag.strip()
-            if tag in GummyTag.tags:
-                tag = GummyTag.tags[tag]
-            else:
-                tag = GummyTag(tag)
-
-        elif not isinstance(tag,GummyTag):
-            raise ValueError('utype must be either None or a str')
-            
-        tag.values.add(g._ref)
-        g._ref._tag = tag
-        g._ref._tag_refs.append(weakref.ref(g))
-        
-    def __init__(self,tag_name):
-        GummyTag.tags[tag_name] = self
-        
-        self.values = weakref.WeakSet()
-        
-        self.name = tag_name
-        
-    def get_values(self):
-        vals = list(self.values)
-
-        # Can't put this in a list comprehension since v.ref is a weakref and
-        # it could die in the middle of the loop.
-        ret = []
-        for v in vals:
-            if v is not None:
-                r = v.get_tag_ref()
-                if r is not None:
-                    ret.append(r)
-                
-        return ret
+        return float(dof)
     
-                        
 def _der(function,*args):
     # computes the numerical derivative of function with respect to args.
     # puts zeros for any of args that are not an ummy
@@ -1576,7 +1631,7 @@ def _der(function,*args):
             v[i] = a
     d = np.zeros(n)
     for i,p in enumerate(args):
-        if isinstance(p,ummy) and p._u > 0:          
+        if isinstance(p,ummy) and p._u != 0:          
             df = None
             s = 2*p.u
             x1 = np.array(v)
@@ -1607,7 +1662,7 @@ def _der(function,*args):
     return d
 
 
-class MetaImmy(MetaPrettyPrinter):
+class MetaImmy(MetaPrettyPrinter,ABCMeta):
     @property
     def style(cls):
         """
@@ -1640,7 +1695,7 @@ class MetaImmy(MetaPrettyPrinter):
     def imag_symbol(cls,value):
         immy._imag_symbol = str(value)
     
-class immy(PrettyPrinter,Dfunc,metaclass=MetaImmy):
+class immy(PrettyPrinter,Dfunc,Number,metaclass=MetaImmy):
     
     _style = 'cartesian'
     _imag_symbol = 'j'
@@ -1774,20 +1829,20 @@ class immy(PrettyPrinter,Dfunc,metaclass=MetaImmy):
     def r(self):
         """
         read-only
-        Returns the magnitude of the value.
+        Returns the magnitude of the value (`abs(self)`).
         """
         if self._r is None:
-            self._r = abs(self)
+            self._r = (self.real**2 + self.imag**2)**0.5
         return self._r
     
     @property
     def phi(self):
         """
         read-only
-        Returns the polar angle of the value.
+        Returns the polar angle of the value (`self.angle()`)
         """
         if self._phi is None:
-            self._phi = self.angle()
+            self._phi = np.arctan2(self.imag,self.real)
         return self._phi
     
     def conjugate(self):
@@ -1798,11 +1853,12 @@ class immy(PrettyPrinter,Dfunc,metaclass=MetaImmy):
     
     def angle(self):
         """
-        Returns the polar angle in radians.
+        Returns the polar angle in radians (which is also the phi read-only 
+        property value).
         """
-        return np.arctan2(self.imag,self.real)
+        return self.phi
     
-    def copy(self,formatting=True,tofloat=False):
+    def copy(self,formatting=True,totype=None):
         """
         Returns a copy of the jummy.  If the `formatting` parameter is
         `True` the display formatting information will be copied and if
@@ -1812,12 +1868,13 @@ class immy(PrettyPrinter,Dfunc,metaclass=MetaImmy):
         imaginary components will be converted to floats.
         """
         if self._ridef:
-            r = self.real.copy(formatting=formatting,tofloat=tofloat)
-            i = self.imag.copy(formatting=formatting,tofloat=tofloat)
+            r = self.real.copy(formatting=formatting,totype=totype)
+            i = self.imag.copy(formatting=formatting,totype=totype)
             return type(self)(real=r,imag=i)
+        
         else:
-            r = self.r.copy(formatting=formatting,tofloat=tofloat)
-            phi = self.phi.copy(formatting=formatting,tofloat=tofloat)
+            r = self.r.copy(formatting=formatting,totype=totype)
+            phi = self.phi.copy(formatting=formatting,totype=totype)
             return type(self)(r=r,phi=phi)
     
     def tofloat(self):
@@ -1825,7 +1882,7 @@ class immy(PrettyPrinter,Dfunc,metaclass=MetaImmy):
         Returns a copy of the gummy with x an u (for both the real and
         imaginary components) converted to floats.
         """
-        return self.copy(formatting=False,tofloat=True)
+        return self.copy(formatting=False,totype=float)
     
     def splonk(self):
         if self.real.u == 0 and self.imag.u == 0:
@@ -2135,7 +2192,7 @@ class immy(PrettyPrinter,Dfunc,metaclass=MetaImmy):
         raise TypeError("can't mod immy")
     
     def __abs__(self):
-        return (self.real**2 + self.imag**2)**0.5
+        return self.r
     
     def __neg__(self):
         return type(self)(real=-self.real.copy(formatting=False),
@@ -2145,85 +2202,20 @@ class immy(PrettyPrinter,Dfunc,metaclass=MetaImmy):
         return type(self)(real=self.real.copy(formatting=False),
                           imag=self.imag.copy(formatting=False))
     
-    #def __complex__(self):
-        #return complex(self.real.x,self.imag.x)
-    
-    #def __float__(self):
-        #raise TypeError("can't convert immy to float")
-        
-    #def __int__(self):
-        #raise TypeError("can't convert immy to int")
-        
     def __eq__(self,v):
         return self.real == v.real and self.imag == v.imag
-
-        
-class MFraction(Fraction):
-    """
-    A fraction.Fraction sub-class that works with mpmath.mpf objects
-    """
-    
-    def __new__(cls, *args, **kwargs):
-        if len(args) == 1 and not (isinstance(args[0],str) 
-                                   or isinstance(args[0],Fraction)):
-            return args[0]
-        ret = super(MFraction, cls).__new__(cls, *args, **kwargs)
-        if ret.denominator == 1:
-            return ret.numerator
-        return ret
     
-    def _mpmath_(self,p,r):
-        return rational.mpq(self.numerator,self.denominator)
+    def __hash__(self):
+        return hash((self.real,self.imag))
     
-    def __add__(self,v):
-        return MFraction(super().__add__(v))
+    def __complex__(self):
+        return complex(float(self.real),float(self.imag))
     
-    def __radd__(self,v):
-        return MFraction(super().__radd__(v))
-    
-    def __sub__(self,v):
-        return MFraction(super().__sub__(v))
-    
-    def __rsub__(self,v):
-        return MFraction(super().__rsub__(v))
-    
-    def __mul__(self,v):
-        return MFraction(super().__mul__(v))
+    def __bool__(self):
+        return self != 0
     
-    def __rmul__(self,v):
-        return MFraction(super().__rmul__(v))
-    
-    def __truediv__(self,v):
-        return MFraction(super().__truediv__(v))
-    
-    def __rtruediv__(self,v):
-        return MFraction(super().__rtruediv__(v))
-        
-    def __pow__(self,v):
-        return MFraction(super().__pow__(v))
-    
-    def __rpow__(self,v):
-        if isinstance(v,Fraction):
-            return MFraction(v).__pow__(self)
-        return MFraction(super().__rpow__(v))
-        
-    def __floordiv__(self,v):
-        return MFraction(super().__floordiv__(v))
-        
-    def __rfloordiv__(self,v):
-        return MFraction(super().__rfloordiv__(v))
+    #def __float__(self):
+        #raise TypeError("can't convert immy to float")
         
-    def __mod__(self,v):
-        return MFraction(super().__mod__(v))
-    
-    def __rmod__(self,v):
-        return MFraction(super().__rmod__(v))
-    
-    def __abs__(self):
-        return MFraction(super().__abs__())
-    
-    def __neg__(self):
-        return MFraction(super().__neg__())
-    
-    def __pos__(self):
-        return MFraction(super().__pos__())
+    #def __int__(self):
+        #raise TypeError("can't convert immy to int")