richvalues 4.2.26__tar.gz → 4.2.28__tar.gz

{richvalues-4.2.26/richvalues.egg-info → richvalues-4.2.28}/PKG-INFO

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

{richvalues-4.2.26 → richvalues-4.2.28}/pyproject.toml

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

{richvalues-4.2.26 → richvalues-4.2.28}/richvalues/__init__.py

@@ -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.26'
+__version__ = '4.2.28'
 __author__ = 'Andrés Megías Toledano'
 
 import copy
@@ -61,10 +61,11 @@ defaultparams = {
     'maximum number of decimals to use parentheses': 5,
     'limit for extra significant figure': 2.5,
     'use extra significant figure for exact values': True,
+    'use extra significant figure for upper/lower limits': True,
     'use extra significant figure for integers': True,
     'omit ones in scientific notation in LaTeX': False,
     'always show inferior and superior uncertainties': False,
-    'multiplication symbol for scientific notation in LaTeX': '\\cdot',
+    'multiplication symbol for scientific notation in LaTeX': r'\cdot',
     'sigmas to define upper/lower limits from read values': 3.,
     'decimal exponent to define zero': -90.,
     'decimal exponent to define infinity': 90.,
@@ -273,8 +274,13 @@ def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
                 else:
                     mantissa_dy, exp_dy = dy, '0'
                 m = len(mantissa_dy.split('.')[1]) if '.' in dy else 0
-                mantissa_y = ('{:.{}f}'.format(float(mantissa_y)*10**(-d), m)
+                mantissa_y = ('{:.{}f}'.format(float(mantissa_y), m)
                               if x != 0 else '0')
+                if float(mantissa_y) == 10.:
+                    exp_dy = int(exp_dy) + 1
+                    exp_y = exp_dy
+                    mantissa_y = '{:.{}f}'.format(float(mantissa_y)/10, m+1)
+                    mantissa_dy = '{:.{}f}'.format(float(mantissa_dy)/10, m+1)
                 y = '{}e{}'.format(mantissa_y, exp_dy)
             else:
                 f = 10**(-int(exp_y))
@@ -282,9 +288,6 @@ def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
                                                np.inf, max_dec, extra_sf_lim)
                 y = '{}e{}'.format(mantissa_y, exp_y)
             dy = '{}e{}'.format(mantissa_dy, exp_y)
-            if len(dy) > len(y)+1:
-                min_exp = np.inf
-                y, dy = round_sf_unc(x, dx, n, min_exp, max_dec, extra_sf_lim)
     elif dx == 0:
         y = round_sf(x, n, min_exp, extra_sf_lim)
         dy = '0e0'
@@ -297,7 +300,7 @@ def round_sf_unc(x, dx, n=None, min_exp=None, max_dec=None, extra_sf_lim=None):
         y = y.replace('e0','')
         dy = dy.replace('e0','')
     else:
-        if not np.isinf(x):
+        if np.isfinite(x):
             if not 'e' in y:
                 y = '{:e}'.format(float(y))
             exp = int(y.split('e')[1]) if 'e' in y else 0
@@ -475,9 +478,11 @@ class RichValue():
             integer, so when creating samples it will have integer values.
         """
         
+        input_main = copy.copy(main)
         input_domain = copy.copy(domain)
         domain = set_default_value(domain, 'domain')
-        possible_kwargs = ['main_value', 'center', 'uncertainty', 'is_integer',
+        possible_kwargs = ['nominal', 'center', 'rel_unc', 'main_value'
+                           'uncertainty', 'relative_uncertainty', 'is_integer',
                            'is_lower_limit', 'is_upper_limit', 'is_finite_range',
                            'num_sf', 'min_exp', 'max_dec', 'extra_sf_lim']
         for kwarg in kwargs:
@@ -486,8 +491,20 @@ class RichValue():
                                 + " '{}'".format(kwarg))
         if 'main_value' in kwargs:
             main = kwargs['main_value']
+        elif 'nominal' in kwargs:
+            main = kwargs['nominal']
+        elif 'center' in kwargs:
+            main = kwargs['center']
+            is_uplim, is_lolim, is_range = False, False, False
+        if main is None:
+            raise TypeError("RichValue() missing required argument 'main'"
+                            + " (first argument)")
         if 'uncertainty' in kwargs:
             unc = kwargs['uncertainty']
+        elif 'relative_uncertainty' in kwargs or 'rel_unc' in kwargs:
+            rel_unc = (kwargs['rel_unc'] if 'rel_unc' in kwargs
+                       else kwargs['relative_uncertainty'])
+            unc = np.array(rel_unc) * main
         if 'is_upper_limit' in kwargs:
             is_uplim = kwargs['is_upper_limit']
         if 'is_lower_limit' in kwargs:
@@ -498,12 +515,6 @@ class RichValue():
             is_int = kwargs['is_integer']
         if 'show_both_uncertainties' in kwargs:
             show_both_uncs = kwargs['show_both_uncertainties']
-        if 'center' in kwargs:
-            main = kwargs['center']
-            is_uplim, is_lolim, is_range = False, False, False
-        if main is None:
-            raise TypeError("RichValue() missing required argument 'main'"
-                            + " (first argument)")
             
         num_sf = (kwargs['num_sf'] if 'num_sf' in kwargs
                   else defaultparams['number of significant figures'])
@@ -610,7 +621,7 @@ class RichValue():
             main = np.nan
             unc = [np.nan]*2
     
-        if type(main) in [list, tuple]:
+        if type(main) is list:
             is_lolim, is_uplim, is_range = False, False, False
             if main[0] > main[1]:
                 raise ValueError('Upper edge of interval must be greater or'
@@ -649,7 +660,8 @@ class RichValue():
                     else:
                         main = np.nan
                         unc = [np.nan]*2   
-        
+
+        main = float(main)
         if np.isnan(main):
             is_uplim, is_lolim, is_range = False, False, False
         if is_lolim or is_uplim:
@@ -727,8 +739,11 @@ class RichValue():
             else:
                 main = (x1 + x2) / 2
                 unc = [(x2 - x1) / 2] * 2
-            
-        main = float(main)
+        if is_range and not np.array_equal(input_main, [main-unc[0], main+unc[1]]):
+            main = input_main
+            if is_int:
+                x1, x2 = main
+                main = [int(x1), int(x2)]
 
         global variable_count
         if domain[0] != domain[1]:
@@ -760,11 +775,14 @@ class RichValue():
         variable_dict[expression] = self
         
     def __setattr__(self, name, value):
-        descriptors = ['main', 'unc', 'is_uplim', 'is_lolim', 'is_range',
-                       'is_int', 'domain']
+        descriptors = ['main', 'unc', 'is_uplim', 'is_lolim',
+                       'is_range', 'is_int', 'domain']
         internals = ['pdf_info', 'variables', 'expression']
         display_options = ['num_sf', 'min_exp', 'max_dec', 'extra_sf_lim',
                            'show_both_uncs']
+        if name == 'rel_unc':
+            self.unc = value * self.main
+            return
         if name in internals:
             raise AttributeError(f'Cannot modify attribute {name}.')
             return
@@ -778,9 +796,16 @@ class RichValue():
                             value = int(value) if self.is_int else float(value)
                         else:
                             super().__setattr__('unc', [np.nan]*2)
+                    elif isinstance(value, (list, tuple, np.ndarray)):
+                        main = (value[0] + value[1]) / 2
+                        unc = [main - value[0], value[1] - main]
+                        super().__setattr__('unc', unc)
+                        super().__setattr__('is_range', True)
+                        value = main
                     else:
                         raise TypeError('Wrong type for attribute main.')
-                elif name == 'unc' and isinstance(value, (int, float, np.integer, np.floating)):
+                elif name == 'unc' and isinstance(value,
+                                        (int, float, np.integer, np.floating)):
                     if value < 0:
                         raise ValueError('Uncertainty cannot be negative.')
                     value = float(abs(value))
@@ -788,28 +813,37 @@ class RichValue():
                 elif name in ('unc', 'domain'):
                     if isinstance(value, (tuple, list)):
                         if len(value) != 2:
-                            raise ValueError(f'Wrong number of elements for attribute {name}.')
+                            raise ValueError(f'Wrong number of elements for'
+                                             f' attribute {name}.')
                         else:
-                            if not (isinstance(value[0], (int, float, np.integer, np.floating))
-                                    and isinstance(value[1], (int, float, np.integer, np.floating))):
-                                raise TypeError(f'Wrong type for elements of attribute {name}.')
+                            if not (isinstance(value[0],
+                                        (int, float, np.integer, np.floating))
+                                    and isinstance(value[1],
+                                       (int, float, np.integer, np.floating))):
+                                raise TypeError(f'Wrong type for elements of'
+                                                f' attribute {name}.')
                             value = [float(value[0]), float(value[1])]
                     elif isinstance(value, np.ndarray):
                         if value.size > 2:
-                            raise ValueError(f'Too many elements for attribute {name}.')
+                            raise ValueError(f'Too many elements for'
+                                             f' attribute {name}.')
                         else:
                             value = value.flatten().tolist()
-                            if not (isinstance(value[0], (int, float, np.integer, np.floating))
-                                    and isinstance(value[1], (int, float, np.integer, np.floating))):
-                                raise TypeError('Wrong type for elements of attribute {name}.')
+                            if not (isinstance(value[0],
+                                         (int, float, np.integer, np.floating))
+                                    and isinstance(value[1],
+                                       (int, float, np.integer, np.floating))):
+                                raise TypeError('Wrong type for elements of'
+                                                f' attribute {name}.')
                     else:
                         raise TypeError(f'Wrong type for attribute {name}.')
                     if name == 'unc':
                         if value[1] < 0:
-                            raise ValueError('Superior uncertainty cannot be negaive.')
+                            raise ValueError('Superior uncertainty cannot be'
+                                             ' negaive.')
                         elif value[0] == 0. != value[1] or value[1] == 0. != value[0]:
-                            raise ValueError('Superior and inferior uncertainties must be'
-                                             ' either both zero or both non-zero.')
+                            raise ValueError('Superior and inferior uncertainties'
+                                     ' must be either both zero or both non-zero.')
                         value[0] = abs(value[0])
                         if any(np.isinf(value)) or any(np.isnan(value)):
                             value = [np.nan]*2
@@ -886,6 +920,22 @@ class RichValue():
         else:
             raise AttributeError('Wrong attribute for RichValue class.')
          
+    def __getattribute__(self, name):
+        if name in ('main', 'unc'):
+            self_main = self.__dict__['main']
+            if type(self_main) is list:
+                main = (self_main[0] + self_main[1]) / 2
+                if name == 'main':
+                    value = main
+                else:
+                    unc = [main - self_main[0], self_main[1] - main]
+                    value = unc
+            else:
+                value = super().__getattribute__(name)
+        else:
+            value = super().__getattribute__(name)
+        return value
+         
     @property
     def is_lim(self):
         """Upper/lower limit."""
@@ -1063,7 +1113,8 @@ class RichValue():
             elif self.is_lolim:
                 interv = [self.main, self.domain[1]]
             elif self.is_range:
-                interv = [self.main - self.unc[0], self.main + self.unc[1]]
+                interv = (self.__dict__['main'] if type(self.__dict__['main']) is list
+                          else [self.main - self.unc[0], self.main + self.unc[1]])
             else:
                 interv = [np.nan, np.nan]
         if self.is_int:
@@ -1208,6 +1259,8 @@ class RichValue():
         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_lims = \
+            defaultparams['use extra significant figure for upper/lower limits']
         use_extra_sf_in_ints = \
             defaultparams['use extra significant figure for integers']
         unc = self.unc
@@ -1238,6 +1291,13 @@ class RichValue():
                     if '.' not in y_:
                         y, (dy1, dy2) = y_, (dy1_, dy2_)
                         num_sf += 1
+                if self.is_int:
+                    if '.' in y:
+                        y = str(round(float(y)))
+                    if '.' in dy1:
+                        dy1 = str(round(float(dy1)))
+                    if '.' in dy2:
+                        dy2 = str(round(float(dy2)))
                 if 'e' in y:
                     y, a = y.split('e')
                     a = int(a)
@@ -1265,6 +1325,8 @@ class RichValue():
                 if not use_exp:
                     text = text.replace(' e0','')
             else:
+                if use_extra_sf_in_lims:
+                    num_sf += 1
                 y = round_sf(x, num_sf, min_exp, extra_sf_lim)
                 if use_extra_sf_in_ints and '.' not in y and y.endswith('0'):
                     y_ = round_sf(x, num_sf+1, min_exp, extra_sf_lim)
@@ -1304,7 +1366,7 @@ class RichValue():
         elif not self.is_range and np.isnan(self.main):
             text = 'nan'
         else:
-            x1, x2 = self.main - unc[0], self.main + unc[1]
+            x1, x2 = self.interval()
             if self.is_int:
                 x1 = np.ceil(x1)
                 x2 = np.floor(x2)
@@ -1317,19 +1379,50 @@ class RichValue():
                 x.__dict__['extra_sf_lim'] = extra_sf_lim
                 x.__dict__['range_bound'] = True
             while str(x1) == str(x2):
-                x1.num_sf = x1.num_sf + 1
-                x2.num_sf = x2.num_sf + 1
+                x1.num_sf += 1
+                x2.num_sf += 1
                 num_sf += 1
+            if '.' in str(x1) and '.' not in str(x2):
+                while '.' not in str(x2):
+                    x2.num_sf += 1
             text = '{} -- {}'.format(x1, x2)
+            if ' e' in text:
+                exp1 = int(str(x1).split(' e')[1]) if 'e' in str(x1) else 0
+                exp2 = int(str(x2).split(' e')[1]) if 'e' in str(x2) else 0
+                exp = round((exp1 + exp2) / 2)
+                if ((abs(exp2-exp) < min_exp//2) and (abs(exp-exp1) < min_exp//2)
+                        and abs(exp) >= min_exp):
+                    x1.main /= 10**exp
+                    x2.main /= 10**exp
+                    x1.min_exp = np.inf
+                    x2.min_exp = np.inf
+                    if '.' in str(x1) and '.' not in str(x2):
+                        while '.' not in str(x2):
+                            x2.num_sf += 1
+                    text = '({} -- {}) e{}'.format(x1, x2, exp)
         if show_domain and self.domain[0] != self.domain[1] and not range_bound:
             text += ' [{}, {}]'.format(self.domain[0], self.domain[1])
         return text
         
     def __repr__(self):
+        text = self._format_as_rich_value()
         if self.is_exact:
-            return self.center.__format__('')
-        else:
-            return self._format_as_rich_value()
+            text_ = text.split(' [')[0] if '[' in text else text
+            text_ = text_.replace(' e', 'e')
+            if '.' in text_ and float(text_) != self.main:
+                if ' e' in text:
+                    mantissa, exp = text.split(' ')
+                    text = f'{mantissa}... {exp}'
+                else:
+                    text += '...'
+            else:
+                if float(text_) != self.main:
+                    text = str(int(self.main))
+        elif self.is_lim:
+            text = text.replace('< ', '<').replace('> ', '>')
+        elif self.is_range and not text.startswith('('):
+            text = text.replace(' e', 'e')
+        return text
     
     def __str__(self):
         return self._format_as_rich_value()
@@ -1351,16 +1444,25 @@ class RichValue():
                 char = '<' if self.is_uplim else '>'
                 text = char + self.main.__format__(format_spec)
             elif self.is_range:
-                x1 = self.main - self.unc[0]
-                x2 = self.main + self.unc[1]
+                x1, x2 = self.interval()
                 text = x1.__format__(format_spec) + ' -- ' + x2.__format__(format_spec)
             else:
                 text = str(self)
             return text
+        
+    def __round__(self, n=0):
+        rval = copy.copy(self)
+        rval.min_exp = 0
+        exp = int(repr(rval).split(' e')[1])
+        n += exp
+        rval.num_sf = n
+        rval.min_exp = np.inf
+        text = repr(rval)
+        return text
    
     def latex(self, show_dollars=True, mult_symbol=None,
-              use_extra_sf_in_exacts=None, use_extra_sf_in_ints=None,
-              omit_ones_in_sci_notation=None):
+              use_extra_sf_in_exacts=None, use_extra_sf_in_lims=None,
+              use_extra_sf_in_ints=None, omit_ones_in_sci_notation=None):
         """Display rich value in LaTeX format."""
         mult_symbol = set_default_value(mult_symbol,
                       'multiplication symbol for scientific notation in LaTeX')
@@ -1368,6 +1470,8 @@ class RichValue():
                                 'use extra significant figure for exact values')
         use_extra_sf_in_ints = set_default_value(use_extra_sf_in_ints,
                                     'use extra significant figure for integers')
+        use_extra_sf_in_lims = set_default_value(use_extra_sf_in_lims,
+                          'use extra significant figure for upper/lower limits')
         omit_ones_in_sci_notation = set_default_value(omit_ones_in_sci_notation,
                                     'omit ones in scientific notation in LaTeX')
         if not np.isfinite(self.main):
@@ -1430,6 +1534,8 @@ class RichValue():
                                               extra_sf_lim)
                         text = y + '_{-'+dy[0]+'}^{+'+dy[1]+'}'
                 else:
+                    if use_extra_sf_in_lims:
+                        num_sf += 1
                     y = round_sf(x, num_sf, min_exp, extra_sf_lim)
                     if use_extra_sf_in_ints and '.' not in y and y.endswith('0'):
                         y_ = round_sf(x, num_sf+1, min_exp, extra_sf_lim)
@@ -1496,9 +1602,11 @@ class RichValue():
                             text = (y + dy1 + dy2 + ' '
                                     + mult_symbol + ' 10^{'+a+'}')
                         else:
-                            text = (y + '_{-'+dy1+'}^{+'+dy2+'} '
-                                    + mult_symbol + ' 10^{'+a+'}')
+                            text = (r'\left(' + y + r'\,_{-'+dy1+'}^{+'+dy2+'}'
+                                    + r' \right)' + mult_symbol + ' 10^{'+a+'}')
                 else:
+                    if use_extra_sf_in_lims:
+                        num_sf += 1
                     if self.is_lolim:
                         symbol = '>'
                         y = int(np.floor(x)) if self.is_int and a > num_sf else x  
@@ -1530,7 +1638,7 @@ class RichValue():
                     if '.' not in text:
                         text = text.replace('1 {} '.format(mult_symbol), '')
             else:
-                x1, x2 = self.main - unc[0], self.main + unc[1]
+                x1, x2 = self.interval()
                 if self.is_int:
                     x1 = np.ceil(x1)
                     x2 = np.floor(x2)
@@ -1543,11 +1651,32 @@ class RichValue():
                     x.__dict__['extra_sf_lim'] = extra_sf_lim
                     x.__dict__['range_bound'] = True
                 while str(x1) == str(x2):
-                    x1.num_sf = x1.num_sf + 1
-                    x2.num_sf = x2.num_sf + 1
+                    x1.num_sf += 1
+                    x2.num_sf += 1
                     num_sf += 1
-                text = '{} -- {}'.format(x1.latex(show_dollars=False),
-                                         x2.latex(show_dollars=False))
+                if '.' in str(x1) and '.' not in str(x2):
+                    while '.' not in str(x2):
+                        x2.num_sf += 1
+                    text = r'{} \,{}\, {}'.format(x1.latex(show_dollars=False),
+                               r'\text{ --- }', x2.latex(show_dollars=False))
+                if ' e' in str(x):
+                    exp1 = int(str(x1).split(' e')[1]) if 'e' in str(x1) else 0
+                    exp2 = int(str(x2).split(' e')[1]) if 'e' in str(x2) else 0
+                    exp = round((exp1 + exp2) / 2)
+                    if ((abs(exp2-exp) <= min_exp//2) and (abs(exp-exp1) <= min_exp//2)
+                            and abs(exp) >= min_exp):
+                        x1.main /= 10**exp
+                        x2.main /= 10**exp
+                        x1.min_exp = np.inf
+                        x2.min_exp = np.inf
+                        if '.' in str(x1) and '.' not in str(x2):
+                            while '.' not in str(x2):
+                                x2.num_sf += 1
+                        text = r'({} \,{}\, {})'.format(x1.latex(show_dollars=False),
+                                              r'\text{---}', x2.latex(show_dollars))
+                        text += ' ' + mult_symbol + ' 10^{'+str(exp)+'}'
+                    elif ' e' in str(x1):
+                        text = text.replace(r' \,\text', r' \text')
         else:
             text = (str(self.main).replace('NaN','nan').replace('nan','...')
                     .replace('inf','\\infty'))
@@ -1859,6 +1988,10 @@ class RichValue():
                     domain = [-np.inf, np.inf]
                 rvalue = RichValue(x, dx, self.is_uplim, self.is_lolim,
                                      domain=domain, is_int=is_int)
+                min_exp = self.min_exp
+                num_sf = self.num_sf
+                max_dec = self.max_dec
+                extra_sf_lim = self.extra_sf_lim
             else:
                 other_ = other if type(other) is RichValue else RichValue(other)
                 domain = None
@@ -1870,10 +2003,14 @@ class RichValue():
                                                     [self, other_], domain=domain)
                 else:
                     rvalue = RichValue(0., 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
+                num_sf = int(np.mean([self.num_sf, other.num_sf]))
+                min_exp = round(np.mean([self.min_exp, other.min_exp]))
+                max_dec = round(np.mean([self.max_dec, other.max_dec]))
+                extra_sf_lim = max([self.extra_sf_lim, other.extra_sf_lim])
+            rvalue.num_sf = num_sf
+            rvalue.min_exp = min_exp
+            rvalue.max_dec = max_dec
+            rvalue.extra_sf_lim = extra_sf_lim
         else:
             vars_str = ','.join(variables)
             function = eval('lambda {}: {}'.format(vars_str, expression))
@@ -1983,22 +2120,7 @@ class RichValue():
                     if self.is_range:
                         sample_ = np.random.uniform(x1, x2, N)
                     elif np.isfinite(xrange):
-                        if self.is_uplim:
-                            # pdf = lambda x: truncated_normal_pdf(x,
-                            #                     self.domain[0],
-                            #                     (self.main - self.domain[0])/3,
-                            #                     [self.domain[0], self.main])
-                            # sample_ = sample_from_pdf(pdf, N,
-                            #                           [self.domain[0], self.main])
-                            sample_ = np.random.uniform(x1, x2, N)
-                        else:
-                            # pdf = lambda x: truncated_normal_pdf(x,
-                            #                     self.domain[1],
-                            #                     (self.domain[1] - self.main)/3,
-                            #                     [self.main, self.domain[1]])
-                            # sample_ = sample_from_pdf(pdf, N,
-                            #                           [self.main, self.domain[1]])
-                            sample_ = np.random.uniform(x1, x2, N)
+                        sample_ = np.random.uniform(x1, x2, N)
                         if N >= 20:
                             diffs = sample_ - x1
                             inds = np.argsort(diffs)
@@ -2038,6 +2160,11 @@ class RichValue():
     @main_value.setter
     def main_value(self, x): self.main = x
     
+    @property
+    def nominal(self): return self.nominal
+    @nominal.setter
+    def nominal(self, x): self.nominal = x
+    
     @property
     def uncertainty(self): return self.unc
     @uncertainty.setter
@@ -2114,27 +2241,49 @@ class RichArray(np.ndarray):
             corresponds to an integer variable. The default is False.
         """
         
-        acronyms = ['main_values', 'uncertainties', 'are_integers',
-                   'are_lower_limits', 'are_upper_limits', 'are_finite_ranges']
+        acronyms = ['nominals', 'centers', 'rel_uncs', 'main_values', 
+                    'uncertainties', 'relative_uncertainties', 'are_integers',
+                    'are_lower_limits', 'are_upper_limits', 'are_finite_ranges']
         for kwarg in kwargs:
             if kwarg not in acronyms:
                 raise TypeError("RichArray() got an unexpected keyword argument"
                                 + " '{}'".format(kwarg))
         if 'main_values' in kwargs:
             mains = kwargs['main_values']
+        elif 'nominals' in kwargs:
+            mains = kwargs['nominals']
+        elif 'centers' in kwargs:
+            mains = kwargs['centers']
+            are_uplims, are_lolims, are_ranges = False, False, False
         if mains is None:
-            raise TypeError("RichArray() missing required argument 'mains'"
-                            + " (pos 1)")
+            raise TypeError("RichValue() missing required argument 'mains'"
+                            + " (first argument)")
         if 'uncertainties' in kwargs:
             uncs = kwargs['uncertainties']
-        if 'are_lower_limits' in kwargs:
-            are_lolims = kwargs['are_lower_limits']
+        elif 'relative_uncertainties' in kwargs or 'rel_uncs' in kwargs:
+            rel_uncs = (kwargs['rel_uncs'] if 'rel_uncs' in kwargs
+                        else kwargs['relative_uncertainties'])
+            rel_uncs = np.array(rel_uncs)
+            mains = np.array(mains)
+            shape = mains.shape
+            if rel_uncs.size == 1:
+                rel_uncs = np.full((*shape, 2), rel_uncs).transpose()
+            elif len(rel_uncs) == 2 and type(rel_uncs[0]) is not np.ndarray:
+                rel_uncs = np.array([np.full(shape, rel_uncs[0]),
+                                     np.full(shape, rel_uncs[1])])
+            elif rel_uncs.shape == (*shape, 2):
+                rel_uncs = rel_uncs.transpose()
+            elif rel_uncs.shape == shape:
+                rel_uncs = np.array([[rel_uncs]]*2).reshape((2, *shape))
+            uncs = (rel_uncs * mains).transpose()
         if 'are_upper_limits' in kwargs:
-            are_uplims = kwargs['are_upper_limits']
-        if 'are_finite_ranges' in kwargs:
-            are_ranges = kwargs['are_finite_ranges']
-        if 'are_integers' in kwargs:
-            are_ints = kwargs['are_integers']
+            is_uplim = kwargs['are_upper_limits']
+        if 'are_lower_limits' in kwargs:
+            is_lolim = kwargs['are_lower_limits']
+        if 'are_finite_range' in kwargs:
+            is_range = kwargs['are_finite_ranges']
+        if 'are_integer' in kwargs:
+            is_int = kwargs['are_integers']
         
         mains = np.array(mains)
         shape = mains.shape
@@ -2373,6 +2522,17 @@ class RichArray(np.ndarray):
         return np.array([x.moments(n, central, standarized)
                                    for x in self.flat]).reshape(self.shape) 
     
+    def __setattr__(self, name, value):
+        alt_names = {'mains': 'main', 'uncs': 'unc', 'rel_uncs': 'rel_unc',
+                     'are_uplims': 'is_uplim', 'are_lolims': 'is_lolim',
+                     'are_ranges': 'is_range',  'nums_sf': 'num_sf',
+                     'min_exps': 'min_exp', 'max_decs': 'max_dec',
+                     'extra_sf_lims': 'extra_sf_lim'}
+        if name in alt_names.keys():
+            name = alt_names[name]
+        for x in self.flat:
+            setattr(x, name, value)
+    
     def set_params(self, params):
         """Set the rich value parameters of each entry of the rich array."""
         abbreviations = {'is integer': 'is_int',
@@ -2433,13 +2593,16 @@ class RichArray(np.ndarray):
         """Apply a function to the rich array."""
         return function_with_rich_arrays(function, self, **kwargs)
     
-    def mean(self):
-        return np.array(self).mean()
+    def mean(self, axis, dtype, out, **kwargs):
+        return np.array(self).mean(axis, dtype, out, **kwargs)
     
     def std(self):
         std_function = lambda u: (np.sum((u-u.mean())**2)/(len(self)-1))**0.5
-        return self.function(std_function)
-
+        return self.function(std_function)    
+    
+    def __str__(self):
+        text = np.array2string(self, separator=', ')
+        return text
 
     # Attribute synonims.
     main = mains
@@ -3411,7 +3574,8 @@ def add_rich_values(x, y):
     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]]
-    if (x.is_exact or y.is_exact) and (x.is_interv or y.is_interv):
+    if ((x.is_exact or y.is_exact) and (x.is_interv or y.is_interv)
+            or x.is_interv and 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)
@@ -3450,6 +3614,8 @@ def multiply_rich_values(x, y):
     else:
         z = function_with_rich_values(lambda a,b: a*b, [x, y], domain=domain,
                                       is_vectorizable=True)
+    if x.is_range and y.is_centered or x.is_centered and y.is_range:
+        z.is_range = True
     z.num_sf = num_sf
     z.min_exp = min_exp
     z.max_dec = max_dec
@@ -3503,6 +3669,10 @@ def divide_rich_values(x, y):
         else:
             z = function_with_rich_values(lambda a,b: a/b, [x, y], domain=domain,
                                           is_vectorizable=True)
+    if ((x.is_range and y.is_centered or x.is_centered and y.is_range)
+            and z.is_centered):
+        z.main = z.interval(3.)
+        # z.is_range = True
     z.num_sf = num_sf
     z.min_exp = min_exp
     z.max_dec = max_dec
@@ -3750,7 +3920,7 @@ def parse_as_rich_value(text, abbreviations={}, use_default_extra_sf_lim=False):
                         dx1 = x_dx.split('-')[1]
                     x = sign + x
                 else:
-                    x = _eval(x_dx)
+                    x = str(_eval(x_dx))
                     dx1, dx2 = '0', '0'
             if e != 'e0':
                 if 'e' in x:
@@ -3801,7 +3971,7 @@ def parse_as_rich_value(text, abbreviations={}, use_default_extra_sf_lim=False):
             if mantissa <= default_extra_sf_lim:
                 default_num_sf = defaultparams['number of significant figures']
                 if num_sf < default_num_sf + 1:
-                    extra_sf_lim = mantissa   
+                    extra_sf_lim = mantissa - 0.5
         x = x.replace('e0', '')
         main = _eval(x)
         unc = [_eval(dx1), _eval(dx2)]
@@ -3809,7 +3979,13 @@ def parse_as_rich_value(text, abbreviations={}, use_default_extra_sf_lim=False):
         min_exp = min(min_exp, default_min_exp)
     else:
         text = text.replace(' --','--').replace('-- ','--')
-        text1, text2 = text.split('--')
+        if text.startswith('('):
+            group, exp = text.split(' e')
+            text1, text2 = group[1:-1].split('--')
+            text1 += 'e'+exp
+            text2 += 'e'+exp
+        else:
+            text1, text2 = text.split('--')
         x1, _, _, _, _, _, me1, md1, el1 = parse_as_rich_value(text1,
                                        abbreviations, use_default_extra_sf_lim)
         x2, _, _, _, _, _, me2, md2, el2 = parse_as_rich_value(text2,
@@ -3877,6 +4053,11 @@ def rich_value(text=None, domain=None, is_int=None, pdf=None, support=None,
                         ' represent the rich value, not both.')
 
     input_domain = copy.copy(domain)
+    if type(input_domain) is str:
+        if input_domain in ('p', 'pos', 'positive'):
+            input_domain = [0., np.inf]
+        elif input_domain in ('n', 'neg', 'negative'):
+            input_domain = [-np.inf, 0.]
     abbreviations = {'inf': 'np.inf', 'tau': 'math.tau', 'pi': 'np.pi',
                      'nan': 'np.nan', 'NaN': 'np.nan', 'none': 'np.nan'}
     
@@ -5057,28 +5238,26 @@ def evaluate_sample(sample, function=None, args=None, len_samples=None,
                 if not is_range:
                     probs_hr, bins_hr = np.histogram(sample, bins=60, density=True)
                     probs_hr /= probs_hr.max()
-                    hr1f, hr2f, lrf, rf = 0.9, 0.8, 0.5, 0.4
-                    cond_hr1 = (probs_hr[0] > hr1f or probs_hr[-1] > hr1f)
-                    cond_hr2 = probs_hr[0] > hr2f
-                    is_lim = cond_hr1 or cond_hr2
+                    cond_hr = probs_hr[0] > 0.9 or probs_hr[-1] > 0.9
+                    is_lim = cond_hr and (x1 == domain[0] or x1 == domain[1])
                     if is_lim:
                         ord_range_b1 = magnitude_order_range([x1, median])
                         ord_range_b2 = magnitude_order_range([median, x2])
                         x1, x2 = add_zero_infs([x1, x2], zero_log-6, inf_log-6)
                         if (ord_range_b1 > inf_log-6 and ord_range_b2 > inf_log-6
-                                and cond_hr2):
+                                and cond_hr):
                             is_lim = False
                             is_nan = True
                     if not is_lim and not is_nan:
-                        cond_lr = lrf < probs_lr[0] < 1.
+                        cond_lr = 0.5 < probs_lr[0] < 1.
                         interval_1s = [np.quantile(sample, 0.15865),
                                        np.quantile(sample, 0.84135)]
                         ord_range_1s = magnitude_order_range(interval_1s)
                         ord_range_x = magnitude_order_range([x1, x2])
-                        cond_ord = (ord_range_x - ord_range_1s < rf if x1 != x2
+                        cond_ord = (ord_range_x - ord_range_1s < 0.4 if x1 != x2
                                     else False)
-                        is_range = (cond_ord or (not cond_ord and cond_hr2)
-                                    or (not cond_ord and not cond_hr2 and cond_lr))
+                        is_range = (cond_ord or (not cond_ord and cond_hr)
+                                    or (not cond_ord and not cond_hr and cond_lr))
                         if not is_range:
                             is_centered = True
         if is_lim and args is not None:
@@ -5143,7 +5322,7 @@ def evaluate_sample(sample, function=None, args=None, len_samples=None,
             x1, x2 = add_zero_infs([x1, x2], zero_log+6, inf_log-6)
             ampls = [x1 - domain[0], domain[1] - x2]
             rel_ampls = np.array(ampls) / (x2 - x1)
-            threshold = 0.01
+            threshold = 1e-9
             if rel_ampls[0] < threshold:
                 x1 = domain[0]
             if rel_ampls[1] < threshold:
@@ -5157,6 +5336,10 @@ def evaluate_sample(sample, function=None, args=None, len_samples=None,
     if is_centered:
         if not is_exact:
             main, unc = center_and_uncs(sample)
+            asymmetry = abs(unc[1] - unc[0]) / (unc[0] + unc[1])
+            threshold = min(0.05, 10. / np.sqrt(len_samples))
+            if asymmetry < threshold:
+                unc = (unc[0] + unc[1]) / 2
             rvalue = RichValue(main, unc, domain=domain, is_int=is_int)
         else:
             rvalue = RichValue(main, unc=0., domain=domain, is_int=is_int)
@@ -5307,6 +5490,7 @@ def function_with_rich_values(function, args, len_samples=None, domain=None,
             
     if len_samples is None:
         len_samples = int(len(args)**0.5 * defaultparams['size of samples'])
+    len_samples = int(len_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]))
@@ -6106,8 +6290,9 @@ def _log10(x):
 
 def _eval(text):
     """Evaluate a mathematical expression."""
-    y = eval(text, {'__builtins__': {}}, {'math': math, 'np': np,
-                                          'pi': math.pi, 'tau': math.tau})
+    y = eval(text, {'__builtins__': {}},
+             {'math': math, 'np': np, 'pi': math.pi, 'tau': math.tau,
+              'nan': np.nan})
     return y
 
 # Abbreviations from NumPy.
@@ -6134,9 +6319,9 @@ def concatenate(arrs, **kwargs):
 # Mathematical functions.
 get_operation_function = lambda x: (function if type(x) in
                         (str, RichValue, ComplexRichValue) else array_function)
-def sqrt(x):
+def sqrt(x, **kwargs):
     function_ = get_operation_function(x)
-    return function_('np.sqrt({})', x, domain=[0., np.inf])
+    return function_('np.sqrt({})', x, domain=[0., np.inf], **kwargs)
 def exp(x):
     function_ = get_operation_function(x)
     return function_('np.exp({})', x, domain=[0., np.inf])

{richvalues-4.2.26 → richvalues-4.2.28/richvalues.egg-info}/PKG-INFO

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

{richvalues-4.2.26 → richvalues-4.2.28}/setup.py

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