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

metrolopy/nummy.py

@@ -27,11 +27,12 @@ class is not intended to be used directly; rather it is utilized by the gummy
 class.
 """
 import numpy as np
-from .ummy import ummy
+from .ummy import ummy,_udict,_isscalar
 from .distributions import (Distribution,TDist,NormalDist,MultivariateElement,
-                            MultivariateDistribution,MultiNormalDist,MultiTDist)
+                            MultivariateDistribution,Convolution)
 from .exceptions import NoSimulatedDataError
-from math import isinf,isfinite,isnan,sqrt
+from math import isinf,isnan,sqrt
+from html import escape
 
 def _bop(f,npf,s,b):    
     if isinstance(b,nummy):
@@ -50,6 +51,59 @@ def _uop(f,npf,s):
     f._dist = Distribution.apply(npf,s._dist)
     return f
 
+def _getnrefs(x,fr):
+    if isinstance(x,ummy):
+        x = [x]
+    ret = set()
+    for i in x:
+        for r in x._getrefs(fr):
+            if r.dist is not None:
+                ret.add(r.dist)
+    return ret
+
+def get_name(name,fmt,norm):
+    fmt = fmt.strip().lower()
+    if fmt not in {'unicode','html','latex','ascii'}:
+        raise ValueError('fmt "' + str(fmt) + '" is not recognized')
+        
+    if name is None:
+        return None
+    
+    if isinstance(name,str):
+        name = name.strip()
+        if fmt == 'html':
+            name = escape(name)
+            if len(name) == 1:
+                name = '<i>' + name + '</i>'
+        elif fmt == 'latex':
+            sc = {
+                '&': r'\&',
+                '%': r'\%',
+                '$': r'\$',
+                '#': r'\#',
+                '_': r'\_',
+                '{': r'\{',
+                '}': r'\}',
+                '~': r'\_',
+                '^': r'\_',
+                '\\': r'\_'
+                }
+            name = ''.join(sc[c] if c in sc else c for c in name)
+            if len(name) > 1:
+                name = norm(name)
+        elif fmt == 'ascii':
+            name = ''.join(i if ord(i) < 128 else '_' for i in name)
+        return name
+    
+    if fmt == 'unicode':
+        return name[0]
+    if fmt == 'html':
+        return name[1]
+    if fmt == 'latex':
+        return name[2]
+    if fmt == 'ascii':
+        return name[3]
+
     
 class nummy(ummy):
     #  This class is not intended to be used directly and was created to contain
@@ -75,37 +129,42 @@ class nummy(ummy):
             if isinstance(x,MultivariateElement):
                 raise TypeError('a MultivariateElement may not be used in a gummy initializer\nuse the create static method with a MultivariateDistribution')
             
+            if utype is None:
+                utype = x.utype
+            else:
+                x.utype = utype
             self._dist = x
             
             if hasattr(x,'dof'):
+                ndof = x.dof
                 if nummy._bayesian:
                     u = float(x.u())*np.sqrt(x.dof/(x.dof-2))
-                    dof = float('inf')
                 else:
                     u = float(x.u())
-                    dof = x.dof
             else:
-                dof = float('inf')
+                ndof = float('inf')
                 u = float(x.u())
                 
-            super().__init__(x.x(),u=u,dof=dof,utype=utype)
+            super().__init__(x.x(),u=u,dof=ndof,utype=utype)
             
         else:
             super().__init__(x,u=u,dof=dof,utype=utype)
             x = float(x)
-            u = float(self._u)
-            if self._u == 0 or isnan(x) or isinf(x) or isnan(u):
+            u = float(self.u)
+            if u == 0 or isnan(x) or isinf(x) or isnan(u) or isinf(u):
                 self._dist = x
                 return
-            dof = self._dof
-            if isinf(dof):
-                self._dist = NormalDist(x,u)
+            if isinstance(dof,_udict):
+                self._dist = None
             else:
-                if nummy._bayesian:
-                    self._dist = TDist(x,u*np.sqrt((dof-2)/dof),dof)
-                    self._dof = float('inf')
+                if dof is None or dof > self.max_dof:
+                    self._dist = NormalDist(x,u)
                 else:
-                    self._dist = TDist(x,u,dof)
+                    if nummy._bayesian:
+                        self._dist = TDist(x,u*np.sqrt((dof-2)/dof),dof)
+                    else:
+                        self._dist = TDist(x,u,dof)
+                self._dist.utype = utype
             
     @property
     def distribution(self):
@@ -116,31 +175,6 @@ class nummy(ummy):
         """
         return self._dist
     
-    @property
-    def dof(self):
-        """
-        float, read-only
-
-        Returns the number or degrees of freedom that the uncertainty of the 
-        gummy is based on.  If `gummy.bayesian` is set to `False`, then the Welch-
-        Satterthwaite approximation is used to calculate the effective number
-        of degrees of freedom for gummys that result from an operation between
-        two or more other gummys.  A version of the Welch-Satterthwaite 
-        approximation that takes into account correlations is used here, see
-        [R. Willink, Metrologia, 44, 340 (2007)].  If `gummy.bayesian` is `True`
-        then gummys that are the result from an opertaion between other gummys
-        will always have dof = float('inf').
-        """
-        if isinf(self._dof) and hasattr(self._dist,'dof'):
-            dof = self._dist.dof
-        else:
-            dof = self._dof
-        if dof < 1:
-            # Occasionally correlations can result in a dof less than 1;
-            # see the ummy._get_dof method.
-            return 1
-        return dof
-    
     @property
     def name(self):
         if self._name is None:
@@ -170,31 +204,9 @@ class nummy(ummy):
             raise ValueError('the name must be a string or a length 4 tuple of str')
             
     def get_name(self,fmt='unicode',norm=None):
-        fmt = fmt.strip().lower()
-        if fmt not in {'unicode','html','latex','ascii'}:
-            raise ValueError('fmt "' + str(fmt) + '" is not recognized')
-            
-        if self._name is None:
-            return None
-        
-        if isinstance(self._name,str):
-            name = str(self._name).strip()
-            if fmt == 'html' and len(name) == 1:
-                return '<i>' + name + '</i>'
-            if fmt == 'latex' and len(name) > 1:
-                if norm is None:
-                    norm = type(self).latex_norm
-                return norm(self.name)
-            return self._name
-        
-        if fmt == 'unicode':
-            return self._name[0]
-        if fmt == 'html':
-            return self._name[1]
-        if fmt == 'latex':
-            return self._name[2]
-        if fmt == 'ascii':
-            return self._name[3]
+        if norm is None:
+            norm = type(self).latex_norm
+        return get_name(self._name,fmt,norm)
     
     @property
     def bayesian(self):
@@ -240,12 +252,21 @@ class nummy(ummy):
     @staticmethod
     def simulate(nummys,n=100000,ufrom=None):
         if ufrom is not None:
-            ufrom = [g._dist for g in ufrom]
+            if isinstance(ufrom,(nummy,str,Distribution)):
+                ufrom = [ufrom]
+            ufrom = [g.distribution if isinstance(g,nummy) else g for g in ufrom]
         if isinstance(nummys,nummy):
             nummys = [nummys]
-        Distribution.simulate([g.distribution for g in nummys],n,ufrom)
+        Distribution.simulate([g.distribution for g in nummys if isinstance(g,nummy)],n=n,ufrom=ufrom)
         nummy._nsim = n
         
+    def sim(self,n=100000,ufrom=None):
+        return nummy.simulate([self],n=n,ufrom=ufrom)
+    
+    def clear(self):
+        if isinstance(self._dist,Distribution):
+            self._dist.clear()
+        
     @property
     def simdata(self):
         """
@@ -320,7 +341,7 @@ class nummy(ummy):
         return 0.5*(self.Usim[0] + self.Usim[1])/self.usim
         
     @property
-    def independent(self):
+    def isindependent(self):
         """
         `bool`, read-only
 
@@ -384,7 +405,7 @@ class nummy(ummy):
         """
         returns an ummy representaion of the nummy
         """
-        r = ummy(self.x,u=self.u,dof=self.dof)
+        r = ummy(self.x,u=self.u)
         r._ref = self._ref
         r._refs = self._refs
         return r
@@ -397,9 +418,9 @@ class nummy(ummy):
     
         
     @staticmethod
-    def _copy(s,r,formatting=True,tofloat=False):
+    def _copy(s,r,formatting=True,totype=None):
         # copies attributes of s to r, called from ummy.copy()
-        super(nummy,nummy)._copy(s,r,formatting=formatting,tofloat=tofloat)
+        super(nummy,nummy)._copy(s,r,formatting=formatting,totype=totype)
         if isinstance(s,nummy):
             r._dist = s._dist
             if formatting:
@@ -409,18 +430,18 @@ class nummy(ummy):
                 r.name = None
         else:
             r.name = None
-            if s._u == 0:
-                r._dist = r._x
+            if s.u == 0:
+                r._dist = r.x
                 return
-            dof = s._dof
+            dof = s.dof
             if isinf(dof):
-                r._dist = NormalDist(s._x,s._u)
+                r._dist = NormalDist(s.x,s.u)
             else:
                 if r._bayesian:
-                    r._dist = TDist(s._x,s._u*np.sqrt((dof-2)/dof),dof)
-                    r._dof = float('inf')
+                    r._dist = TDist(s.x,s.u*np.sqrt((dof-2)/dof),dof)
+                    r.dof = float('inf')
                 else:
-                    r._dist = TDist(s._x,s._u,dof)
+                    r._dist = TDist(s.x,s.u,dof)
         
     @classmethod
     def _apply(cls,function,derivative,*args,fxdx=None):
@@ -452,34 +473,11 @@ class nummy(ummy):
             r._dist = Distribution.apply(function,*a)
         return r
         
-    @staticmethod
-    def _set_correlation_matrix(gummys, matrix):
-        super(nummy,nummy)._set_correlation_matrix(gummys,matrix)
-        cov = nummy.covariance_matrix(gummys)
-        mean = [g.x for g in gummys]
-        if isfinite(gummys[0].dof) and all([g.dof==gummys[0].dof for g in gummys]):
-            mvdist = MultiTDist(mean,cov,gummys[0].dof)
-        else:
-            mvdist = MultiNormalDist(mean,cov)
-        for i,g in enumerate(gummys):
-            g._dist = mvdist[i]
-            
-    @staticmethod
-    def _set_covariance_matrix(gummys, matrix):
-        super(nummy,nummy)._set_covariance_matrix(gummys,matrix)
-        mean = [g.x for g in gummys]
-        if isfinite(gummys[0].dof) and all([g.dof==gummys[0].dof for g in gummys]):
-            mvdist = MultiTDist(mean,matrix,gummys[0].dof)
-        else:
-            mvdist = MultiNormalDist(mean,matrix)
-        for i,g in enumerate(gummys):
-            g._dist = mvdist[i]
-        
     @classmethod
-    def create(cls,x,u=0,dof=float('inf'),name=None,correlation_matrix=None,
-               covariance_matrix=None):
-        if name is None:
-            name = [None]*len(x)
+    def create(cls,x,u=0,dof=float('inf'),name=None,utype=None,
+               correlation_matrix=None,covariance_matrix=None):
+        if _isscalar(name):
+            name = [name]*len(x)
                    
         if isinstance(x,MultivariateDistribution):
 
@@ -497,9 +495,10 @@ class nummy(ummy):
                 else:
                     dof = x.dof
             else:
-                dof = [float('inf')]*nd
+                dof = float('inf')
             
-            ret = super(nummy,cls).create(x.x(),u=u,dof=dof,covariance_matrix=x.cov)
+            ret = super(nummy,cls).create(x.x(),u=u,dof=dof,utype=utype,
+                                          covariance_matrix=x.cov)
                    
             for i,r in enumerate(ret):
                 r._dist = x[i]
@@ -513,6 +512,11 @@ class nummy(ummy):
             
         if dof is None:
             dof = [float('inf')]*len(x)
+        elif _isscalar(dof):
+            dof = [dof]*len(x)
+        else:
+            dof = [float('inf') if i is None else i for i in dof]
+            
         if u is None:
             u = [0]*len(x)
         d = [None]*len(x)
@@ -527,7 +531,9 @@ class nummy(ummy):
                         u[i] = u[i]*np.sqrt(v.dof/(v.dof-2))
                         dof[i] = float('inf')
             
-        ret = super(nummy,cls).create(x,u,dof,correlation_matrix,covariance_matrix)
+        ret = super(nummy,cls).create(x,u=u,dof=dof,utype=utype,
+                                      correlation_matrix=correlation_matrix,
+                                      covariance_matrix=covariance_matrix)
         for i,r in enumerate(ret):
             r.name = name[i]
             if d[i] is None:
@@ -538,7 +544,6 @@ class nummy(ummy):
                 else:
                     if nummy._bayesian:
                         r._dist = TDist(x,u[i]*np.sqrt((dof[i]-2)/dof[i]),dof[i])
-                        r._dof = float('inf')
                     else:
                         r._dist = TDist(x,u[i],dof[i])
             else:
@@ -546,12 +551,10 @@ class nummy(ummy):
                     
         return ret
 
-    def hist(self,xlabel=None,title=None,hold=False,**kwds):
-        if xlabel is None and self.name is not None:
-            xlabel = str(self.name)
-            if len(xlabel) == 1:
-                xlabel = '$ ' + xlabel + ' $'
-        self.distribution.hist(xlabel=xlabel,title=title,hold=hold,**kwds)
+    def hist(self,**kwds):
+        if not isinstance(self._dist,Distribution):
+            raise TypeError('hist may not be called from a constant nummy')
+        self.distribution.hist(**kwds)
         
     def covariance_sim(self,g):
         """
@@ -561,8 +564,6 @@ class nummy(ummy):
         See the method `gummy.covariance(g)` for the corresponding result based
         on first order error propagation.
         """
-        #if self._u == 0 or g._u == 0:
-            #return 0
         return self._dist.covsim(g._dist)
         
     def correlation_sim(self,g):
@@ -573,8 +574,6 @@ class nummy(ummy):
         See the method `gummy.correlation(g)` for the corresponding result based
         on first order error propagation.
         """
-        #if self._u == 0 or g._u == 0:
-            #return 0
         return self.covariance_sim(g)/(self.usim*g.usim)
         
     @staticmethod
@@ -607,59 +606,110 @@ class nummy(ummy):
     @staticmethod
     def covplot(x,y,title=None,xlabel=None,ylabel=None,hold=False,**kwds):
         if xlabel is None and x.name is not None:
-            xlabel = str(x.name)
-            if len(xlabel) == 1:
-                xlabel = '$ ' + xlabel + ' $'
+            xlabel = x.get_name(fmt='latex')
         if ylabel is None and y.name is not None:
-            ylabel = str(y.name)
-            if len(ylabel) == 1:
-                ylabel = '$ ' + ylabel + ' $'
+            ylabel = y.get_name(fmt='latex')
 
         Distribution.covplot(x.distribution,y.distribution,xlabel=xlabel,ylabel=ylabel,
                              title=title,hold=hold,**kwds)
         
-    def ufrom(self,x,sim=False):
-        """
-        Gets the standard uncertainty contributed from particular gummys
-        or utypes if all other free variables are held fixed.
+    #def ufrom(self,x,sim=False):
 
+        #if not sim:
+            #return super().ufrom(x)
+            
+        #v = nummy.correlation_matrix_sim(x)
+            
+        #b = [self.correlation(z) for z in x]
+        #s = np.linalg.lstsq(v,b,rcond=-1)[0]
+        #u = 0
+        
+        #d = [i*self.usim/j.usim 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].usim*x[j].usim
+                
+        #return sqrt(u)
+    
+    def ufromsim(self,x):
+        """
+        Gets the standard deviation of the Monte-Carlo data only allowing the
+        independent variables in `x` to vary.  Independent istributions not in 
+        `x` are held fixed.  `sim` or `simulate` must be called to generate
+        Monte-Carlo data before calling this method.
+        
         Parameters
-        ---------_
-        x:  `gummy`, `str`, or array_like
-            A gummy, a string referencing a utype or a list containing
-            gummys and strings.
-
+        ----------
+        x:  `nummy`, `str`, or array_like
+            A nummy, a string referencing a utype or a list containing
+            nummys and strings.
+            
         Returns
         -------
         `float`
-
-        Example
-        -------
-        >>>  a = gummy(1.2,0.2,utype='A')
-        >>>  b = gummy(3.2,0.5,utype='A')
-        >>>  c = gummy(0.9,0.2,utype='B')
-        >>>  d = a + b + c
-        >>>  d.ufrom('A')
-        0.53851648071345048
         """
-        if not sim:
-            return super().ufrom(x)
+        return float(np.std(self.datafrom(x,save=False),ddof=1))
+    
+    def datafrom(self,x,save=True):
+        """
+        Recomputes the convolution with only the varaibles in `x` allowed to
+        vary.  `sim` or `simulate` must be called to generate
+        Monte-Carlo data before calling this method.  This method cannot be 
+        called with save == `True` from from a nummy representing an independent 
+        variable (that is from a nummy not created by by mathematical operations
+        between two or more other nummy's).
         
-        x = [g for g in ummy._toummylist(x) if self.correlation(g) != 0]
+        Parameters
+        ----------
+        x:  list containing `nummy` or `str`
+            all independent Distributions not in the list or having a utype
+            not in the list are held fixed at their `.x()` value
             
-        v = nummy.correlation_matrix_sim(x)
+        save:  If `save` is `True` the recomputed data is stored in the `simdata`
+            attribute and `None` is returned.  If `save` is `False` then the
+            recomputed data is returned and the `simdata` attribute is not
+            overwritten.
+        
+        Returns
+        -------
+        'numpy.array' if `save` is `False`, otherwise returns `None`
+
+        Raises
+        ------
+        `NoSimulatedDataError`:
+            if no simulated data is available from a call to
+            `Distribution.simulate`.
+        `RuntimeError`:  
+            if this method is called from an independent `nummy` 
+        """
+        if not isinstance(self._dist,Distribution):
+            if nummy._nsim is None:
+                raise NoSimulatedDataError
+            return np.full(nummy._nsim,self._dist)
+        
+        if not isinstance(self.distribution,Convolution) and save == 'True':
+            raise RuntimeError('datafrom may not be called from an independent nummy with save == True')
+        
+        if self.distribution.simdata is None:
+            raise NoSimulatedDataError('no simulated data')
             
-        b = [self.correlation(z) for z in x]
-        s = np.linalg.lstsq(v,b,rcond=-1)[0]
-        u = 0
-        
-        d = [i*self.usim/j.usim 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].usim*x[j].usim
-                
-        return sqrt(u)
+        if isinstance(x,(nummy,str,Distribution)):
+            x = [x]
+        x = [i.distribution if isinstance(i,nummy) else i for i in x]
         
+        if not isinstance(self.distribution,Convolution):
+            if self.distribution in x or self.distribution.utype in x:
+                ret = self.distribution.simdata
+            else:
+                ret = np.full(self.distribution.simdata,self.distribution.x())
+        else:
+            ret = self.distribution.datafrom(x,save=save)
+            
+        if save:
+            self.distribution.simdata = ret
+        else:
+            return ret
+            
     def __add__(self,b):
         return _bop(super().__add__(b),np.add,self,b)
         

metrolopy/offsetunit.py

@@ -64,8 +64,6 @@ class _IntervalUnit(Unit):
         kwds['parent'] = parent
         Unit.__init__(self,params[0] + ' interval',params[1],conversion=conv,**kwds)
     
-    def _getme(self,ul,e):
-        return self.parent
     
 class OffsetUnit(NonlinearUnit):
     """
@@ -107,4 +105,5 @@ class OffsetUnit(NonlinearUnit):
             return (b - a,self.interval_unit)
         raise IncompatibleUnitsError('a quantity with unit ' + self.tostring() + ' may not be subtracted from a quantity with unit ' + bunit.tostring() + '; automatic conversion is disabled with offset unit instances')
 
-        
+    def _getme(self,ul,e):
+        return self.interval_unit

metrolopy/prefixedunit.py

@@ -25,6 +25,7 @@ Classes to automatically generate prefixed units from a base unit.
 """
 
 from .unit import Unit,Conversion
+from .ummy import MFraction
 
 class PrefixedUnit(Unit):    
     """PrefixedUnit(name,symbol,conversion=None,short_name=None,
@@ -40,26 +41,26 @@ class PrefixedUnit(Unit):
     will be generated. 
     """
     prefix_definitions = {
-                'yocto':[1e-24,'y',None,None,None],
-                'zepto':[1e-21,'z',None,None,None],
-                'atto':[1e-18,'a',None,None,None],
-                'femto':[1e-15,'f',None,None,None],
-                'pico':[1e-12,'p',None,None,None],
-                'nano':[1e-9,'n',None,None,None],
-                'micro':[1e-6,'\u03BC','μ',None,'u'],
-                'milli':[0.001,'m',None,None,None],
-                'centi':[0.01,'c',None,None,None],
-                'deci':[0.1,'d',None,None,None],
+                'yocto':[MFraction('1e-24'),'y',None,None,None],
+                'zepto':[MFraction('1e-21'),'z',None,None,None],
+                'atto':[MFraction('1e-18'),'a',None,None,None],
+                'femto':[MFraction('1e-15'),'f',None,None,None],
+                'pico':[MFraction('1e-12'),'p',None,None,None],
+                'nano':[MFraction('1e-9'),'n',None,None,None],
+                'micro':[MFraction('1e-6'),'\u03BC','μ',None,'u'],
+                'milli':[MFraction('0.001'),'m',None,None,None],
+                'centi':[MFraction('0.01'),'c',None,None,None],
+                'deci':[MFraction('0.1'),'d',None,None,None],
                 'deca':[10,'da',None,None,None],
                 'hecto':[100,'h',None,None,None],
                 'kilo':[1000,'k',None,None,None],
                 'mega':[1000000,'M',None,None,None],
-                'giga':[1e9,'G',None,None,None],
-                'tera':[1e12,'T',None,None,None],
-                'peta':[1e15,'P',None,None,None],
-                'exa':[1e18,'E',None,None,None],
-                'zetta':[1e21,'Z',None,None,None],
-                'yotta':[1e24,'Y',None,None,None],
+                'giga':[1000000000,'G',None,None,None],
+                'tera':[1000000000000,'T',None,None,None],
+                'peta':[1000000000000000,'P',None,None,None],
+                'exa': [1000000000000000000,'E',None,None,None],
+                'zetta':[MFraction('1e21'),'Z',None,None,None],
+                'yotta':[MFraction('1e24'),'Y',None,None,None],
                 }
     
     @staticmethod
@@ -223,13 +224,13 @@ class BinaryPrefixedUnit(PrefixedUnit):
     """
     prefix_definitions = {
                 'kilo':[1000,'k',None,None,None],
-                'mega':[1e6,'M',None,None,None],
-                'giga':[1e9,'G',None,None,None],
-                'tera':[1e12,'T',None,None,None],
-                'peta':[1e15,'P',None,None,None],
-                'exa':[1e18,'E',None,None,None],
-                'zetta':[1e21,'Z',None,None,None],
-                'yotta':[1e24,'Y',None,None,None],
+                'mega':[1000000,'M',None,None,None],
+                'giga':[1000000000,'G',None,None,None],
+                'tera':[1000000000000,'T',None,None,None],
+                'peta':[1000000000000000,'P',None,None,None],
+                'exa':[1000000000000000000,'E',None,None,None],
+                'zetta':[MFraction('1e21'),'Z',None,None,None],
+                'yotta':[MFraction('1e24'),'Y',None,None,None],
                 'kibi':[1024,'Ki',None,None,None],
                 'mebi':[1024**2,'Mi',None,None,None],
                 'gibi':[1024**3,'Gi',None,None,None],

metrolopy/relunits.py

@@ -24,8 +24,7 @@
 This module is loaded by the gummy.units module and is not intended be be
 imported directly.  Dimensionless units are defined here.
 """
-from .unit import Unit,Conversion,one
-from .ummy import MFraction
+from .unit import Unit,Conversion,one,MFraction
 
 class RatioUnit(Unit):
     """RatioUnit is used for dimensionless units like % where powers, e.g. %**2,

metrolopy/siunits.py

@@ -28,8 +28,8 @@ The most of the units here are from the SI Brochure, 9th edition.
 """
 
 from numpy import pi
-from .ummy import ummy,MFraction
-from .unit import Conversion,Unit
+from .ummy import ummy
+from .unit import Conversion,Unit,MFraction
 from .prefixedunit import PrefixedUnit
 from .offsetunit import OffsetUnit,OffsetConversion
 
@@ -112,8 +112,9 @@ with Unit._builtin():
     _degC = OffsetUnit('degree Celsius','\u00B0C',OffsetConversion(_K,273.15),
                latex_symbol='^{\\circ}C',ascii_symbol = 'degC',add_symbol=True,order=0,
                description='unit of temperature')
-    Unit.alias('degree C',_degC)
-    Unit.alias('deg C',_degC)
+    Unit.alias('degreeC',_degC)
+    Unit.alias('degree-C',_degC)
+    Unit.alias('deg-C',_degC)
     
     _lm = PrefixedUnit('lumen','lm',Conversion(_cd*_sr,1),add_symbol=True,order=0,
                        description='SI derived unit for luminous flux')
@@ -151,4 +152,5 @@ with Unit._builtin():
                           prefixes=['centi','deci','deca','hecto','kilo','mega',
                                     'giga','tera','peta','exa','zetta','yotta'],
                           description='unit of mass')
-    Unit.alias('metric ton',_tonne)
+    Unit.alias('metric ton',_tonne)
+    Unit.alias('metric-ton',_tonne)