richvalues 4.2.0__tar.gz → 4.2.2__tar.gz

{richvalues-4.2.0 → richvalues-4.2.2}/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2023, Andrés Megías Toledano
+Copyright (c) 2025, Andrés Megías Toledano
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

{richvalues-4.2.0 → richvalues-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: richvalues
-Version: 4.2.0
+Version: 4.2.2
 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.0 → richvalues-4.2.2}/pyproject.toml

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

{richvalues-4.2.0 → richvalues-4.2.2}/richvalues/__init__.py

@@ -6,19 +6,19 @@ Rich Values Library
 -------------------
 Version 4.2
 
-Copyright (C) 2024 - Andrés Megías Toledano
+Copyright (C) 2025 - Andrés Megías Toledano
 
 Redistribution and use in source and binary forms, with or without
 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.0'
+__version__ = '4.2.2'
 __author__ = 'Andrés Megías Toledano'
 
 import copy
@@ -275,7 +275,8 @@ def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
                 y = '{}e{}'.format(base_y, exp_dy)
             else:
                 f = 10**(-int(exp_y))
-                base_y, base_dy = round_sf_unc(x*f, dx*f, n, np.inf, max_dec, extra_sf_lim)
+                base_y, base_dy = round_sf_unc(x*f, dx*f, n,
+                                               np.inf, max_dec, extra_sf_lim)
                 y = '{}e{}'.format(base_y, exp_y)
             dy = '{}e{}'.format(base_dy, exp_y)
             if len(dy) > len(y)+1:
@@ -311,7 +312,8 @@ def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
         else:
             exp = None
         d = len(y.split('.')[-1])
-        dy_ = round_sf(float(dy)*10**d, n, min_exp=np.inf, extra_sf_lim=0.)
+        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)
@@ -354,45 +356,48 @@ def round_sf_uncs(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
     dx1, dx2 = dx
     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)
-    if 'e' in y1 and 'e' not in y2 or 'e' in y2 and 'e' not in y1:
-        min_exp = 0
-        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, max_dec, extra_sf_lim)
-        y2, dy2 = round_sf_unc(x, dx2, n, min_exp, max_dec, extra_sf_lim)
+    if y1 == y2 and dy1 == dy2:
+        y = y1
     else:
-        diff = num_dec_1 - num_dec_2
-        off1, off2 = 0, 0
-        if num_dec_1 == 0 == num_dec_2:
-            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, 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:]
+        if 'e' in y1 and 'e' not in y2 or 'e' in y2 and 'e' not in y1:
+            min_exp = 0
+            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, 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:
+                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, 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
 
@@ -592,6 +597,15 @@ class RichValue():
             x = [x, x]
         x = list(x)
         self._unc = x
+        global variable_count
+        variable_count += 1
+        variable = 'x{}'.format(variable_count)
+        variables = [variable]
+        expression = variable
+        self.variables = variables
+        self.expression = expression
+        global variable_dict
+        variable_dict[expression] = self
          
     @property
     def is_lim(self):
@@ -618,11 +632,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)."""
@@ -649,7 +663,7 @@ class RichValue():
         else:
             s_n = [np.nan]*2
         return s_n
-    @property    
+    @property
     def ampl(self):
         """Amplitudes."""
         m, b = self.main, self.domain
@@ -675,14 +689,23 @@ class RichValue():
             s_a = [np.nan]*2
         return s_a
     @property
+    def unc_asymmetry(self):
+        """Asymmetry of the uncertainties, as its maximum ratio."""
+        if self.is_centr:
+            s1, s2 = np.abs(self.unc)
+            f = max(s1/s2, s2/s1)
+        return f
+    @property
     def prop_score(self):
-        """Minimum of the signals-to-noise and the relative amplitudes."""
+        """Propagation score, to determine the non-normal behaviour."""
         if self.is_exact:
             ps = np.inf
         elif self.is_centr:
             s_n = self.signal_noise
             a_s = self.rel_ampl
             ps = np.min([s_n, a_s])
+            f = self.unc_asymmetry
+            ps /= (1. + 8.*(f-1.))
         else:
             ps = 0.
         return ps
@@ -761,7 +784,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."""
@@ -817,7 +840,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
@@ -1071,7 +1094,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
@@ -1121,10 +1144,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')
@@ -1388,27 +1411,27 @@ class RichValue():
     
     def __floordiv__(self, other):
         type_other = str(type(other))
-        other_ = (RichValue(other, is_int=(type(other) is int))
+        other_ = (RichValue(other, is_int=('int' in str(type(other))))
                   if 'int' in type_other or 'float' in type_other else other)
         rvalue = function_with_rich_values('{}//{}', [self, other_])
         return rvalue
 
     def __rfloordiv__(self, other):
         type_other = str(type(other))
-        other_ = (RichValue(other, is_int=(type(other) is int))
+        other_ = (RichValue(other, is_int=('int' in str(type(other))))
                   if 'int' in type_other or 'float' in type_other else other)
         other_ = RichValue(other) if type(other) is not RichValue else other
         return other_ // self
 
     def __mod__(self, other):
         type_other = str(type(other))
-        other_ = (RichValue(other, is_int=(type(other) is int))
+        other_ = (RichValue(other, is_int=('int' in str(type(other))))
                   if 'int' in type_other or 'float' in type_other else other)
         domain = other_.interval(6.)
         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
@@ -1452,7 +1475,7 @@ class RichValue():
                 x = self.main ** other
                 dx = (np.abs(x * other * np.array(self.unc) / self.main)
                       if (x*other) != 0. else 0.)
-                is_int = self.is_int and type(other) is int
+                is_int = self.is_int and 'int' in str(type(other))
                 if domain != [-np.inf, np.inf]:
                     if domain[0] != 0 or (domain[0] == 0 and other>0):
                         x1 = domain[0] ** other
@@ -1519,11 +1542,11 @@ class RichValue():
             main = self.main
             unc = self.unc
             domain = copy.copy(self.domain)
-            if type(x) in (int, float):
+            if not hasattr(x, '__iter__'):
                 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]
@@ -1584,7 +1607,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)
@@ -1694,7 +1717,7 @@ class RichArray(np.ndarray):
     
     def __new__(cls, mains=None, uncs=None, are_lolims=None, are_uplims=None,
                 are_ranges=None, domains=None, are_ints=None,
-                variables=None, expressions=None, **kwargs):
+                variables=None, expressions=None, pdf_infos=None, **kwargs):
         """
         Parameters
         ----------
@@ -1823,6 +1846,8 @@ class RichArray(np.ndarray):
             if variables is not None and expressions is not None:
                 array[i].variables = variables[i]
                 array[i].expression = expressions[i]
+            if pdf_infos is not None:
+                array[i].pdf_info = pdf_infos[i]
         array = array.reshape(mains.shape)
         array = array.view(cls)
         return array
@@ -1832,17 +1857,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
@@ -1883,7 +1908,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])
@@ -1957,27 +1982,27 @@ 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."""
@@ -1986,7 +2011,7 @@ class RichArray(np.ndarray):
                          '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()) 
+        attributes = ['domain'] + list(abbreviations.values())
         for entry in abbreviations:
             name = abbreviations[entry]
             if entry in params:
@@ -2138,7 +2163,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')
@@ -2570,7 +2595,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
         """
@@ -2651,14 +2676,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
@@ -2698,7 +2723,7 @@ class ComplexRichValue():
     def main(self):
         """Main value."""
         x = self.real.main + 1j*self.imag.main
-        return x 
+        return x
 
     @property
     def unc(self):
@@ -2898,7 +2923,7 @@ class ComplexRichValue():
         is_other_real = (type(other) not in (RichValue, ComplexRichValue)
                          and 'complex' not in str(type(other)))
         if is_other_real:
-            is_int = type(other) is int
+            is_int = 'int' in str(type(other))
             other_ = RichValue(other, is_int=is_int)
             other_.variables = []
             other_.expression = str(other)
@@ -2918,7 +2943,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
@@ -3262,7 +3287,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:
@@ -3314,8 +3339,10 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
                         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))
+                    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)))
                 elif '+/-' in text:
                     x, dx = x_dx.split('+/-')
                     text = '{}-{}+{} {}'.format(x, dx, dx, e)
@@ -3370,11 +3397,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','')
@@ -3382,7 +3409,7 @@ 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('--')
@@ -3429,7 +3456,7 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None,
                 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)
@@ -3489,15 +3516,18 @@ def rich_array(array, domain=None, is_int=None,
     shape = array.shape
     mains, uncs, are_lolims, are_uplims, are_ranges, domains, are_ints = \
         [], [], [], [], [], [], []
-    min_exps, extra_sf_lims, variables, expressions = [], [], [], []
+    min_exps, extra_sf_lims, variables, expressions, pdf_infos = \
+        [], [], [], [], []
     for entry in array.flat:
         if type(entry) in (RichValue, ComplexRichValue):
             if domain is not None:
                 entry.domain = domain
             if is_int is not None:
                 entry.is_int = is_int
+            pdf_info = entry.pdf_info
         else:
             entry = rich_value(entry, domain, is_int, use_default_extra_sf_lim)
+            pdf_info = 'default'
         mains += [entry.main]
         uncs += [entry.unc]
         are_lolims += [entry.is_lolim]
@@ -3509,6 +3539,7 @@ def rich_array(array, domain=None, is_int=None,
         extra_sf_lims += [entry.extra_sf_lim]
         variables += [entry.variables]
         expressions += [entry.expression]
+        pdf_infos += [pdf_info]
     mains = np.array(mains).reshape(shape)
     uncs = np.array(uncs)
     uncs = (np.array([uncs[:,0].reshape(shape).tolist(),
@@ -3523,7 +3554,7 @@ def rich_array(array, domain=None, is_int=None,
                .transpose().reshape((*shape, 2)))
     are_ints = np.array(are_ints).reshape(shape)
     rarray = RichArray(mains, uncs, are_lolims, are_uplims, are_ranges,
-                       domains, are_ints, variables, expressions)
+                       domains, are_ints, variables, expressions, pdf_infos)
     min_exp = round(np.mean(min_exps))
     extra_sf_lim = max(extra_sf_lims)
     rarray.set_params({'min_exp': min_exp, 'extra_sf_lim': extra_sf_lim})
@@ -3608,6 +3639,28 @@ def rich_dataframe(df, domains=None, are_ints=None, ignore_columns=[],
     rdf = RichDataFrame(df)
     return rdf
 
+def gaussian(x, m=0., s=1.):
+    """
+    Parameters
+    ----------
+    x : array (float)
+        Independent variable.
+    m : float, optional
+        Mean of the curve. The default is 0.
+    s : float, optional
+        Standard deviation of the curve.
+        The default is 1.
+
+    Returns
+    -------
+    y : array (float)
+        Resulting array.
+    """
+    sqrt_tau = 2.50662827
+    y = np.exp(-0.5 * ((x-m) / s)**2)
+    y /= s * sqrt_tau
+    return y
+
 def bounded_gaussian(x, m=0., s=1., a=np.inf):
     """
     Bounded gaussian function.
@@ -3724,7 +3777,7 @@ def qsplitgaussian(x, m=0., s1=1., s2=1., num_points=1200, sigmas=8.,
         Resulting array.
     """
     alpha = 0.15865
-    if type(x) in (int, float):
+    if not hasattr(x, '__iter__'):
         x = [x]
     x = np.array(x)
     x_ = np.linspace(m - sigmas*s1, m + sigmas*s2, num_points)
@@ -3772,7 +3825,7 @@ def qgenextreme(x, m=0., s1=1., s2=1., num_points=800, sigmas=12.,
         Resulting array.
     """
     alpha = 0.15865
-    if type(x) in (int, float):
+    if not hasattr(x, '__iter__'):
         x = [x]
     x = np.array(x)
     x_ = np.linspace(m - s1*sigmas, m + s2*sigmas, num_points)
@@ -4120,7 +4173,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:
@@ -4146,6 +4199,8 @@ def distr_with_rich_values(function, args, len_samples=None,
     """
     Same as function_with_rich_values, but just returns the final distribution.
     """
+    len_samples = (int(len_samples) if len_samples is not None else
+                   int(len(args)**0.5 * defaultparams['size of samples']))
     if type(args) not in (tuple, list):
         args = [args]
     args = [rich_value(arg) if type(arg) not in (RichValue, ComplexRichValue)
@@ -4260,7 +4315,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
@@ -4371,8 +4426,16 @@ def evaluate_distr(distr, domain=None, function=None, args=None,
                     (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
+        if args is not None:
+            if type(args[0]) is RichValue:
+                all_args = [arg for arg in args]
+            elif type(args[0]) is RichArray:
+                all_args = []
+                for arg in args:
+                    for xi in arg:
+                        all_args += [xi]
+            if all([arg.is_centr for arg in all_args]):
+                consider_intervs = False
         
     distr = np.array(distr)
     
@@ -5042,6 +5105,7 @@ def distr_with_rich_arrays(function, args, elementwise=False, **kwargs):
             alt_args = []
             for arg in args:
                 alt_args += list(arg.flat)
+        distr = []
         output = distr_with_rich_values(alt_function, alt_args, **kwargs)
     return output
 
@@ -5156,7 +5220,7 @@ 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 type(lims_factor) in (float, int):
+    if not hasattr(lims_factor, '__iter__'):
         lims_factor_x, lims_factor_y = [lims_factor]*2
     elif type(lims_factor) in (list, tuple):
         lims_factor_x, lims_factor_y = lims_factor
@@ -5363,7 +5427,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.
@@ -5376,7 +5440,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.,
@@ -5453,7 +5517,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.
@@ -5696,4 +5760,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.0 → richvalues-4.2.2}/richvalues.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: richvalues
-Version: 4.2.0
+Version: 4.2.2
 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.0 → richvalues-4.2.2}/setup.py

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