readme

Author: mbruno46

README.md

@@ -19,11 +19,11 @@ If you use this library in your publications please consider citing:
 
 * U. Wolff, [Monte Carlo errors with less errors](https://inspirehep.net/literature/621085). *Comput.Phys.Commun.* 156 (2004) 143-153.
 * S. Schaefer, R. Sommer, F. Virotta, [Critical slowing down and error analysis in lattice QCD simulations](https://inspirehep.net/literature/871175). *Nucl.Phys.B* 845 (2011) 93-119.
-* M. Bruno, R. Sommer, In preparation.
+* M. Bruno, R. Sommer, [On fits to correlated and auto-correlated data](https://inspirehep.net/literature/2157883) *Comput.Phys.Commun.* 285 (2023) 108643.
 
 ### Authors
 
-Copyright (C) 2020-2021, Mattia Bruno
+Copyright (C) 2020-2023, Mattia Bruno
 
 ## Installation
 
@@ -45,8 +45,7 @@ help(pyobs.observable)
 
 The library can also be installed from a local clone of
 the repository in *developer mode*, as described in the 
-documentation. Recompilation of the C++ extensions might 
-be necessary in this case.
+documentation. 
 
 ## Example
 

scripts/generate-unary.py

@@ -0,0 +1,79 @@
+dest='pyobs/tensor/unary.py'
+
+ops = {
+    "log": ['Natural logarithm', 'logarithm', 'numpy.log', 'numpy.reciprocal'],
+    "exp": ['exponential', 'exponential', 'numpy.exp', 'numpy.exp'],
+    "sin": ['sine', 'sine', 'numpy.sin', 'numpy.cos'],
+    "arcsin": ['Inverse sine', 'arcsine', 'numpy.arcsin', 'lambda x: (1-x*x)**(-0.5)'],
+    "cos": ['cosine', 'cosine', 'numpy.cos', 'lambda x: -numpy.sin(x)'],
+    "arccos": ['Inverse sine', 'arcsine', 'numpy.arcsin', 'lambda x: -(1-x*x)**(-0.5)'],
+    "tan": ['tangent', 'tangent', 'numpy.tan', 'lambda x: 1 / numpy.cos(x) ** 2'],
+    "arctan": ['inverser tangent', 'arctangent', 'numpy.arctan', 'lambda x: 1 / (1 + x*x)'],
+    "cosh": ['Hyperbolic cosine', 'hyperbolic cosine', 'numpy.cosh', 'numpy.sinh'],
+    "arccosh": ['inverse Hyperbolic cosine', 'inverse hyperbolic cosine', 'numpy.arccosh', 'lambda x: (x*x - 1)**(-0.5)'],
+    "sinh": ['Hyperbolic sine', 'hyperbolic sine', 'numpy.sinh', 'numpy.cosh'],
+    "arcsinh": ['inverse Hyperbolic sine', 'inverse hyperbolic sine', 'numpy.arcsinh', 'lambda x: (x*x + 1)**(-0.5)'],
+}
+
+
+def make_py(key, l):
+    return f'''
+def {key}(x):
+    """
+    Return the {l[0]} element-wise.
+
+    Parameters:
+       x (obs): input observable
+
+    Returns:
+       obs : the {l[1]} of the input observable, element-wise.
+
+    Examples:
+       >>> y = pyobs.{key}(x)
+    """
+    return __unary(x, {l[2]}, {l[3]})
+
+'''
+
+with open(dest,'w') as f:
+    f.write("""#################################################################################
+#
+# unary.py: definitions of unary operations
+# Copyright (C) 2020-2023 Mattia Bruno
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+#################################################################################
+import pyobs
+import numpy
+
+def __unary(x, f, df):
+    new_mean = f(x.mean)
+    aux = df(x.mean)
+    g = pyobs.gradient(lambda xx: xx * aux, x.mean, gtype="diag")
+    return pyobs.derobs([x], new_mean, [g])
+
+""")
+            
+    f.write('\n\n')
+            
+    all = '__all__ = ['
+    for key in ops:
+        all += f'"{key}",'
+    all += '\n]\n\n'
+    f.write(all)
+            
+    for key in ops:
+        f.write(make_py(key, ops[key]))

tests/tensor/unary_special.py

@@ -0,0 +1,50 @@
+import pyobs
+import numpy
+import scipy
+
+T=32
+L=16
+mass=0.25
+p=0.0
+
+xax=range(T//2)
+corr_ex = [pyobs.qft.free_scalar.Cphiphi(x,mass,p,T,L)+2.0 for x in xax]
+cov_ex = pyobs.qft.free_scalar.cov_Cphiphi(mass,p,T,L)[0:T//2,0:T//2]
+
+N=1000
+tau=2.0
+rng = pyobs.random.generator('unary')
+data = rng.markov_chain(corr_ex,cov_ex/N,tau,N)
+
+corr = pyobs.observable()
+corr.create(f'm{mass:g}-{L}x{T}', data.flatten(), shape=(len(xax),))
+print(corr)
+[c,dc] = corr.error()
+
+mat = pyobs.reshape(corr/corr.mean[0]/1.01, (T//8,T//8))
+print(mat)
+flist = pyobs.tensor.unary.__all__
+flist.remove('arccosh')
+
+for f in flist:
+    [v0, e0] = pyobs.__dict__[f](mat).error()
+    mean = numpy.__dict__[f](mat.mean)
+    g = pyobs.num_grad(mat, numpy.__dict__[f])
+    g0 = pyobs.gradient(g)
+    [v1, e1] = pyobs.derobs([mat], mean, [g0]).error()
+    assert numpy.all(numpy.fabs(e1-e0) < 2e-9)
+    
+mat = pyobs.reshape(corr, (T//8,T//8))
+flist = ['besselk']
+slist = ['kv']
+args = [1.0]
+
+for i in range(len(flist)):
+    [v0, e0] = pyobs.__dict__[flist[i]](args[i], mat).error()
+    f = lambda x: scipy.special.__dict__[slist[i]](args[i], x)
+    mean = f(mat.mean)
+    g = pyobs.num_grad(mat, f)
+    g0 = pyobs.gradient(g)
+    [v1, e1] = pyobs.derobs([mat], mean, [g0]).error()
+    assert numpy.all(numpy.fabs(e1-e0) < 1e-10)
+