richvalues 4.2.4__tar.gz → 4.2.6__tar.gz

{richvalues-4.2.4 → richvalues-4.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: richvalues
-Version: 4.2.4
+Version: 4.2.6
 Summary: Python library for working with uncertainties and upper/lower limits
 Home-page: https://github.com/andresmegias/richvalues/
 Author: Andrés Megías Toledano

{richvalues-4.2.4 → richvalues-4.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "richvalues"
-version = "4.2.4"
+version = "4.2.6"
 description = "Python library for working with uncertainties and upper/lower limits"
 license = {file="LICENSE"}
 authors = [{name="Andrés Megías Toledano"}]

{richvalues-4.2.4 → richvalues-4.2.6}/richvalues/__init__.py

@@ -13,12 +13,12 @@ modification, are permitted provided that the following conditions are
 met:
 
     (1) Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
+    notice, this list of conditions and the following disclaimer. 
 
     (2) Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
-    distribution.
+    distribution.  
     
     (3) The name of the author may not be used to endorse or promote
     products derived from this software without specific prior written
@@ -37,7 +37,7 @@ IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 """
 
-__version__ = '4.2.4'
+__version__ = '4.2.6'
 __author__ = 'Andrés Megías Toledano'
 
 import copy
@@ -59,7 +59,7 @@ defaultparams = {
     'size of samples': int(8e3),
     'number of significant figures': 1,
     'minimum exponent for scientific notation': 4,
-    'maximum number of decimals': 5,
+    'maximum number of decimals to use parenthesis': 5,
     'limit for extra significant figure': 2.5,
     'use extra significant figure for exact values': True,
     'use extra significant figure for finite intervals': True,
@@ -211,7 +211,7 @@ def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
     """
     n = set_default_value(n, 'number of significant figures')
     min_exp = set_default_value(min_exp, 'minimum exponent for scientific notation')
-    max_dec = set_default_value(max_dec, 'maximum number of decimals')
+    max_dec = set_default_value(max_dec, 'maximum number of decimals to use parenthesis')
     extra_sf_lim = set_default_value(extra_sf_lim, 'limit for extra significant figure')
     use_exp = True
     if ((float(x) > float(dx)
@@ -303,20 +303,29 @@ def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
                 min_exp = np.inf
                 y, dy = round_sf_unc(x, dx, n, min_exp, max_dec, extra_sf_lim)
         y = y.replace('e+', 'e').replace('e00', 'e0')
-        dy = dy.replace('e+','e').replace('e00', 'e0')
-    d = len(y.split('e')[0].split('.')[-1])
-    if d > max_dec and ')' not in dy:
+        dy = dy.replace('e+','e').replace('e00', 'e0') .replace('(', '').replace(')', '')
+    d = len(y.split('e')[0].split('.')[-1]) if '.' in y else 0
+    if max_dec == 0 or d > max_dec and ')' not in dy:
         if 'e' in y:
-            y, exp = y.split('e')
+            y, exp_y = y.split('e')
             dy, _ = dy.split('e')
         else:
-            exp = None
-        d = len(y.split('.')[-1])
-        d_ = len(dy.split('.')[-1])
-        dy_ = round_sf(float(dy)*10**(d-d_), n, 0, extra_sf_lim)
-        dy = '(' + dy_.split('e')[0] + ')'
-        if exp is not None:
-            y = '{}e{}'.format(y, exp)
+            exp_y = None
+        if dy != '0':
+            d = len(y.split('.')[-1]) if '.' in y else 0
+            d_ = len(dy.split('.')[-1]) if '.' in dy else 0
+            dy_ = round_sf(float(dy)*10**(d-d_), n, 0, extra_sf_lim)
+            dy, exp_dy = dy_.split('e')
+            exp_y_ = 0 if exp_y is None else exp_y
+            if int(exp_y_) > int(exp_dy):
+                dy = round_sf(float(dy)*10**int(exp_dy), n, np.inf, extra_sf_lim)
+                if '.' in dy:
+                    dy = dy.split('.')[-1]
+            dy = '(' + dy + ')'
+        else:
+            dy = ''
+        if exp_y is not None:
+            y = '{}e{}'.format(y, exp_y)
     return y, dy
 
 def round_sf_uncs(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
@@ -351,7 +360,7 @@ def round_sf_uncs(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
     """
     n = set_default_value(n, 'number of significant figures')
     min_exp = set_default_value(min_exp, 'minimum exponent for scientific notation')
-    max_dec = set_default_value(max_dec, 'maximum number of decimals')
+    max_dec = set_default_value(max_dec, 'maximum number of decimals to use parenthesis')
     extra_sf_lim = set_default_value(extra_sf_lim, 'limit for extra significant figure')
     dx1, dx2 = dx
     y1, dy1 = round_sf_unc(x, dx1, n, min_exp, max_dec, extra_sf_lim)
@@ -580,7 +589,7 @@ class RichValue():
         self.domain = domain
         self.num_sf = defaultparams['number of significant figures']
         self.min_exp = defaultparams['minimum exponent for scientific notation']
-        self.max_dec = defaultparams['maximum number of decimals']
+        self.max_dec = defaultparams['maximum number of decimals to use parenthesis']
         self.extra_sf_lim = defaultparams['limit for extra significant figure']
         self.pdf_info = 'default'
         self.variables = variables
@@ -632,11 +641,11 @@ class RichValue():
         """Constant value."""
         isconst = self.is_exact and self.domain[0] == self.domain[1]
         return isconst
-    @property
+    @property    
     def center(self):
         """Central value."""
         cent = self.main if self.is_centr else np.nan
-        return cent
+        return cent  
     @property
     def unc_eb(self):
         """Uncertainties with shape (2,1)."""
@@ -663,7 +672,7 @@ class RichValue():
         else:
             s_n = [np.nan]*2
         return s_n
-    @property
+    @property    
     def ampl(self):
         """Amplitudes."""
         m, b = self.main, self.domain
@@ -784,7 +793,7 @@ class RichValue():
                 m = np.nanmedian(distr)
         else:
             m = np.nan
-        return m
+        return m         
     
     def mean(self, num_points=int(1e4), sigmas=8.):
         """Mean of the PDF of the rich value."""
@@ -840,7 +849,7 @@ class RichValue():
             y = self.pdf(x)
             c = np.trapz(y*x, x) if central or standarized else 0.
             s = np.sqrt(np.trapz(y*(x-c)**2)) if standarized else 1.
-            moment = np.trapz((y*(x-c)**n)) / s**n
+            moment = np.trapz((y*(x-c)**n)) / s**n 
         else:
             moment = np.nan
         return moment
@@ -1094,7 +1103,7 @@ class RichValue():
                 else:
                     if is_lolim:
                         symbol = '>'
-                        y = int(np.floor(x)) if is_int else x
+                        y = int(np.floor(x)) if is_int else x               
                     elif is_uplim:
                         symbol = '<'
                         y = int(np.ceil(x)) if is_int else x
@@ -1144,10 +1153,10 @@ class RichValue():
                 else:
                     if is_lolim:
                         symbol = '>'
-                        y = int(np.floor(x)) if is_int else x
+                        y = int(np.floor(x)) if is_int else x  
                     elif is_uplim:
                         symbol = '<'
-                        y = int(np.ceil(x)) if is_int else x
+                        y = int(np.ceil(x)) if is_int else x  
                     y = round_sf(y, n, min_exp, extra_sf_lim)
                     if 'e' in y:
                         y, a = y.split('e')
@@ -1215,6 +1224,7 @@ class RichValue():
         rvalue = RichValue(x, dx, domain=domain, is_int=self.is_int)
         rvalue.num_sf = self.num_sf
         rvalue.min_exp = self.min_exp
+        rvalue.max_dec = self.max_dec
         rvalue.extra_sf_lim = self.extra_sf_lim
         rvalue.variables = self.variables
         expression = self.expression
@@ -1253,6 +1263,7 @@ class RichValue():
         rvalue.domain[0] = max(0, rvalue.domain[0])
         rvalue.num_sf = self.num_sf
         rvalue.min_exp = self.min_exp
+        rvalue.max_dec = self.max_dec
         rvalue.extra_sf_lim = self.extra_sf_lim
         rvalue.variables = self.variables
         rvalue.expression = 'abs({})'.format(self.expression)
@@ -1431,7 +1442,7 @@ class RichValue():
         if domain[0] > 0 and other_.sign() != -1:
             domain[0] = 0
         if domain[1] < 0 and other_.sign() != 1:
-            domain[1] = 0
+            domain[1] = 0    
         rvalue = function_with_rich_values('{}%{}', [self, other_],
                                domain=domain, is_domain_cyclic=True)
         return rvalue
@@ -1498,6 +1509,7 @@ class RichValue():
                 rvalue = RichValue(np.nan)
             rvalue.num_sf = self.num_sf
             rvalue.min_exp = self.min_exp
+            rvalue.max_dec = self.max_dec
             rvalue.extra_sf_lim = self.extra_sf_lim
         else:
             vars_str = ','.join(variables)
@@ -1546,7 +1558,7 @@ class RichValue():
                 x = [x]
             x = np.array(x)
             y = np.zeros(len(x))
-            if self.is_exact:
+            if self.is_exact:    
                 ind = np.argmin(abs(x - main))
                 if hasattr(ind, '__iter__'):
                     ind = ind[0]
@@ -1607,7 +1619,7 @@ class RichValue():
                     if not self.is_lim:
                         distr = general_distribution(main, unc, domain, N)
                     else:
-                        x1, x2 = self.interval()
+                        x1, x2 = self.interval()    
                         distr = loguniform_distribution(x1, x2, N)
                 elif not is_finite_interv and all(np.isinf(unc)):
                     distr = loguniform_distribution(-np.inf, np.inf, N)
@@ -1857,17 +1869,17 @@ class RichArray(np.ndarray):
         return np.array([x.main for x in self.flat]).reshape(self.shape)
     @property
     def uncs(self):
-        return np.array([x.unc for x in self.flat]).reshape([*self.shape,2])
+        return np.array([x.unc for x in self.flat]).reshape([*self.shape,2]) 
     @property
     def are_lolims(self):
         return np.array([x.is_lolim for x in self.flat]).reshape(self.shape)
     @property
     def are_uplims(self):
-        return np.array([x.is_uplim for x in self.flat]).reshape(self.shape)
+        return np.array([x.is_uplim for x in self.flat]).reshape(self.shape) 
     @property
     def are_ranges(self):
         return np.array([x.is_range for x in self.flat]).reshape(self.shape)
-    @property
+    @property 
     def domains(self):
         return np.array([x.domain for x in self.flat]).reshape([*self.shape,2])
     @property
@@ -1908,7 +1920,7 @@ class RichArray(np.ndarray):
         return np.array([x.is_inf for x in self.flat]).reshape(self.shape)
     @property
     def centers(self):
-        return np.array([x.center for x in self.flat]).reshape(self.shape)
+        return np.array([x.center for x in self.flat]).reshape(self.shape) 
     @property
     def rel_uncs(self):
         return (np.array([x.rel_unc for x in self.flat])
@@ -1982,36 +1994,36 @@ class RichArray(np.ndarray):
     
     def medians(self, num_points=None):
         return np.array([x.median(num_points)
-                         for x in self.flat]).reshape(self.shape)
+                         for x in self.flat]).reshape(self.shape) 
 
     def means(self, num_points=int(1e4), sigmas=8.):
         return np.array([x.mean(num_points, sigmas)
-                         for x in self.flat]).reshape(self.shape)
+                         for x in self.flat]).reshape(self.shape) 
 
     def modes(self, num_points=int(1e4), sigmas=8.):
         return np.array([x.mode(num_points, sigmas)
-                         for x in self.flat]).reshape(self.shape)
+                         for x in self.flat]).reshape(self.shape) 
 
     def variances(self, num_points=int(1e4), sigmas=8.):
         return np.array([x.var(num_points, sigmas)
-                         for x in self.flat]).reshape(self.shape)
+                         for x in self.flat]).reshape(self.shape) 
 
     def stds(self, num_points=int(1e4), sigmas=8.):
         return np.array([x.std(num_points, sigmas)
-                         for x in self.flat]).reshape(self.shape)
+                         for x in self.flat]).reshape(self.shape) 
     
     def moments(self, n, central=True, standarized=False):
         return np.array([x.moments(n, central, standarized)
-                                   for x in self.flat]).reshape(self.shape)
+                                   for x in self.flat]).reshape(self.shape) 
     
     def set_params(self, params):
         """Set the rich value parameters of each entry of the rich array."""
         abbreviations = {'is integer': 'is_int',
                          'number of significant figures': 'num_sf',
                          'minimum exponent for scientific notation': 'min_exp',
-                         'maximum number of decimals': 'max_dec',
+                         'maximum number of decimals to use parenthesis': 'max_dec',
                          'limit for extra significant figure': 'extra_sf_lim'}
-        attributes = ['domain'] + list(abbreviations.values())
+        attributes = ['domain'] + list(abbreviations.values()) 
         for entry in abbreviations:
             name = abbreviations[entry]
             if entry in params:
@@ -2163,7 +2175,7 @@ class RichDataFrame(pd.DataFrame):
         exec(code, {**{'self': self}, **globals()}, output)
         return output['df']
 
-    @property
+    @property    
     def mains(self): return self._property('mains')
     @property
     def uncs(self): return self._property2('uncs')
@@ -2247,7 +2259,7 @@ class RichDataFrame(pd.DataFrame):
         abbreviations = {'is integer': 'is_int',
                          'number of significant figures': 'num_sf',
                          'minimum exponent for scientific notation': 'min_exp',
-                         'maximum number of decimals': 'max_dec',
+                         'maximum number of decimals to use parenthesis': 'max_dec',
                          'limit for extra significant figure': 'extra_sf_lim'}
         attributes = ['domain'] + list(abbreviations.values())
         for entry in abbreviations:
@@ -2595,7 +2607,7 @@ class ComplexRichValue():
         Parameters
         ----------
         real : rich value
-            Real part of the complex rich value.
+            Real part of the complex rich value. 
         imag : rich value
             Imaginary part of the complex rich value
         """
@@ -2676,14 +2688,14 @@ class ComplexRichValue():
         self.imag.num_sf = x
         
     @property
-    def min_exp(self): return round(np.mean([self.real.min_exp, self.imag.min_exp]))
+    def min_exp(self): return round(np.mean([self.real.min_exp, self.imag.min_exp]))  
     @min_exp.setter
     def min_exp(self, x):
         self.real.min_exp = x
         self.imag.min_exp = x
         
     @property
-    def max_dec(self): return min(self.real.max_dec, self.imag.max_dec)
+    def max_dec(self): return min(self.real.max_dec, self.imag.max_dec)  
     @max_dec.setter
     def max_dec(self, x):
         self.real.max_dec = x
@@ -2723,7 +2735,7 @@ class ComplexRichValue():
     def main(self):
         """Main value."""
         x = self.real.main + 1j*self.imag.main
-        return x
+        return x 
 
     @property
     def unc(self):
@@ -2943,7 +2955,7 @@ class ComplexRichValue():
         """Apply a function to the rich value"""
         return function_with_rich_values(function, self, **kwargs)
     
-    # Instance variable acronyms.
+    # Instance variable acronyms.  
 
     @property
     def real_part(self): return self.real
@@ -2988,6 +3000,7 @@ def add_rich_values(x, y):
     """Sum two rich values to get a new one."""
     num_sf = min(x.num_sf, y.num_sf)
     min_exp = round(np.mean([x.min_exp, y.min_exp]))
+    max_dec = round(np.mean([x.max_dec, y.max_dec]))
     extra_sf_lim = max(x.extra_sf_lim, y.extra_sf_lim)
     is_int = x.is_int and y.is_int
     domain = [x.domain[0] + y.domain[0], x.domain[1] + y.domain[1]]
@@ -3005,6 +3018,7 @@ def add_rich_values(x, y):
                                       is_vectorizable=True)
     z.num_sf = num_sf
     z.min_exp = min_exp
+    z.max_dec = max_dec
     z.extra_sf_lim = extra_sf_lim
     return z
 
@@ -3012,6 +3026,7 @@ def multiply_rich_values(x, y):
     """Multiply two rich values to get a new one."""
     num_sf = min(x.num_sf, y.num_sf)
     min_exp = round(np.mean([x.min_exp, y.min_exp]))
+    max_dec = round(np.mean([x.max_dec, y.max_dec]))
     extra_sf_lim = max(x.extra_sf_lim, y.extra_sf_lim)
     is_int = x.is_int and y.is_int
     domain = propagate_domain(x.domain, y.domain, lambda a,b: a*b)
@@ -3030,6 +3045,7 @@ def multiply_rich_values(x, y):
                                       is_vectorizable=True)
     z.num_sf = num_sf
     z.min_exp = min_exp
+    z.max_dec = max_dec
     z.extra_sf_lim = extra_sf_lim
     return z
 
@@ -3037,6 +3053,7 @@ def divide_rich_values(x, y):
     """Divide two rich values to get a new one."""
     num_sf = min(x.num_sf, y.num_sf)
     min_exp = round(np.mean([x.min_exp, y.min_exp]))
+    max_dec = round(np.mean([x.max_dec, y.max_dec]))
     extra_sf_lim = max(x.extra_sf_lim, y.extra_sf_lim)
     is_int = x.is_int and y.is_int
     domain = propagate_domain(x.domain, y.domain, lambda a,b: a/b)
@@ -3078,6 +3095,7 @@ def divide_rich_values(x, y):
                                       is_vectorizable=True, sigmas=sigmas)
     z.num_sf = num_sf
     z.min_exp = min_exp
+    z.max_dec = max_dec
     z.extra_sf_lim = extra_sf_lim
     return z
 
@@ -3211,7 +3229,8 @@ def less_equiv(x, y, sigmas_interval=None, sigmas_overlap=None):
     return output
 
 def rich_value(text=None, domain=None, is_int=None, pdf=None,
-               consider_intervs=True, use_default_extra_sf_lim=False):
+               consider_intervs=True, use_default_max_dec=False,
+               use_default_extra_sf_lim=False):
     """
     Convert the input text to a rich value.
 
@@ -3233,6 +3252,10 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
         If the PDF is given, this variable determines if we consider the
         possibility that the rich value is an upper/lower limit or a finite
         interval of values. By default, it is True.
+    use_default_max_dec : bool, optional
+        If True, the default maximum number of decimals to show uncertainties
+        between parenthesis will be used instead of inferring it from the input
+        text. This will reduce the computation time a little bit.
     use_default_extra_sf_lim : bool, optional
         If True, the default limit for extra significant figure will be used
         instead of inferring it from the input text. This will reduce the
@@ -3258,6 +3281,7 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
 
     input_domain = copy.copy(domain)
     default_num_sf = defaultparams['number of significant figures']
+    default_max_dec = defaultparams['maximum number of decimals to use parenthesis']
     default_extra_sf_lim = defaultparams['limit for extra significant figure']
     abbreviations = {'inf': 'np.inf', 'tau': 'math.tau', 'pi': 'np.pi',
                      'nan': 'np.nan', 'NaN': 'np.nan', 'none': 'np.nan'}
@@ -3287,7 +3311,7 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
         domain = read_domain(text)
         if domain is not None:
             text = text.split('[')[0][:-1]
-        if not '--' in text:
+        if not '--' in text:    
             if text.startswith('+'):
                 text = text[1:]
             if 'e' in text:
@@ -3341,8 +3365,8 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
                     d = len(x.split('.')[1]) if '.' in x else 0
                     d1 = len(dx1.split('.')[1]) if '.' in dx1 else 0
                     d2 = len(dx1.split('.')[1]) if '.' in dx2 else 0
-                    dx1 = '{:f}'.format(float(dx1)*10**(-(d-d1)))
-                    dx2 = '{:f}'.format(float(dx2)*10**(-(d-d2)))
+                    dx1 = str(float(dx1)*10**(-(d-d1)))
+                    dx2 = str(float(dx2)*10**(-(d-d2)))
                 elif '+/-' in text:
                     x, dx = x_dx.split('+/-')
                     text = '{}-{}+{} {}'.format(x, dx, dx, e)
@@ -3370,6 +3394,11 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
             x = parse_value(x)
             dx1 = parse_value(dx1)
             dx2 = parse_value(dx2)
+            if not use_default_max_dec:
+                num_dec = len(x.split('.')[1].split('e')[0]) if '.' in x else 0
+                max_dec = num_dec - 1
+            else:
+                max_dec = default_max_dec
             if not use_default_extra_sf_lim:
                 if (not (is_lolim or is_uplim)
                         and not (eval(dx1) == eval(dx2) == 0)):
@@ -3397,11 +3426,11 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
                 if eval(dx1) == eval(dx2) == 0:
                     extra_sf_lim = 1 - 1e-8
                 else:
-                    extra_sf_lim = default_extra_sf_lim
+                    extra_sf_lim = default_extra_sf_lim 
                     base = float('{:e}'.format(eval(val)).split('e')[0])
                     if base <= default_extra_sf_lim:
                         if num_sf < default_num_sf + 1:
-                            extra_sf_lim = base - 1e-8
+                            extra_sf_lim = base - 1e-8    
             else:
                 extra_sf_lim = default_extra_sf_lim
             x = x.replace('e0','')
@@ -3409,31 +3438,33 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
             unc = [eval(dx1), eval(dx2)]
             is_range = False
             if domain is None and np.isfinite(main) and unc[0] == 0. == unc[1]:
-                domain = [main]*2
+                domain = [main]*2          
         else:
             text = text.replace(' --','--').replace('-- ','--')
             text1, text2 = text.split('--')
-            x1, _, _, _, _, _, me1, el1 = parse_as_rich_value(text1)
-            x2, _, _, _, _, _, me2, el2 = parse_as_rich_value(text2)
+            x1, _, _, _, _, _, me1, md1, el1 = parse_as_rich_value(text1)
+            x2, _, _, _, _, _, me2, md2, el2 = parse_as_rich_value(text2)
             main = [x1, x2]
             unc = 0
             is_lolim, is_uplim, is_range = False, False, True
             min_exp = round(np.mean([me1, me2]))
+            max_dec = round(np.mean([md1, md2]))
             extra_sf_lim = max(el1, el2)
         return (main, unc, is_lolim, is_uplim, is_range, domain,
-                min_exp, extra_sf_lim)
+                min_exp, max_dec, extra_sf_lim)
     
     if pdf is None:
         text = str(text)
         is_complex = 'j' in text
         if not is_complex:
-            (main, unc, is_lolim, is_uplim, is_range, domain,
-                         min_exp, extra_sf_lim) = parse_as_rich_value(text)
+            (main, unc, is_lolim, is_uplim, is_range, domain, min_exp,
+                         max_dec, extra_sf_lim) = parse_as_rich_value(text)
             if input_domain is not None:
                 domain = input_domain
             rvalue = RichValue(main, unc, is_lolim, is_uplim,
                                is_range, domain, is_int)
             rvalue.min_exp = min_exp
+            rvalue.max_dec = max_dec
             rvalue.extra_sf_lim = extra_sf_lim
         else:
             if '+/-' in text or '-' in text[1:] and '+' in text[1:]:
@@ -3451,12 +3482,13 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
                     text_imag = text_imag[1:]
                 if text_imag[-1] == ')':
                     text_imag = text_imag[:-1]
-                args = (domain, is_int, pdf, use_default_extra_sf_lim)
+                args = (domain, is_int, pdf,
+                        use_default_max_dec, use_default_extra_sf_lim)
                 real = rich_value(text_real, *args)
                 imag = rich_value(text_imag, *args)
             else:
                 text = text.replace(' + ', '+').replace(' - ', '-')
-                val = complex(text)
+                val = complex(text) 
                 real = val.real
                 imag = val.imag
             rvalue = ComplexRichValue(real, imag, domain, is_int)
@@ -4173,7 +4205,7 @@ def loguniform_distribution(low=-1, high=1, size=1,
             log_x2 = _log10(abs(x2))
         if log_x1 < zero_log:
             log_x1 = zero_log
-        if log_x2 > inf_log:
+        if log_x2 > inf_log: 
             log_x2 = inf_log
         if x1 < 0:
             if x2 <= 0:
@@ -4315,7 +4347,7 @@ def add_zero_infs(interval, zero_log, inf_log):
     elif x2 > 0 and x2 > 10**inf_log:
         x2 = np.inf
     new_interval = [x1, x2]
-    return new_interval
+    return new_interval 
 def remove_zero_infs(interval, zero_log, inf_log):
     """Replace 0 and infinity for the given values in the input interval."""
     x1, x2 = interval
@@ -4782,6 +4814,7 @@ def function_with_rich_values(function, args, unc_function=None,
         len_samples = int(len(args)**0.5 * defaultparams['size of samples'])
     num_sf = int(np.median([arg.num_sf for arg in args]))
     min_exp = round(np.mean([arg.min_exp for arg in args]))
+    max_dec = round(np.mean([arg.max_dec for arg in args]))
     extra_sf_lim = max([arg.extra_sf_lim for arg in args])
     
     if consider_intervs is None:
@@ -4919,6 +4952,7 @@ def function_with_rich_values(function, args, unc_function=None,
                 rval_k = ComplexRichValue(real_k, imag_k)
             rval_k.num_sf = num_sf
             rval_k.min_exp = min_exp
+            rval_k.max_dec = max_dec
             rval_k.extra_sf_lim = extra_sf_lim
             output += [rval_k]
             
@@ -4946,6 +4980,7 @@ def function_with_rich_values(function, args, unc_function=None,
                           num_reps_lims, save_pdf)
             rval_k.num_sf = num_sf
             rval_k.min_exp = min_exp
+            rval_k.max_dec = max_dec
             rval_k.extra_sf_lim = extra_sf_lim
             if type(input_function) is str:
                 if type(rval_k) is RichValue:
@@ -5427,7 +5462,7 @@ def curve_fit(x, y, function, guess, num_samples=3000,
         lim1, lim2 = 0.2, 1.2
         if disp_coef <= lim1:
             frac1 = 1.
-        elif disp_coef < lim2:
+        elif disp_coef < lim2: 
             frac1 = 1. - disp_coef / (lim2 - lim1)
         else:
             frac1 = 0.
@@ -5440,7 +5475,7 @@ def curve_fit(x, y, function, guess, num_samples=3000,
     result = {'parameters': params_fit, 'dispersion': dispersion, 'loss': loss,
               'parameters samples': samples, 'dispersion sample': dispersions,
               'loss sample': losses, 'number of fails': num_fails}
-    return result
+    return result   
 
 def point_fit(y, function, guess, num_samples=3000,
               loss=lambda a,b: (a-b)**2, lim_loss_factor=4.,
@@ -5517,7 +5552,7 @@ def point_fit(y, function, guess, num_samples=3000,
         lim1, lim2 = 0.2, 1.2
         if disp_coef <= lim1:
             frac1 = 1.
-        elif disp_coef < lim2:
+        elif disp_coef < lim2: 
             frac1 = 1. - disp_coef / (lim2 - lim1)
         else:
             frac1 = 0.
@@ -5760,4 +5795,4 @@ evaluate_distribution = evaluate_distr
 center_and_uncertainties = center_and_uncs
 is_not_a_number = is_nan = isnan
 is_infinite = is_inf = isinf
-is_finite = is_finite = isfinite
+is_finite = is_finite = isfinite

{richvalues-4.2.4 → richvalues-4.2.6}/richvalues.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: richvalues
-Version: 4.2.4
+Version: 4.2.6
 Summary: Python library for working with uncertainties and upper/lower limits
 Home-page: https://github.com/andresmegias/richvalues/
 Author: Andrés Megías Toledano

{richvalues-4.2.4 → richvalues-4.2.6}/setup.py

@@ -5,7 +5,7 @@ with open('README.md', 'r') as file:
 
 setuptools.setup(
     name = 'richvalues',
-    version = '4.2.4',
+    version = '4.2.6',
     license = 'BSD-3-Clause',
     author = 'Andrés Megías Toledano',
     description = 'Python library for working with uncertainties and upper/lower limits',