rt method added to observable class; remove_tensor will be deprecated; internal types cleanup

Author: mbruno46

pyobs/core/data.py

@@ -26,8 +26,7 @@
 
 
 def is_int(x):
-    return isinstance(x, (int, np.int32, np.int64))
-
+    return pyobs.is_type(x, pyobs.types.INT)
 
 def expand_data(data, idx, shape):
     v = np.prod(shape)

pyobs/core/ndobs.py

@@ -134,11 +134,11 @@ def create(self, ename, data, icnfg=None, rname=None, shape=(1,), lat=None):
             self.ename.append(ename)
 
         pyobs.check_type(data, "data", list, np.ndarray)
-        if isinstance(data[0], (int, np.int32, np.int64)):
+        if pyobs.is_type(data[0], pyobs.types.INT):
             data = [np.array(data).astype(pyobs.int)]
-        elif isinstance(data[0], (float, np.float32, np.float64)):
+        elif pyobs.is_type(data[0], pyobs.types.FLOAT):
             data = [np.array(data).astype(pyobs.double)]
-        elif isinstance(data[0], (complex, np.complex64, np.complex128)):
+        elif pyobs.is_type(data[0], pyobs.types.COMPLEX):
             data = [np.array(data).astype(pyobs.complex)]
         else:
             pyobs.assertion(True, "Data type not supported")
@@ -147,11 +147,11 @@ def create(self, ename, data, icnfg=None, rname=None, shape=(1,), lat=None):
         nc = [len(data[ir]) // self.size for ir in range(R)]
         if rname is None:
             rname = list(range(R))
-        elif isinstance(rname, (str, int, np.int32, np.int64)):
+        elif pyobs.is_type(rname, str, pyobs.types.INT):
             rname = [rname]
         if icnfg is None:
             icnfg = [range(_nc) for _nc in nc]
-        elif isinstance(icnfg[0], (int, np.int32, np.int64)):
+        elif pyobs.is_type(icnfg[0], pyobs.types.INT):
             icnfg = [icnfg]
 
         pyobs.check_type(rname, "rname", list)
@@ -409,7 +409,7 @@ def f(x):
         return transform(self, f)
 
     def __getitem__(self, args):
-        if isinstance(args, (int, np.int32, np.int64, slice, np.ndarray)):
+        if pyobs.is_type(args, pyobs.types.INT, slice, np.ndarray):
             args = [args]
         na = len(args)
         pyobs.assertion(na == len(self.shape), "Unexpected argument")
@@ -420,12 +420,12 @@ def f(x):
         return transform(self, f)
 
     def __setitem__(self, args, yobs):
-        if isinstance(args, (int, np.int32, np.int64, slice, np.ndarray)):
+        if pyobs.is_type(args, pyobs.types.INT, slice, np.ndarray):
             args = [args]
         else:
             args = [
                 [a]
-                if isinstance(a, (int, np.int32, np.int64, slice, np.ndarray))
+                if pyobs.is_type(a, pyobs.types.INT, slice, np.ndarray)
                 else a
                 for a in args
             ]
@@ -454,6 +454,41 @@ def __setitem__(self, args, yobs):
             )
             self.cdata[key].assign(submask, yobs.cdata[key])
 
+    def rt(self, axis=None):
+        """
+        Removes trivial tensor indices reducing the dimensionality of the observable.
+
+        Parameters:
+           axis (int, list or array): axis to be considered for tensor removal.
+
+        Returns:
+           observable
+
+        Examples:
+           >>> obs.shape
+           (10, 3, 1)
+           >>> obs.rt().shape
+           (10, 3)
+        """
+        ## duplicate of pyobs.remove_tensor, to be eventually deprecated
+        Nd = len(self.shape)
+        if axis is None:
+            selection = [True] * Nd
+        else:
+            selection = [False] * Nd
+            for a in pyobs.to_list(axis):
+                selection[a] = True
+                
+        new_shape = []
+        for mu in range(Nd):
+            if (self.shape[mu] == 1) and (selection[mu] is True):
+                continue
+            new_shape.append(self.shape[mu])
+        if not new_shape:
+            new_shape.append(1)
+        return pyobs.reshape(self, tuple(new_shape))
+        
+            
     ##################################
     # overloaded basic math operations
 
@@ -654,14 +689,18 @@ class provides additional details for the automatic or manual
            >>> einfo = {'A': errinfo(Stau=3.0), 'B': errinfo(W=30)}
            >>> [v,e] = obsC.error(errinfo=einfo,plot=True)
         """
-        [sigma, sigma_tot, _] = self.error_core(errinfo, plot, pfile)
-
-        if plot:  # pragma: no cover
-            h = [len(self.ename), len(self.cdata)]
-            if sum(h) > 1:
-                plot_piechart(self.description, sigma, sigma_tot.real)
-
-        return [self.mean, np.sqrt(sigma_tot)]
+        def error_real(obs):
+            [sigma, sigma_tot, _] = obs.error_core(errinfo, plot, pfile)
+
+            if plot:  # pragma: no cover
+                h = [len(obs.ename), len(obs.cdata)]
+                if sum(h) > 1:
+                    plot_piechart(obs.description, sigma, sigma_tot.real)
+            return sigma_tot
+        
+        if np.iscomplexobj(self.mean):
+            return [self.mean, np.sqrt(error_real(self.real())) + 1j*np.sqrt(error_real(self.imag()))]        
+        return [self.mean, np.sqrt(error_real(self))]
 
     def error_breakdown(self, errinfo={}):
         """

pyobs/default.py

@@ -19,15 +19,22 @@
 #
 #################################################################################
 
-import numpy
+import numpy as np
 import functools
 import time
 
-__all__ = ["is_verbose", "set_verbose", "log_timer", "complex", "double", "int"]
+__all__ = [
+    "is_verbose", 
+    "set_verbose", 
+    "log_timer", 
+    "complex", 
+    "double", 
+    "int",
+]
 
-complex = numpy.complex128
-double = numpy.float64
-int = numpy.int32
+complex = np.complex128
+double = np.float64
+int = np.int32
 
 verbose = ["save", "load", "mfit"]
 
@@ -46,7 +53,6 @@ def set_verbose(func, yesno=True):
         if func in verbose:
             verbose.remove(func)
 
-
 def log_timer(tag):
     def decorator(func):
         @functools.wraps(func)

pyobs/tensor/manipulate.py

@@ -74,7 +74,7 @@ def remove_tensor(x, axis=None):
        (10, 3)
     """
     Nd = len(x.shape)
-    if isinstance(axis, int):
+    if pyobs.is_type(axis, pyobs.types.INT):
         axis = [axis]
     if axis is None:
         selection = [True] * Nd

pyobs/utils.py

@@ -1,7 +1,7 @@
 #################################################################################
 #
 # utils.py: generic utility routines
-# Copyright (C) 2020 Mattia Bruno
+# Copyright (C) 2020-2025 Mattia Bruno
 #
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
@@ -30,13 +30,16 @@
     "PyobsError",
     "assertion",
     "check_type",
+    "types",
+    "is_type",
     "valerr",
     "tex_table",
     "slice_ndarray",
     "import_string",
     "array",
     "double_array",
     "int_array",
+    "to_list",
 ]
 
 
@@ -161,6 +164,13 @@ def check_type(obj, s, *t):
     if c == len(t):
         raise TypeError(f"Unexpected type for {s} [{t}]")
 
+class types:
+    INT = (int, numpy.int32, numpy.int64)
+    FLOAT = (float, numpy.float32, numpy.float64)
+    COMPLEX = (complex, numpy.complex64, numpy.complex128)
+
+def is_type(x, *args):
+    return isinstance(x, args)
 
 def slice_to_range(sl, n):
     return list(range(n)[sl])
@@ -203,7 +213,7 @@ def slice_ndarray(t, *args):
                 aa.append(range(s[ia]))
             else:
                 aa.append(a)
-        elif isinstance(a, (int, numpy.int32, numpy.int64)):
+        elif pyobs.is_type(a, pyobs.types.INT):
             aa.append([a])
         else:  # pragma: no cover
             raise PyobsError("slicing not understood")
@@ -233,3 +243,8 @@ def core(string):
         out = [core(s) for s in data]
         return numpy.array(out)
     return core(data)
+
+def to_list(x):
+    if numpy.isdim(x)==0:
+        return [x]
+    return list(x)

tests/core/complex.py

@@ -22,7 +22,9 @@
 obsA_i = pyobs.observable()
 obsA_i.create('a', data_i, shape=(2,))
 
-print(obsA_r, obsA_i)
+print(obsA_r.error())
+print(obsA_i.error())
+print(obsB.error())
 
 def check(A,B):
     b, db = B.error()

tests/core/slice.py

@@ -62,7 +62,7 @@
 obsB.create('B',data)
 [vB, eB] = obsB.error()
 
-obsC = pyobs.remove_tensor(pyobs.stack([obsA,obsB]))
+obsC = pyobs.stack([obsA,obsB]).rt()
 obsC.peek()
 [v,e] = obsC[0].error()
 assert abs(vA - v) < 1e-12