richvalues 4.0.5__tar.gz → 4.1.0__tar.gz

{richvalues-4.0.5 → richvalues-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: richvalues
-Version: 4.0.5
+Version: 4.1.0
 Summary: Python library for working with uncertainties and upper/lower limits
 Home-page: https://github.com/andresmegias/richvalues/
 Author: Andrés Megías Toledano
@@ -15,7 +15,7 @@ License-File: LICENSE
 
 RichValues is a Python 3 library for working with numeric values with uncertainties, upper/lower limits and finite intervals, which may be called _rich values_. 
 
-With it, one can import rich values written in plain text documents in an easily readable format, operate with them propagating the uncertainties automatically, and export them in the same formatting style as the import. It also allows to easily plot rich values and to make fits to any function, taking into account the uncertainties and the upper/limits or finite intervals. Moreover, correlations between variables are taken into account when performing calculations with rich values. 
+With it, one can import rich values written in plain text documents in an easily readable format, operate with them propagating the uncertainties automatically, and export them in the same formatting style as the import. It also allows to easily plot rich values and to make fits to any function, taking into account the uncertainties and the upper/lower limits or finite intervals. Moreover, correlations between variables are taken into account when performing calculations with rich values. 
 
 The libraries NumPy, Pandas, SciPy and Matplotlib are required by RichValues. A user guide and a quick tutorial are available on GitHub: https://github.com/andresmegias/richvalues/.
 

{richvalues-4.0.5 → richvalues-4.1.0}/README.md

@@ -1,5 +1,5 @@
 RichValues is a Python 3 library for working with numeric values with uncertainties, upper/lower limits and finite intervals, which may be called _rich values_. 
 
-With it, one can import rich values written in plain text documents in an easily readable format, operate with them propagating the uncertainties automatically, and export them in the same formatting style as the import. It also allows to easily plot rich values and to make fits to any function, taking into account the uncertainties and the upper/limits or finite intervals. Moreover, correlations between variables are taken into account when performing calculations with rich values. 
+With it, one can import rich values written in plain text documents in an easily readable format, operate with them propagating the uncertainties automatically, and export them in the same formatting style as the import. It also allows to easily plot rich values and to make fits to any function, taking into account the uncertainties and the upper/lower limits or finite intervals. Moreover, correlations between variables are taken into account when performing calculations with rich values. 
 
 The libraries NumPy, Pandas, SciPy and Matplotlib are required by RichValues. A user guide and a quick tutorial are available on GitHub: https://github.com/andresmegias/richvalues/.

{richvalues-4.0.5 → richvalues-4.1.0}/pyproject.toml

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

{richvalues-4.0.5 → richvalues-4.1.0}/richvalues/__init__.py

@@ -4,7 +4,7 @@
 """
 Rich Values Library
 -------------------
-Version 4.0
+Version 4.1
 
 Copyright (C) 2024 - Andrés Megías Toledano
 
@@ -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.0.5'
+__version__ = '4.1.0'
 __author__ = 'Andrés Megías Toledano'
 
 import copy
@@ -57,6 +57,7 @@ defaultparams = {
     'size of samples': int(8e3),
     'number of significant figures': 1,
     'minimum exponent for scientific notation': 4,
+    'maximum number of decimals': 5,
     'limit for extra significant figure': 2.5,
     'use extra significant figure for exact values': True,
     'use extra significant figure for finite intervals': True, 
@@ -174,7 +175,7 @@ def round_sf(x, n=None, min_exp=None, extra_sf_lim=None):
     y = y.replace('e+','e').replace('e00','e0')
     return y
 
-def round_sf_unc(x, dx, n=None, min_exp=None, extra_sf_lim=None):
+def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
     """
     Round a value and its uncertainty depending on their significant figures.
 
@@ -189,6 +190,9 @@ def round_sf_unc(x, dx, n=None, min_exp=None, extra_sf_lim=None):
     min_exp : int, optional
         Minimum decimal exponent, in absolute value, to display the values in
         scientific notation. The default is 4.
+    max_dec : int, optional
+        Maximum number of decimals, to use the notation with parenthesis.
+        The default is 5.
     extra_sf_lim : float, optional
         If the number expressed in scientific notation has a base that is lower
         than this value, an additional significant figure will be used.
@@ -202,10 +206,9 @@ def round_sf_unc(x, dx, n=None, min_exp=None, extra_sf_lim=None):
         Rounded uncertainty.
     """
     n = set_default_value(n, 'number of significant figures')
-    min_exp = set_default_value(min_exp,
-                                'minimum exponent for scientific notation')
-    extra_sf_lim = set_default_value(extra_sf_lim,
-                                     'limit for extra significant figure')
+    min_exp = set_default_value(min_exp, 'minimum exponent for scientific notation')
+    max_dec = set_default_value(max_dec, 'maximum number of decimals')
+    extra_sf_lim = set_default_value(extra_sf_lim, 'limit for extra significant figure')
     use_exp = True
     if ((float(x) > float(dx)
           and all(abs(np.floor(_log10(abs(np.array([x, dx]))))) < min_exp))
@@ -238,7 +241,8 @@ def round_sf_unc(x, dx, n=None, min_exp=None, extra_sf_lim=None):
                 num_digits_x = len(str(x).split('.')[0])
                 if num_digits_y > num_digits_x:
                     m -= 1
-                if float(dy[0]) <= extra_sf_lim:
+                base_dy = '{:e}'.format(float(dy)).split('e')[0]
+                if float(base_dy) <= extra_sf_lim:
                     m += 1
                 y = round_sf(x, m, min_exp, extra_sf_lim=1-1e-8)
         else:
@@ -268,7 +272,7 @@ def round_sf_unc(x, dx, n=None, min_exp=None, extra_sf_lim=None):
                 y = '{}e{}'.format(base_y, exp_dy)
             else:
                 f = 10**(-int(exp_y))
-                base_y, dy = round_sf_unc(x*f, dx*f, n, np.inf, extra_sf_lim)
+                base_y, dy = round_sf_unc(x*f, dx*f, n, np.inf, max_dec, extra_sf_lim)
                 y = '{}e{}'.format(base_y, exp_y)
     elif dx == 0:
         y = round_sf(x, n, min_exp, extra_sf_lim)
@@ -289,12 +293,24 @@ def round_sf_unc(x, dx, n=None, min_exp=None, extra_sf_lim=None):
             if abs(exp) < min_exp:
                 x = float(sign + str(x))
                 min_exp = np.inf
-                y, dy = round_sf_unc(x, dx, n, min_exp, extra_sf_lim)
+                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:
+        if 'e' in y:
+            y, exp = y.split('e')
+            dy, _ = dy.split('e')
+        else:
+            exp = None
+        d = len(y.split('.')[-1])
+        dy_ = round_sf(float(dy)*10**d, n, min_exp=np.inf, extra_sf_lim=0.)
+        dy = '(' + dy_.split('e')[0] + ')'
+        if exp is not None:
+            y = '{}e{}'.format(y, exp)
     return y, dy
 
-def round_sf_uncs(x, dx, n=None, min_exp=None, extra_sf_lim=None):
+def round_sf_uncs(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
     """
     Round a value and its uncertainties depending on their significant figures.
 
@@ -309,6 +325,9 @@ def round_sf_uncs(x, dx, n=None, min_exp=None, extra_sf_lim=None):
     min_exp : int, optional
         Minimum decimal exponent, in absolute value, to apply scientific
         notation. The default is 4.
+    max_dec : int, optional
+        Maximum number of decimals, to apply notation with parenthesis.
+        The default is 5.
     extra_sf_lim : float, optional
         If the number expressed in scientific notation has a base that is lower
         than this value, an additional significant figure will be used.
@@ -322,32 +341,47 @@ def round_sf_uncs(x, dx, n=None, min_exp=None, extra_sf_lim=None):
         Rounded uncertainties.
     """
     n = set_default_value(n, 'number of significant figures')
-    min_exp = set_default_value(min_exp,
-                                'minimum exponent for scientific notation')
-    extra_sf_lim = set_default_value(extra_sf_lim,
-                                     'limit for extra significant figure')
+    min_exp = set_default_value(min_exp, 'minimum exponent for scientific notation')
+    max_dec = set_default_value(max_dec, 'maximum number of decimals')
+    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, extra_sf_lim)
-    y2, dy2 = round_sf_unc(x, dx2, n, min_exp, extra_sf_lim)
+    y1, dy1 = round_sf_unc(x, dx1, n, min_exp, max_dec, extra_sf_lim)
+    y2, dy2 = round_sf_unc(x, dx2, n, min_exp, max_dec, extra_sf_lim)
     num_dec_1 = len(y1.split('e')[0].split('.')[1]) if '.' in y1 else 0
     num_dec_2 = len(y2.split('e')[0].split('.')[1]) if '.' in y2 else 0
     if num_dec_2 > num_dec_1:
         diff = num_dec_2 - num_dec_1
-        y1, dy1 = round_sf_unc(x, dx1, n+diff, min_exp, extra_sf_lim)
-        y2, dy2 = round_sf_unc(x, dx2, n, min_exp, extra_sf_lim)
+        y1, dy1 = round_sf_unc(x, dx1, n+diff, min_exp, max_dec, extra_sf_lim)
+        y2, dy2 = round_sf_unc(x, dx2, n, min_exp, max_dec, extra_sf_lim)
     else:
         diff = num_dec_1 - num_dec_2
         off1, off2 = 0, 0
         if num_dec_1 == 0 == num_dec_2:
-            b1 = float(str(dy1)[0]) if np.isfinite(dx1) else 10.
-            b2 = float(str(dy2)[0]) if np.isfinite(dx2) else 10.
+            base_dy1 = '{:e}'.format(dx1).split('e')[0]
+            base_dy2 = '{:e}'.format(dx2).split('e')[0]
+            b1 = float(base_dy1) if np.isfinite(dx1) else 10.
+            b2 = float(base_dy2) if np.isfinite(dx2) else 10.
             if dx2 > dx1 and b1 <= extra_sf_lim and b2 > extra_sf_lim:
                 off2 = 1
             if dx1 > dx2 and b2 <= extra_sf_lim and b1 > extra_sf_lim:
                 off1 = 1
-        y1, dy1 = round_sf_unc(x, dx1, n+off1, min_exp, extra_sf_lim)
-        y2, dy2 = round_sf_unc(x, dx2, n+diff+off2, min_exp, extra_sf_lim)
+        y1, dy1 = round_sf_unc(x, dx1, n+off1, min_exp, max_dec, extra_sf_lim)
+        y2, dy2 = round_sf_unc(x, dx2, n+diff+off2, min_exp, max_dec, extra_sf_lim)
     y = y1 if dx2 > dx1 else y2
+    if dy1 != dy2 and (')' in dy1 or ')' in dy2):
+        dy1 = dy1.replace('(', '(-')
+        dy2 = dy2.replace('(', '(+')
+    if ')' in dy1 and ')' not in dy2 or ')' in dy2 and '.' in dy2:
+        _, dy2 = round_sf_unc(x, dx[1], n, min_exp, max_dec-1, extra_sf_lim)
+        dy2 = '(' + dy2[1:-1] + '0' + ')'
+    elif ')' in dy2 and ')' not in dy1 or ')' in dy1 and '.' in dy1:
+        _, dy1 = round_sf_unc(x, dx[0], n, min_exp, max_dec-1, extra_sf_lim)
+        dy1 = '(' + dy1[1:-1] + '0' + ')'
+    if ')' in dy1 or ')' in dy2:
+        if not dy1.startswith('(-'):
+            dy1 = '(-' + dy1[1:]
+        if not dy2.startswith('(+'):
+            dy2 = '(+' + dy2[1:]
     dy = [dy1, dy2]
     return y, dy
 
@@ -530,6 +564,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.extra_sf_lim = defaultparams['limit for extra significant figure']
         self.pdf_info = 'default'
         self.variables = variables
@@ -716,10 +751,10 @@ class RichValue():
         domain = copy.copy(self.domain)
         is_int = self.is_int
         min_exp = abs(self.min_exp)
+        max_dec = abs(self.max_dec)
         extra_sf_lim = self.extra_sf_lim
         show_domain = defaultparams['show domain']
-        show_asterisk = defaultparams['show asterisk for rich values with'
-                                      ' custom PDF']
+        show_asterisk = defaultparams['show asterisk for rich values with custom PDF']
         use_extra_sf_in_exacts = \
             defaultparams['use extra significant figure for exact values']
         use_extra_sf_in_ranges = \
@@ -736,7 +771,7 @@ class RichValue():
                        else False)
         use_exp = True
         if ((self.is_centr and 'e' not in
-             str(round_sf_uncs(x, dx, n, min_exp, extra_sf_lim)))
+             str(round_sf_uncs(x, dx, n, min_exp, max_dec, extra_sf_lim)))
               or self.is_lim and abs(np.floor(_log10(abs(float(x))) < min_exp))
               or np.isinf(min_exp)):
             use_exp = False
@@ -747,8 +782,8 @@ class RichValue():
                     if (not range_bound and use_extra_sf_in_exacts
                         or range_bound and use_extra_sf_in_ranges):
                         n += 1
-                y, (dy1, dy2) = round_sf_uncs(x, [dx1, dx2], n,
-                                              min_exp, extra_sf_lim)
+                y, (dy1, dy2) = round_sf_uncs(x, [dx1, dx2], n, min_exp,
+                                              max_dec, extra_sf_lim)
                 if 'e' in y:
                     y, a = y.split('e')
                     a = int(a)
@@ -758,14 +793,20 @@ class RichValue():
                     dy1, _ = dy1.split('e')
                 if 'e' in dy2:
                     dy2, _ = dy2.split('e')
-                if dy1 == dy2:
-                    if float(dy1) != 0:
-                        text = '{}+/-{} e{}'.format(y, dy1, a)
+                if ')' not in dy1:
+                    if dy1 == dy2:
+                        if float(dy1) != 0:
+                            text = '{}+/-{} e{}'.format(y, dy1, a)
+                        else:
+                            y = int(round(float(y))) if is_int else y
+                            text = '{} e{}'.format(y, a)
                     else:
-                        y = int(round(float(y))) if is_int else y
-                        text = '{} e{}'.format(y, a)
+                        text = '{}-{}+{} e{}'.format(y, dy1, dy2, a)
                 else:
-                    text = '{}-{}+{} e{}'.format(y, dy1, dy2, a)
+                    if dy1 == dy2:
+                        text = '{}{} e{}'.format(y, dy1, a)
+                    else:
+                        text = '{}{}{} e{}'.format(y, dy1, dy2, a)
                 if not use_exp:
                     text = text.replace(' e0','')
             else:
@@ -848,6 +889,7 @@ class RichValue():
         is_range = self.is_range
         is_int = self.is_int
         min_exp = abs(self.min_exp)
+        max_dec = abs(self.max_dec)
         extra_sf_lim = self.extra_sf_lim
         show_domain = defaultparams['show domain']
         use_exp = True
@@ -871,7 +913,7 @@ class RichValue():
                        else False)
         if is_numeric:
             if not is_range:
-                _, unc_r = round_sf_uncs(x, dx, n, min_exp, extra_sf_lim)
+                _, unc_r = round_sf_uncs(x, dx, n, min_exp, np.inf, extra_sf_lim)
                 unc_r = np.array(unc_r, float)
             if not is_range and not use_exp:
                 if not self.is_lim:
@@ -883,11 +925,11 @@ class RichValue():
                                  round_sf(x, n, np.inf, extra_sf_lim))
                             text = '${}$'.format(y)
                         else:
-                            y, dy = round_sf_unc(x, dx[0], n,
-                                                 min_exp, extra_sf_lim)
+                            y, dy = round_sf_unc(x, dx[0], n, min_exp,
+                                                 max_dec, extra_sf_lim)
                             text = '${} \pm {}$'.format(y, dy)
                     else:
-                        y, dy = round_sf_uncs(x, dx, n, min_exp, extra_sf_lim)
+                        y, dy = round_sf_uncs(x, dx, n, min_exp, max_dec, extra_sf_lim)
                         text = '$'+y + '_{-'+dy[0]+'}^{+'+dy[1]+'}$'
                 else:
                     if is_lolim:
@@ -915,8 +957,8 @@ class RichValue():
                             text = ('${} {}'.format(y, mult_symbol)
                                     + ' 10^{'+a+'}$')
                         else:
-                            y, dy = round_sf_unc(x, dx[0], n,
-                                                 min_exp, extra_sf_lim)
+                            y, dy = round_sf_unc(x, dx[0], n, min_exp,
+                                                 max_dec, extra_sf_lim)
                             if 'e' in y:
                                 y, a = y.split('e')
                                 dy, a = dy.split('e')
@@ -926,8 +968,8 @@ class RichValue():
                             text = ('$({} \pm {}) '.format(y, dy)
                                      + mult_symbol + ' 10^{'+a+'}$')
                     else:
-                        y, dy = round_sf_uncs(x, [dx[0], dx[1]], n,
-                                              min_exp, extra_sf_lim)
+                        y, dy = round_sf_uncs(x, [dx[0], dx[1]], n, min_exp,
+                                              max_dec, extra_sf_lim)
                         if 'e' in y:
                             y, a = y.split('e')
                             dy1, a = dy[0].split('e')
@@ -945,13 +987,13 @@ class RichValue():
                     elif is_uplim:
                         symbol = '<'
                         y = int(np.ceil(x)) if is_int else x  
-                    min_exp = 0
                     y = round_sf(y, n, min_exp, extra_sf_lim)
-                    y, a = y.split('e')
-                    a = str(int(a))
+                    if 'e' in y:
+                        y, a = y.split('e')
+                    else:
+                        a = '0'
                     text = ('${} {} {}'.format(symbol, y, mult_symbol)
                             + ' 10^{'+a+'}$')
-                text = text.replace('e-0', 'e-').replace('e+','e')
                 a = int(text.split('10^{')[1].split('}')[0])
                 if abs(a) < min_exp:
                     y = RichValue(x, dx, is_lolim, is_uplim,
@@ -962,7 +1004,8 @@ class RichValue():
                     text = y.latex(*kwargs)
                 if (not use_extra_sf_in_exacts and omit_ones_in_sci_notation
                      and dx[0] == dx[1] and dx[0] == 0 or np.isnan(dx[0])):
-                    text = text.replace('1 {} '.format(mult_symbol), '')
+                    if '.' not in text:
+                        text = text.replace('1 {} '.format(mult_symbol), '')
             else:
                 x1 = RichValue(main - unc[0], domain=domain)
                 x2 = RichValue(main + unc[1], domain=domain)
@@ -1452,6 +1495,11 @@ class RichValue():
     @minimum_exponent_for_scientific_notation.setter
     def minimum_exponent_for_scientific_notation(self, x): self.min_exp = x
     
+    @property
+    def maximum_number_of_decimals(self): return self.max_dec
+    @maximum_number_of_decimals.setter
+    def maximum_number_of_decimals(self, x): self.max_dec = x
+    
     @property
     def limit_for_extra_significant_figure(self): return self.extra_sf_lim
     @limit_for_extra_significant_figure.setter
@@ -1642,6 +1690,9 @@ class RichArray(np.ndarray):
     def min_exps(self):
         return np.array([x.min_exp for x in self.flat]).reshape(self.shape)
     @property
+    def max_decs(self):
+        return np.array([x.max_dec for x in self.flat]).reshape(self.shape)
+    @property
     def extra_sf_lims(self):
         return np.array([x.extra_sf_lim for x in self.flat]).reshape(self.shape)
     @property
@@ -1660,6 +1711,12 @@ class RichArray(np.ndarray):
     def are_consts(self):
         return np.array([x.is_const for x in self.flat]).reshape(self.shape)
     @property
+    def are_nans(self):
+        return np.array([x.is_nan for x in self.flat]).reshape(self.shape)
+    @property
+    def are_infs(self):
+        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) 
     @property
@@ -1738,6 +1795,7 @@ class RichArray(np.ndarray):
         abbreviations = {'is integer': 'is_int',
                          'number of significant figures': 'num_sf',
                          'minimum exponent for scientific notation': 'min_exp',
+                         'maximum number of decimals': 'max_dec',
                          'limit for extra significant figure': 'extra_sf_lim'}
         attributes = ['domain'] + list(abbreviations.values()) 
         for entry in abbreviations:
@@ -1757,6 +1815,8 @@ class RichArray(np.ndarray):
                 x.num_sf = params['num_sf']
             if 'min_exp' in params:
                 x.min_exp = params['min_exp']
+            if 'max_dec' in params:
+                x.max_dec = params['max_dec']
             if 'extra_sf_lim' in params:
                 x.extra_sf_lim = params['extra_sf_lim']
     
@@ -1799,8 +1859,7 @@ class RichArray(np.ndarray):
         return np.array(self).mean()
     
     def std(self):
-        std_function = lambda u: (np.sum((u - u.mean())**2)
-                                  / len(self - 1))**0.5
+        std_function = lambda u: (np.sum((u-u.mean())**2)/(len(self)-1))**0.5
         return self.function(std_function)
 
     # Attribute acronyms.
@@ -1812,11 +1871,14 @@ class RichArray(np.ndarray):
     are_integers = are_ints
     numbers_of_significant_figures = nums_sf
     minimum_exponents_for_scientific_notation = min_exps
+    maximum_number_of_decimals = max_decs
     limits_for_extra_significant_figure = extra_sf_lims
     are_limits = are_lims
     are_intervals = are_intervs
     are_centereds = are_centrs
     are_constants = are_consts
+    are_not_a_number = are_nans
+    are_infinites = are_infs
     relative_uncertainties = rel_uncs
     signals_to_noises = signals_noises
     amplitudes = ampls
@@ -1905,6 +1967,8 @@ class RichDataFrame(pd.DataFrame):
     @property
     def min_exps(self): return self._property('min_exps')
     @property
+    def max_decs(self): return self._property('max_decs')
+    @property
     def extra_sf_lims(self): return self._property('extra_sf_lims')
     @property
     def are_lims(self): return self._property('are_lims')
@@ -1917,6 +1981,10 @@ class RichDataFrame(pd.DataFrame):
     @property
     def are_consts(self): return self._property('are_consts')
     @property
+    def are_nans(self): return self._property('are_nans')
+    @property
+    def are_infs(self): return self._property('are_infs')
+    @property
     def centers(self): return self._property('centers')
     @property
     def rel_uncs(self): return self._property2('rel_uncs')
@@ -1964,6 +2032,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',
                          'limit for extra significant figure': 'extra_sf_lim'}
         attributes = ['domain'] + list(abbreviations.values())
         for entry in abbreviations:
@@ -1984,6 +2053,7 @@ class RichDataFrame(pd.DataFrame):
         set_is_int = 'is_int' in params
         set_num_sf = 'num_sf' in params
         set_min_exp = 'min_exp' in params
+        set_max_dec = 'max_dec' in params
         set_extra_sf_lim = 'extra_sf_lim' in params
         row_inds = self.index
         for col in self:
@@ -2002,6 +2072,9 @@ class RichDataFrame(pd.DataFrame):
                 if set_min_exp and col in params['min_exp']:
                     for i in row_inds:
                         self[col][i].min_exp = params['min_exp'][col]
+                if set_max_dec and col in params['max_dec']:
+                    for i in row_inds:
+                        self[col][i].max_dec = params['max_dec'][col]
                 if set_extra_sf_lim and col in params['extra_sf_lim']:
                     for i in row_inds:
                         self[col][i].extra_sf_lim = params['extra_sf_lim'][col]
@@ -2060,7 +2133,8 @@ class RichDataFrame(pd.DataFrame):
         new_row = pd.DataFrame(new_row, idex=[0])
         return new_row
 
-    def latex(self, return_df=False, row_sep='\\tabularnewline', **kwargs):
+    def latex(self, return_df=False, export_frame=True, export_index=True,
+              row_sep='\\tabularnewline', **kwargs):
         """Return the content of the dataframe as a table in LaTeX format."""
         row_sep = ' ' + row_sep + ' \n'
         df = copy.copy(self)
@@ -2075,17 +2149,35 @@ class RichDataFrame(pd.DataFrame):
         if return_df:
             output = df
         else:
+            columns = list(df.columns)
+            num_columns = len(columns)
             text = ''
+            if export_frame:
+                text += '\\renewcommand*{\\arraystretch}{1.4}' + ' \n'
+                text += ('\\begin{tabular}{' + 'l'*export_index
+                         + num_columns*'c' + '}' + ' \n')
+                text += '\\hline \n'
+            columns = ['{\\bf ' + column + '}' for column in columns]
+            index_name = df.index.name if df.index.name is not None else ' '
+            if export_index:
+                columns = ['{\\bf ' + index_name + '}'] + columns
+            if export_frame:
+                text += ' & '.join(columns) + row_sep + '\\hline \n'
             rows = []
-            for (i,row) in df.iterrows():
-                cols = []
+            for (ind,row) in df.iterrows():
+                cols = [str(ind)] if export_index else []
                 for (j,column) in enumerate(df):
                     entry = str(row[column])
                     if entry == 'nan':
                         entry = '...'
                     cols += [entry]
                 rows += [' & '.join(cols)]
-            text = row_sep.join(rows)
+            text += row_sep.join(rows)
+            if export_frame:
+                text += row_sep
+                text += '\\hline \n'
+                text += '\\end{tabular}' + ' \n'
+                text += '\\renewcommand*{\\arraystretch}{1.0}' + ' \n'
             output = text
         return output
 
@@ -2118,6 +2210,8 @@ class RichDataFrame(pd.DataFrame):
     are_intervals = are_intervs
     are_centereds = are_centrs
     are_constants = are_consts
+    are_not_a_number = are_nans
+    are_infinites = are_infs
     relative_uncertainties = rel_uncs
     signals_to_noises = signals_noises
     amplitudes = ampls
@@ -2171,6 +2265,9 @@ class RichSeries(pd.Series):
     def min_exps(self):
         return pd.Series(self.values.view(RichArray).min_exps, self.index)
     @property
+    def max_decs(self):
+        return pd.Series(self.values.view(RichArray).max_decs, self.index)
+    @property
     def extra_sf_lims(self):
         return pd.Series(self.values.view(RichArray).extra_sf_lim, self.index)
     @property
@@ -2189,6 +2286,12 @@ class RichSeries(pd.Series):
     def are_consts(self):
         return pd.Series(self.values.view(RichArray).are_consts, self.index)
     @property
+    def are_nans(self):
+        return pd.Series(self.values.view(RichArray).are_nans, self.index)
+    @property
+    def are_infs(self):
+        return pd.Series(self.values.view(RichArray).are_infs, self.index)
+    @property
     def centers(self):
         return pd.Series(self.values.view(RichArray).centers, self.index)
     @property
@@ -2250,10 +2353,13 @@ class RichSeries(pd.Series):
     are_integers = are_ints
     numbers_of_scientific_figures = nums_sf
     minimum_exponents_for_scientific_notation = min_exps
+    maximum_numbers_of_decimals = max_decs
     are_limits = are_lims
     are_intervals = are_intervs
     are_centereds = are_centrs
     are_constants = are_consts
+    are_not_a_number = are_nans
+    are_infinites = are_infs
     relative_uncertainties = rel_uncs
     signals_to_noises = signals_noises
     amplitudes = ampls
@@ -2305,11 +2411,14 @@ class ComplexRichValue():
         
         num_sf = min(real.num_sf, imag.num_sf)
         min_exp = round(np.mean([real.min_exp, imag.min_exp]))
+        max_dec = min(real.max_dec, imag.max_dec)
         extra_sf_lim = min(real.extra_sf_lim, imag.extra_sf_lim)
         real.num_sf = num_sf
         imag.num_sf = num_sf
         real.min_exp = min_exp
         imag.min_exp = min_exp
+        real.max_dec = max_dec
+        real.max_dec = max_dec
         real.extra_sf_lim = extra_sf_lim
         imag.extra_sf_lim = extra_sf_lim
         
@@ -2352,16 +2461,21 @@ 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)  
+    @max_dec.setter
+    def max_dec(self, x):
+        self.real.max_dec = x
+        self.imag.max_dec = x
     
     @property
-    def extra_sf_lim(self): return max(self.real.extra_sf_lim,
-                                       self.imag.extra_sf_lim)
+    def extra_sf_lim(self): return max(self.real.extra_sf_lim, self.imag.extra_sf_lim)
     @extra_sf_lim.setter
     def extra_sf_lim(self, x):
         self.real.extra_sf_lim = x
@@ -2663,7 +2777,7 @@ def add_rich_values(x, y):
     is_int = x.is_int and y.is_int
     domain = [x.domain[0] + y.domain[0], x.domain[1] + y.domain[1]]
     sigmas = defaultparams['sigmas to use approximate uncertainty propagation']
-    if x.is_exact or y.is_exact:
+    if (x.is_exact or y.is_exact) and (x.is_interv or y.is_interv):
         z = list(np.array(x.interval()) + np.array(y.interval()))
         z = RichValue(z, domain=domain, is_int=is_int)
     elif (not (x.is_interv or y.is_interv)
@@ -2687,7 +2801,7 @@ def multiply_rich_values(x, y):
     is_int = x.is_int and y.is_int
     domain = propagate_domain(x.domain, y.domain, lambda a,b: a*b)
     sigmas = defaultparams['sigmas to use approximate uncertainty propagation']
-    if x.is_exact or y.is_exact:
+    if (x.is_exact or y.is_exact) and (x.is_interv or y.is_interv):
         z = list(np.array(x.interval()) * np.array(y.interval()))
         z = RichValue(z, domain=domain, is_int=is_int)
     elif (not (x.is_interv or y.is_interv)
@@ -2933,7 +3047,7 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
     def parse_as_rich_value(text):
         """Obtain the properties of the input text as a rich value."""
         def parse_value(text):
-            """Parse input text as a value."""
+            """Parse input text as a numeric value."""
             text = str(text)
             if any([char.isalpha() for char in text.replace(' e','')]):
                 for short_name in abbreviations:
@@ -2992,8 +3106,24 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
                 is_uplim, is_lolim = False, False
                 text = (text.replace('+-', '+/-').replace(' -', '-')
                         .replace(' +/-', '+/-').replace('+/- ', '+/-'))
-                if '+/-' in text:
-                    x_dx, e = text.split(' ')
+                x_dx, e = text.split(' ')
+                if ')' in text:
+                    if text.count(')') == 1:
+                        x, dx = x_dx.split('(')
+                        dx = dx[:-1]
+                        dx1, dx2 = dx
+                    else:
+                        x, dx1, dx2 = x_dx.split('(')
+                        dx1 = dx1[:-1]
+                        dx2 = dx2[:-1]
+                        if dx1.startswith('+'):
+                            dx1, dx2 = dx2, dx1
+                        dx1 = dx1[1:]
+                        dx2 = dx2[1:]
+                    d = len(x.split('.')[1]) if '.' in x else 0
+                    dx1 = '{:f}'.format(float(dx1)*10**(-d))
+                    dx2 = '{:f}'.format(float(dx2)*10**(-d))
+                elif '+/-' in text:
                     x, dx = x_dx.split('+/-')
                     text = '{}-{}+{} {}'.format(x, dx, dx, e)
                     dx1, dx2 = dx, dx
@@ -3014,10 +3144,9 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
                     else:
                         x = text.split(' ')[0]
                         dx1, dx2 = '0', '0'
-                e = text.split(' ')[1]
-                x = '{} {}'.format(x ,e)
-                dx1 = '{} {}'.format(dx1 ,e)
-                dx2 = '{} {}'.format(dx2 ,e)
+                x = '{} {}'.format(x, e)
+                dx1 = '{} {}'.format(dx1, e)
+                dx2 = '{} {}'.format(dx2, e)
             x = parse_value(x)
             dx1 = parse_value(dx1)
             dx2 = parse_value(dx2)
@@ -3070,7 +3199,7 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
             unc = 0
             is_lolim, is_uplim, is_range = False, False, True
             min_exp = round(np.mean([me1, me2]))
-            extra_sf_lim = min(el1, el2)
+            extra_sf_lim = max(el1, el2)
         return (main, unc, is_lolim, is_uplim, is_range, domain,
                 min_exp, extra_sf_lim)
     
@@ -3203,7 +3332,7 @@ def rich_array(array, domain=None, is_int=None,
     rarray = RichArray(mains, uncs, are_lolims, are_uplims, are_ranges,
                        domains, are_ints, variables, expressions)
     min_exp = round(np.mean(min_exps))
-    extra_sf_lim = min(extra_sf_lims)
+    extra_sf_lim = max(extra_sf_lims)
     rarray.set_params({'min_exp': min_exp, 'extra_sf_lim': extra_sf_lim})
     return rarray
 
@@ -3272,8 +3401,10 @@ def rich_dataframe(df, domains=None, are_ints=None,
                         domain = defaultparams['domain']
                     if is_int is None:
                         is_int = defaultparams['assume integers']
-                    entry = rich_value(text, domain, is_int,
-                                       use_default_extra_sf_lim)
+                    try:
+                        entry = rich_value(text, domain, is_int, use_default_extra_sf_lim)
+                    except:
+                        entry = text
             if is_rich_value or is_number:
                 df.at[i,col] = entry
     rdf = RichDataFrame(df)
@@ -3582,7 +3713,7 @@ def loguniform_distribution(low=-1, high=1, size=1,
     return distr
 
 def distr_with_rich_values(function, args, len_samples=None,
-                           is_vectorizable=False):
+                           is_vectorizable=False, **kwargs):
     """
     Same as function_with_rich_values, but just returns the final distribution.
     """
@@ -3688,7 +3819,7 @@ def remove_zero_infs(interval, zero_log, inf_log):
     return new_interval
 
 def evaluate_distr(distr, domain=None, function=None, args=None,
-            len_samples=None, is_vectorizable=False, consider_intervs=True,
+            len_samples=None, is_vectorizable=False, consider_intervs=None,
             is_domain_cyclic=False, lims_fraction=None, num_reps_lims=None,
             save_pdf=None, **kwargs):
     """
@@ -3774,10 +3905,17 @@ def evaluate_distr(distr, domain=None, function=None, args=None,
         return tuple(all_vars)
     
     if args is not None:
+        if type(args) is np.ndarray:
+            args = [rich_value(arg) for arg in args]
         if type(args) not in (tuple, list):
             args = [args]
-        args = [rich_value(arg) if type(arg) not in
-                (RichValue, ComplexRichValue) else arg for arg in args]
+        if type(args[0]) is not RichArray:
+            args = [rich_value(arg) if type(arg) not in
+                    (RichValue, ComplexRichValue) else arg for arg in args]
+    if consider_intervs is None:
+        consider_intervs = True
+        if args is not None and all([arg.is_centr for arg in args]):
+            consider_intervs = False
         
     distr = np.array(distr)
     
@@ -4076,6 +4214,7 @@ def function_with_rich_values(function, args, unc_function=None,
         args = [args]
     args = [rich_value(arg) if type(arg) not in (RichValue, ComplexRichValue)
             else arg for arg in args]
+    args_copy = copy.copy(args)
     
     input_function = copy.copy(function)
     if type(function) is str:
@@ -4119,7 +4258,7 @@ def function_with_rich_values(function, args, unc_function=None,
             
     if len_samples is None:
         len_samples = int(len(args)**0.5 * defaultparams['size of samples'])
-    num_sf = min([arg.num_sf for arg in args])
+    num_sf = int(np.median([arg.num_sf for arg in args]))
     min_exp = round(np.mean([arg.min_exp for arg in args]))
     extra_sf_lim = max([arg.extra_sf_lim for arg in args])
     
@@ -4136,9 +4275,6 @@ def function_with_rich_values(function, args, unc_function=None,
             use_analytic_propagation = False
     
     args_main = np.array([arg.main for arg in args])
-    # print()
-    # print(args)
-    # print(args[0].expression)
     with np.errstate(divide='ignore', invalid='ignore'):
         main = function(*args_main)
     output_size = np.array(main).size
@@ -4224,16 +4360,14 @@ def function_with_rich_values(function, args, unc_function=None,
         
         mains = [main] if output_size == 1 else main
         if unc_function is not None:
-            args_unc = [np.array(arg.unc) for arg in args]
-            uncs = unc_function(*args_main, *args_unc)
+            uncs = []
+            args_main = np.array([arg.main for arg in args_copy])
+            for i in (0,1):
+                args_unc = [arg.unc[i] for arg in args_copy]
+                uncs += [unc_function(*args_main, *args_unc)]
             uncs = [uncs] if output_size == 1 else uncs
-            if output_size > 1:
-                for k in range(output_size):
-                    if not hasattr(uncs[k], '__iter__'):
-                        uncs[k] = [uncs[k]]*2
-                    uncs[k][1] = abs(uncs[k][1])
-            if not hasattr(uncs,'__iter__'):
-                uncs = [uncs]*output_size
+            for k in range(output_size):
+                uncs[k][1] = abs(uncs[k][1])
         else:
             inds_combs = list(itertools.product(*[[0,1,2]]*len(args)))
             comb_main = tuple([1]*len(args))
@@ -4261,6 +4395,9 @@ def function_with_rich_values(function, args, unc_function=None,
                 real_k = RichValue(main_k.real, unc_k.real, domain=domain_k)
                 imag_k = RichValue(main_k.imag, unc_k.imag, domain=domain_k)
                 rval_k = ComplexRichValue(real_k, imag_k)
+            rval_k.num_sf = num_sf
+            rval_k.min_exp = min_exp
+            rval_k.extra_sf_lim = extra_sf_lim
             output += [rval_k]
             
     else:
@@ -4336,6 +4473,43 @@ def function_with_rich_arrays(function, args, elementwise=False, **kwargs):
     output : rich array / rich value
         Result of the function.
     """
+    if 'domain' in kwargs:
+        domain = kwargs['domain']
+        del kwargs['domain']
+    else:
+        domain = None
+    distr = distr_with_rich_arrays(function, args, elementwise, **kwargs)
+    if len(distr.shape) == 1:
+        output = evaluate_distr(distr, domain, function, args, **kwargs)
+    else:
+        output_size = distr.shape[1]
+        output = []
+        for k in range(output_size):
+            function_k = lambda *args: function(args)[k]
+            rval_k = evaluate_distr(distr[:,k], domain, function_k, **kwargs)
+            output += [rval_k]
+        if type(args) not in (tuple, list):
+            args = [args]
+        for (i,arg) in enumerate(args):
+            if type(arg) is not RichArray:
+                args[i] = RichArray(arg)
+        args_mains = [arg.mains for arg in args]
+        if type(function) is not str:
+            with np.errstate(divide='ignore', invalid='ignore'):
+                main = function(*args_mains)
+        else:
+            main = distr[0,:]
+        output_type = RichArray if type(main) is np.ndarray else type(main)
+        if output_type is tuple and output_size > 1:
+            output = tuple(output)
+        elif output_type is RichArray:
+            output = np.array(output).view(RichArray)
+    return output
+
+def distr_with_rich_arrays(function, args, elementwise=False, **kwargs):
+    """
+    Same as function_with_rich_arrays, but just returns the final distribution.
+    """
     if type(args) not in (tuple, list):
         args = [args]
     args = [rich_array(arg) if type(arg) != RichArray else arg
@@ -4351,6 +4525,8 @@ def function_with_rich_arrays(function, args, elementwise=False, **kwargs):
     if 'len_samples' not in kwargs:
         kwargs['len_samples'] = int(len(args)**0.5
                                     * defaultparams['size of samples'])
+    if 'consider_intervs' in kwargs:
+        del kwargs['consider_intervs']
     if elementwise:
         same_shapes = True
         for arg in args[1:]:
@@ -4359,16 +4535,14 @@ def function_with_rich_arrays(function, args, elementwise=False, **kwargs):
                 break
         if not same_shapes:
             raise Exception('Input arrays have different shapes.')
-        array = np.empty(0, RichValue)
+        distr = []
         args_flat = np.array([arg.flatten() for arg in args])
         for i in range(args[0].size):
             args_i = np.array(args_flat)[:,i].tolist()
-            rvalue = function_with_rich_values(function, args_i, **kwargs)
-            array = np.append(array, rvalue)
-        if shape == ():
-            array = np.array(array[0])
-        array = array.view(RichArray)
-        output = array
+            distr_i = distr_with_rich_values(function, args_i, **kwargs)
+            distr += [distr_i]
+        distr = np.array(distr).T
+        output = distr
     else:
         if type(function) is str:
             variables = list(np.concatenate(tuple(arg.variables for arg in args)))
@@ -4410,7 +4584,7 @@ def function_with_rich_arrays(function, args, elementwise=False, **kwargs):
             alt_args = []
             for arg in args:
                 alt_args += list(arg.flat)
-        output = function_with_rich_values(alt_function, alt_args, **kwargs)
+        output = distr_with_rich_values(alt_function, alt_args, **kwargs)
     return output
 
 def fmean(array, function='None', inverse_function='None',
@@ -4524,12 +4698,12 @@ def errorbar(x, y, lims_factor=None, **kwargs):
     xa, ya = rich_array(x), rich_array(y)
     xc = rich_array([x]) if len(xa.shape) == 0 else xa
     yc = rich_array([y]) if len(ya.shape) == 0 else ya
-    if lims_factor is None:
-        lims_factor_x, lims_factor_y = None, None
-    elif type(lims_factor) in (float, int):
+    if type(lims_factor) in (float, int):
         lims_factor_x, lims_factor_y = [lims_factor]*2
     elif type(lims_factor) in (list, tuple):
         lims_factor_x, lims_factor_y = lims_factor
+    else:
+        lims_factor_x, lims_factor_y = None, None
     if lims_factor_x is None:
         lims_factor_x = lim_factor(xc)
     if lims_factor_y is None:
@@ -4884,6 +5058,10 @@ def _log10(x):
         y = np.log10(x)
     return y
 
+# Abbreviations from NumPy.
+inf = np.inf
+nan = np.nan
+
 # Functions for masking arrays.
 def isnan(x):
     x = rich_array(x) if type(x) is not RichArray else x
@@ -4979,6 +5157,7 @@ rich_df = rdataframe = rich_dataframe
 function = function_with_rich_values
 array_function = function_with_rich_arrays
 distribution = distr_with_rich_values
+array_distribution = distr_with_rich_arrays
 evaluate_distribution = evaluate_distr
 center_and_uncertainties = center_and_uncs
 is_not_a_number = is_nan = isnan

{richvalues-4.0.5 → richvalues-4.1.0}/richvalues.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: richvalues
-Version: 4.0.5
+Version: 4.1.0
 Summary: Python library for working with uncertainties and upper/lower limits
 Home-page: https://github.com/andresmegias/richvalues/
 Author: Andrés Megías Toledano
@@ -15,7 +15,7 @@ License-File: LICENSE
 
 RichValues is a Python 3 library for working with numeric values with uncertainties, upper/lower limits and finite intervals, which may be called _rich values_. 
 
-With it, one can import rich values written in plain text documents in an easily readable format, operate with them propagating the uncertainties automatically, and export them in the same formatting style as the import. It also allows to easily plot rich values and to make fits to any function, taking into account the uncertainties and the upper/limits or finite intervals. Moreover, correlations between variables are taken into account when performing calculations with rich values. 
+With it, one can import rich values written in plain text documents in an easily readable format, operate with them propagating the uncertainties automatically, and export them in the same formatting style as the import. It also allows to easily plot rich values and to make fits to any function, taking into account the uncertainties and the upper/lower limits or finite intervals. Moreover, correlations between variables are taken into account when performing calculations with rich values. 
 
 The libraries NumPy, Pandas, SciPy and Matplotlib are required by RichValues. A user guide and a quick tutorial are available on GitHub: https://github.com/andresmegias/richvalues/.
 

{richvalues-4.0.5 → richvalues-4.1.0}/richvalues.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 pyproject.toml
 setup.py
 richvalues/__init__.py
-richvalues.egg-info/.DS_Store
 richvalues.egg-info/PKG-INFO
 richvalues.egg-info/SOURCES.txt
 richvalues.egg-info/dependency_links.txt

{richvalues-4.0.5 → richvalues-4.1.0}/setup.py

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