quadlib 0.1.0__py3-none-any.whl

quadlib/legacy/math.py

@@ -0,0 +1,1337 @@
+# QuaDLib: QUAntum Dynamics LIBrary for research and methods development
+# Copyright (C) 2018-2026, The Theoretical Chemistry Group, Heidelberg University
+#
+# This software is licensed under the MIT License (https://spdx.org/licenses/MIT.html)
+
+"""
+Legacy utilities (formerly quadlib.tools.math); not used by the library.
+
+invert_reg, random_orthogonal_matrix, random_normal_columns_matrix moved
+to quadlib.tools.linalg; corrspec and fourierTransform to
+quadlib.tools.spectra. distributeMatrix/distributeMatrixList stay here;
+quadlib.tools.linalg.kron_list computes the same product with np.kron.
+
+ SECTIONS
+
+   - LINEAR ALGEBRA
+   - TENSOR ALGEBRA
+   - VECTORS in 3D SPACE
+   - INTERPOLATION
+   - NUMERICAL
+   - MONTE-CARLO
+   - OTHER
+   - internal functions
+"""
+
+
+import os
+import sys
+import random
+import math
+from math import sqrt, pi, sin, cos, asin, acos, exp
+
+import numpy as np
+try:
+    from scipy.integrate import simps
+except:
+    from scipy.integrate import simpson as simps
+
+import quadlib.tools.iterators as itr
+
+#import CDTK
+#from CDTK.Tools.Utils import ReverseArray, ShiftArray
+
+au2am = 0.00054857989586762
+
+##############################################################################
+#       --- LINEAR ALGEBRA: Matrix and vector related utilities ---
+##############################################################################
+
+def krylov(func,v,**opts):
+    """Construct a Krylov space
+
+    func    -- takes one vector as argument and returns the action of
+               the Hamiltonian matrix on that vector
+    v       -- Start vector for the construction of the Krylov space
+    argdict -- dictionary:
+                order: order (dimension) of the Krylov space to be constructed
+                kvecs : np.array, space to store the krylov vectors
+                kmat(order x order)  : space to store the krylov matrix
+                work : scratch array of length len(v)
+
+    Return the tridiagonal matrix, kmat, and a list of the vectors
+    spanning the Krylov space kvecs
+
+    Test: The condition K^* A K = t has been tested for this routine
+          using an Hermitian matrix 40x40 and a Krylov space 5x5
+          Orthonormality of the Kvecs was also tested
+          19.01.2007
+    """
+    n = len(v)
+    order = opts.get("order",10)
+    kvecs = opts.get("kvecs",None)
+    kmat = opts.get("kmat",None)
+    t = opts.get("work",None)
+    if not kvecs:
+        kvecs = np.zeros((order,n),type(v[0]))
+    if not kmat:
+        kmat = np.zeros((order,order),type(v[0]))
+    if not t:
+        t = np.zeros(n,type(v[0]))
+
+    # Normalize starting vector
+    kvecs[0] = v/(np.dot(v.conjugate(),v)**0.5)
+    a = 0.0
+    b = 0.0
+    for j in range(order):
+        # Calculate H(v) on the current vector
+        t[:] = func(kvecs[j])
+        if j > 0:
+            # Schmidt orthogonalize with respect to prev. prev. vector
+            t[:] = t - b*kvecs[j-1]
+        # Calculate diagonal term
+        a = np.dot(kvecs[j].conjugate(),t)
+        # Schmidt orthogonalize with respect to prev. vector
+        t[:] = t - a*kvecs[j]
+        # Calculate non-diagonal term
+        b = np.dot(t.conjugate(),t)**0.5
+        kmat[j,j] = a
+        if j < order-1:
+            kvecs[j+1] = (1./b)*t
+            kmat[j+1,j] = b
+            kmat[j,j+1] = b
+    return kmat,kvecs
+
+
+def ovrMatrix(vecs1,vecs2,nvecs,veclen,matrix):
+    """
+    Compute the overlap matrix between two lists of vectors
+
+    Parameters
+    ----------
+    vecs1 : array_like
+            must be conformable to shape=(nvecs,veclen)
+    vecs2 : array_like
+            must be conformable to shape=(nvecs,veclen)
+    nvecs : integer, number of vectors
+    veclen: integer, length of each vector
+    matrix: 2D array, output, overlap matrix
+    """
+    saveshape = vecs1.shape
+    vecs1.shape = (nvecs,veclen)
+    vecs2.shape = (nvecs,veclen)
+    for i,v2 in enumerate(vecs2):
+        for j,v1 in enumerate(vecs1):
+            matrix[j,i] = np.vdot(v1,v2)
+    vecs1.shape = saveshape
+    vecs2.shape = saveshape
+    return matrix
+
+def ovrMatrix2(vecs1,vecs2,nvecs1,nvecs2,veclen,matrix):
+    """
+    Compute the overlap matrix between two lists of vectors
+
+    Parameters
+    ----------
+    vecs1 : array_like
+            must be conformable to shape=(nvecs1,veclen1)
+    vecs2 : array_like
+            must be conformable to shape=(nvecs2,veclen2)
+    nvecs1 : integer, number of vectors in vecs1
+    nvecs2 : integer, number of vectors in vecs2
+    veclen: integer, length of each vector
+    matrix: 2D array, output, overlap matrix
+    """
+    saveshape1 = vecs1.shape
+    saveshape2 = vecs2.shape
+    vecs1.shape = (nvecs1,veclen)
+    vecs2.shape = (nvecs2,veclen)
+    for j,v1 in enumerate(vecs1):
+        for i,v2 in enumerate(vecs2):
+            matrix[j,i] = np.vdot(v1,v2)
+    vecs1.shape = saveshape1
+    vecs2.shape = saveshape2
+    return matrix
+
+
+# sort_eig, simul_diag and the Jacobi-sweep helpers now live in
+# quadlib.tools.linalg. Phase 1.4 will move the rest of this module's
+# linear-algebra surface there too.
+
+
+def distributeMatrix(mat1, mat2, oper='p'):
+    """
+    Given two square matrices that operate on spaces S1 and S2,
+    return a single matrix that operates on the direct product
+    space S = S1 x S2
+
+    mat1 -- square matrix n*n
+    mat2 -- square matrix m*m
+    oper -- 's' for summ or 'p' for product
+            whether the resulting matrices are summed or
+            matrix multiplied
+
+    Example:
+    Given the matrices:
+
+
+                  | 1  2  3  4|           |a b c|
+           mat1 = | 5  6  7  8|    mat2 = |d e f|
+                  | 9 10 11 12|           |g h i|
+                  |13 14 15 16|
+
+
+    The matrix of dimension 12 that operates on the product space is
+    generated from matrices A and B where
+
+         |   1     2     3     4     |        |a b c                  |
+         |     1     2     3     4   |        |d e f                  |
+         |       1     2     3     4 |        |g h i                  |
+         | 5       6     7     8     |        |      a b c            |
+         |   5       6     7     8   |        |      d e f            |
+    A =  |     5       6     7     8 |   B =  |      g h i            |
+         | 9      10    11    12     |        |            a b c      |
+         |   9      10    11    12   |        |            d e f      |
+         |     9      10    11    12 |        |            g h i      |
+         |13      14    15    16     |        |                  a b c|
+         |  13      14    15    16   |        |                  d e f|
+         |    13      14    15    16 |        |                  g h i|
+    """
+    n = len(mat1)
+    m = len(mat2)
+    nm = n*m
+    nmat1 = np.zeros((nm,nm),type(mat1[0,0]))
+    nmat2 = np.zeros((nm,nm),type(mat2[0,0]))
+    for k in range(nm):
+        for l in range(nm):
+            i = k%m
+            j = l%m
+            ii = int(k/m)
+            jj = int(l/m)
+            if i == j:
+                nmat1[k,l] = mat1[ii,jj]
+            if ii == jj:
+                nmat2[k,l] = mat2[i,j]
+    if oper == 's': return nmat1 + nmat2
+    if oper == 'p': return nmat1 @ nmat2
+
+def distributeMatrixList(ml, oper='p'):
+    M = ml[0]
+    for m in ml[1:]:
+        M = distributeMatrix(M, m, oper=oper)
+    return M
+
+def isPositiveDefinite(m):
+    """Return True if m is a positive-definite 2D matrix"""
+    if not isinstance(m, np.ndarray) or m.ndim != 2:
+        return False
+    try:
+        np.linalg.cholesky(m)
+    except np.linalg.LinAlgError:
+        return False
+    return True
+
+
+# invert_reg moved to quadlib.tools.linalg.
+
+
+def schroedinger_to_interaction(VS,H0,t):
+    """
+    Return interaction picture matrix VI using diagonal matrix H0
+
+    VI = exp(i*H0*t) VS exp(-i*H0*t)   Sakurai 5.5.7
+    """
+    exp_p = np.diag( np.exp( 1j*np.diag(H0)*t ) )
+    exp_m = np.diag( np.exp(-1j*np.diag(H0)*t ) )
+    return np.dot( exp_p, np.dot(VS,exp_m) )
+
+
+
+def svd(M, pad=False):
+    """
+    Return the SVD decomposition of matrix M
+
+    This is a thin wrap around numpy.linalg.svd. It pads the array of singular
+    values returned by svd, such that M is reproduced as
+    M = np.(np.dot(U, S), Vt)
+    """
+    u, s, vh = np.linalg.svd(M)
+    if pad:
+        dim = M.shape
+        padC = dim[1] - dim[0]
+        padR = -padC
+        if padC < 0: padC = 0
+        if padR < 0: padR = 0
+        S = np.pad(np.diag(s),((0,padR),(0,padC)),'constant',constant_values=((0,0),(0,0)))
+        return u, S, vh
+    else:
+        return u, s, vh
+
+
+# simul_diag, _sweep, _sum_diag2, _rotation_angles, _rank2_diagonalization
+# moved to quadlib.tools.linalg.
+
+
+# random_orthogonal_matrix moved to quadlib.tools.linalg.
+
+
+# random_normal_columns_matrix moved to quadlib.tools.linalg.
+
+
+##############################################################################
+#       --- VECTORS in 3D SPACE: vectors in cartesian space ---
+##############################################################################
+def eulerMatrix(a,b,c,inv=False):
+    """Return a 3x3 rotation matrix
+
+    xyz is the body fixed frame
+    XYZ is the space fixed frame
+    The normal convention (default) is the rotation XYZ -> xyz
+    First rotate around Z by an ammount of xhi, 
+    then around Y by an ammount of theta 
+    and finally around Z by an ammount of phi.
+    The theta and phi angles can also be seen as the two spherical angles
+    of a vector with respect to the Z vector.
+         phi       azimutal spherical angle (0,2pi)
+         theta     polar spherical angle (0,pi)
+    phi   -- rotation around Z axis
+    theta -- rotation around Y axis
+    xhi   -- rotation around Z axis
+
+    The inverse convention corresponds to xyz -> XYZ
+    The vector is rotated by the specified Euler angles that align it
+    with the space fixed frame.
+
+    Normal and Inverse conventions are inverse operations with respect to
+    each other
+    """
+    A=np.zeros((3,3),float)
+    B=np.zeros((3,3),float)
+    C=np.zeros((3,3),float)
+
+    A[0,0] = cos(a)
+    A[1,1] = cos(a)
+    A[2,2] = 1.0
+    B[0,0] = cos(b)
+    B[1,1] = 1.0
+    B[2,2] = cos(b)
+    C[0,0] = cos(c)
+    C[1,1] = cos(c)
+    C[2,2] = 1.0
+    if not inv:
+        A[0,1] = -sin(a)
+        A[1,0] = sin(a)
+        B[0,2] = sin(b)
+        B[2,0] = -sin(b)
+        C[0,1] = -sin(c)
+        C[1,0] = sin(c)
+        r=np.dot(np.dot(A,B),C)
+    else:
+        A[0,1] = sin(a)
+        A[1,0] = -sin(a)
+        B[0,2] = -sin(b)
+        B[2,0] = sin(b)
+        C[0,1] = sin(c)
+        C[1,0] = -sin(c)
+        r=np.dot(np.dot(C,B),A)
+    return r
+
+def alignMatrix(v,axis='z'):
+    """Return a 3x3 rotation matrix
+
+    Given a 3D vector, the routine returns a matrix that,
+    when multiplied by v, rotates it to the specified axis.
+    The routine computes the rotation axis around which the
+    rotation has to be performed, the angle that has to be
+    rotated, and then use the Rodrigues formula obtain the
+    desired rotation matrix.
+    """
+    if axis == 'x':
+        v1=np.array([1.,0.,0.])
+    elif axis == 'y':
+        v1=np.array([0.,1.,0.])
+    elif axis == 'z':
+        v1=np.array([0.,0.,1.])
+    else:
+        return np.zeros((3,3),float)
+    v2 = np.cross(v,v1)
+    if sqrt(np.dot(v2,v2)) < 1.e-8:
+        return np.identity(3,float)
+    cosphi = np.dot(v,v1)/sqrt(np.dot(v,v))
+    phi = acos(cosphi)
+    return rodriguesMatrix(v2,phi)
+
+def rodriguesMatrix(v,phi):
+    """Return a 3x3 rotation matrix
+
+    v -- 3D vector, the rotation axis (a copy will be
+         normalized in the routine)
+    phi -- ammount of rotation
+
+    Given the vector v=[v0,v1,v2] and an angle phi, it returns the
+    rotation matrix around that axis by the ammount phi.
+    The routine uses the Rodrigues Formula:
+
+    M = I + sin(phi)*A + (1-cos(phi))*A^2
+
+    where I is the unit matrix and A is given by:
+        |  0 -v2  v1|
+    A = | v2   0 -v0|
+        |-v1  v0   0|
+    """
+    vn = v/sqrt(np.dot(v,v))
+    id=np.identity(3,float)
+    a=np.zeros((3,3),float)
+    a[0,1]=-vn[2]
+    a[0,2]= vn[1]
+    a[1,0]= vn[2]
+    a[1,2]=-vn[0]
+    a[2,0]=-vn[1]
+    a[2,1]= vn[0]
+    aa=np.dot(a,a)
+    m = id + sin(phi)*a + (1-cos(phi))*aa
+    return m
+
+def pointsDistance(p,q):
+    """
+    Return the distance (Euclidean norm of connecting vector) between two points
+    p - vector or list
+    q - vector or list
+    """
+    d=0.0
+    for i in range(len(p)):
+        d = d + (p[i]-q[i])**2
+    return d**0.5
+
+def pointsVector(p,q):
+    """
+    Return the vector q ---> p (p-q) between points p and q
+    p - vector or list
+    q - vector or list
+
+    on return v is a list
+    """
+    v = []
+    for i in range(len(p)):
+        v.append(p[i]-q[i])
+    return v
+
+def sphericalAngles(v):
+    """
+    return the spherical angles theta(polar) and phi(azimutal) of v
+
+    v - 3D vector (x,y,z)
+    """
+    r=pointsDistance(v,[0.0,0.0,0.0])
+    theta = acos(v[2]/r)
+    rxy = r*sin(theta)
+    phi = acos(v[0]/rxy)
+    if v[1] < 0.0:
+            phi=2*pi-phi
+    return theta,phi
+
+##############################################################################
+#       --- INTERPOLATION on a regular grid ---
+##############################################################################
+def ndimIntGrid(xgrid1,ygrid1,xgrid2,intfunctions):
+    """Interpolate xgrid2 into the grid defined by xgrid1 and ygrid1
+
+    xgrid1 -- 2D list containing arrays or lists of the original coordinates
+    ygrid1 -- ND list or array containing the values of the function at
+              each point.
+      ygrid1[i1,i2,i3,...,in] = y( xgrid1[1,i1],xgrid1[2,i2],...,xgrid1[n,in] )
+
+    xgrid2 -- 2D list or array containing the arrays of the coordinates
+              to be interpolated.
+    intfunctions -- list containing the pointers to the functions that will handle
+                    the interpolation of each degree of freedom
+                    Each element of the list is also a list, the first
+                    element being the pointer and the rest the arguments
+                    expected by the interpolation routine, i.e.
+                    ((f1,op1a,op1b),(f2,op2a,op2b,op2c),...)
+    """
+    # declare the ygrid2 output array
+    # l contains the number of points in each dimension
+    l = []
+    for xvec in xgrid2:
+        l.append(len(xvec))
+    ygrid2 = np.zeros(l,float)
+
+    # loop over all the points in xgrid2 and interpolate
+    ygrid1a = np.array(ygrid1)
+    p = itr.MultiCounter()
+    p.setPointersN(0,len(l))
+    p.setMaxIter(l)
+    for ic in p:
+        i=0
+        xpoint = []
+        for xvec in xgrid2:
+            xpoint.append(xvec[ic[i]])
+            i = i+1
+        ygrid2[ic] = ndimIntPoint(xgrid1,ygrid1a,xpoint,intfunctions)
+    return ygrid2
+
+
+def ndimIntPoint(xgrid1,ygrid1,xpoint,intfunctions):
+    """Iterpolate xpoint into the grid defined by xgrid1 and ygrid1
+
+    xgrid1 -- 2D list containing arrays or lists of the original coordinates
+    ygrid1 -- ND np.array with the function values
+    xpoint -- list or array of the coordinates of the point to be
+              interpolated
+    intfunctions -- list with pointers to the functions that will handle
+                    the interpolation of each degree of freedom
+                    Each element of the list is also a list, the first
+                    element being the pointer and the rest the arguments
+                    expected by the interpolation routine
+
+    Example:
+       We have a 3D grid, each coordinate (q1,q2,q3) is defined between 
+       0.0 and 5.0. Each coordinate is sampled at 11 equispaced points.
+       We have a mapping f(q1,q2,q3) from the grid points to the real numbers.
+       The specific form of the mapping is of course irrelevant here, we only
+       are interested on the value corresponding to each grid point.
+       Thus xgrid1 contains:
+         xgrid1 = [ [0.0, 0.5, 1.0, 1.5, ..., 5.0],
+                    [0.0, 0.5, 1.0, 1.5, ..., 5.0],
+                    [0.0, 0.5, 1.0, 1.5, ..., 5.0]
+                  ]
+       And ygrid1 contains:
+         ygrid1[i][j][k] = f(xgrid1[0][i],xgrid1[1][j],xgrid1[2][k])
+
+       And we provide also an interpolation point from which we want to
+       know the interpolation f_intp(xpoint):
+         xpoint = [1.3,2.2,3.7]
+
+    """
+    ygridtmpA = np.array(ygrid1)
+    ndim = len(xpoint)
+    l = ygrid1.shape
+    # at each step we get a new grid of 1 dimension less until we reach
+    # the final interpolated number
+    for d in range(ndim):
+        xg = np.array(xgrid1[d])
+        xp = xpoint[d]
+        if l[d+1:]:
+            ygridtmpB = np.zeros(l[d+1:],float)
+            p = itr.MultiCounter()
+            p.setPointersN(0,len(l[d+1:]))
+            p.setMaxIter(l[d+1:])
+            # loop over the (ndim-d+1) dimensional grid
+            for ic in p:
+                yg = np.zeros(l[d],float)
+                # assign y values for the 1D interpolation
+                for j in range(l[d]):
+                    k = (j,)
+                    yg[j] = ygridtmpA[k+ic]
+                ygridtmpB[ic] = onedimInt(xg,yg,xp,intfunctions[d])
+            ygridtmpA = ygridtmpB
+        else: # last iteration
+            ygridtmpB = 0.0
+            yg = ygridtmpA
+            ygridtmpB = onedimInt(xg,yg,xp,intfunctions[d]) 
+            return ygridtmpB
+    return None
+
+def scattered2grid2D(points,xgrid,ygrid,kernel,**args):
+    """
+    Interpolate scattered 2D data into a regular grid
+
+    Arguments:
+        kernel -- w(d)
+            z = Sum_i w(d_i)
+    """
+    griddata = np.zeros((len(xgrid),len(ygrid)),float)
+    for i,x in enumerate(xgrid):
+        for j,y in enumerate(ygrid):
+            z = 0.0
+            for p in points:
+                d = (p[0]-x)**2 + (p[1]-y)**2
+                d = d**0.5
+                z = z + kernel(d)
+            griddata[i,j] = z
+    return griddata
+
+
+
+##############################################################################
+# 1D interpolators
+##############################################################################
+
+def onedimInt(xg,yg,xp,intfunc):
+    """Interpolate point xp using the yg[xg] function
+
+    this routine is a thin wrapper over 1D interpolation routines
+    xg -- array with tabulated x points
+    yg -- array with tabulated y points
+    xp -- point where the interpolation is desired
+    func -- list of one or more elements, the first is the pointer
+            to the interpolation function, the rest are possible
+            arguments expected by such function
+            If the last argument is "periodic", a periodic interpolation
+            will be atempted enlarging the xg segment, usually up to 4
+            more points per side to be safe with respect to the cubic
+            spline interpolation
+    """
+    f = intfunc[0]
+    ops = intfunc[1:]
+    if ops:
+        if ops[len(ops)-1] == 'periodic':
+            xg,yg = _toPeriodic(xg,yg)
+            return f(xg,yg,xp,ops[:-1])
+        return f(xg,yg,xp,ops)
+    else:
+        return f(xg,yg,xp)
+
+
+def linealInterpolation(xg,yg,xp,args=None):
+    """1D lineal interpolation of x
+
+    xg -- array with tabulated x points
+    yg -- array with tabulated y points
+    xp -- point where the interpolation is desired
+    args -- arguments, it is ignored and does not need to be set,
+            only keeps the interface consistency of 1D interpolators
+    """
+    imin = _segment(xg,xp)
+    y = yg[imin] + ((yg[imin+1]-yg[imin])/(xg[imin+1]-xg[imin]))*(xp-xg[imin])
+    return y
+
+
+# Cubic-spline and ENO interpolators removed: they depended on Fortran
+# helpers (splinenm/spline1d/enoi) that were never part of this package.
+# Use scipy.interpolate.CubicSpline / PchipInterpolator instead.
+
+
+# A dictionary is defined to translate from the input file
+# code of an interpolation method (usually 3 characters)
+# and the pointer to the real function, add entries always
+# when a new 1D interpolator is implemented
+keyToFunction = {
+    "default": linealInterpolation,
+    "lin": linealInterpolation,
+}
+
+
+##############################################################################
+#       --- NUMERICAL functions ---
+##############################################################################
+
+def dkron(i,j):
+    """Return the delta of Kroneker operation of integers i and j
+
+    i,j - integers, in case they are not integers the function
+          silently returns 0
+    """
+    if isinstance(i,int) and isinstance(j,int):
+        if i==j:
+            return 1
+        else:
+            return 0
+    else:
+        return 0
+
+
+def richardson(f,hi,con=1.4,niter=10,safe=2.0,fast=False):
+    """
+    Implements Richardson extrapolation to calculate numerical estimates
+    of values obtained by finite difference formulas.
+    f -- function depending on 1 variable, the finite difference, what f is,
+         a derivative, a numerical integral... does not play any role here
+    hi -- initial estimate for the finite difference
+    con -- constant factor by which hi is divided at each step
+    niter -- maximum number of iterations
+    safe -- when error grows by a factor more than safe, terminate and return
+    """
+    if fast:
+        if hi > 0.05:
+            return f(0.05),0.0,hi
+        else:
+            return f(hi),0.0,hi
+    con2 = con*con
+    big = 1.e30
+    a=np.zeros((niter,niter),float)
+    hh=hi
+    a[0,0] = f(hh)
+    err = big
+    for i in range(1,niter):
+        hh = hh/con
+        a[0,i] = f(hh)
+        fac = con2
+        for j in range(1,i+1):
+            a[j,i] = (a[j-1,i]*fac - a[j-1,i-1])/(fac-1.0)
+            fac = con2*fac
+            errt = max(abs(a[j,i]-a[j-1,i]),abs(a[j,i]-a[j-1,i-1]))
+            if errt <= err:
+                err = errt
+                res = a[j,i]
+                hf = hh
+        if abs(a[i,i]-a[i-1,i-1]) >= safe*err:
+            return res,err,hf
+    return res,err,hf
+
+
+
+##############################################################################
+#       --- Sampling & Monte-Carlo functions ---
+##############################################################################
+
+def randomWalkStep(xvec,min=None,max=None,stepnorm=1.0):
+    """
+    Make a random movement on a vector of real (float) coordinates
+
+    xvec - current state of the system in coordinate space
+    min - minimum value for each coordinate
+    max - maximum value for each coordinate
+    stepnorm - length of random steps to be performed
+
+    return
+       - next random position
+    """
+    lx = len(xvec)
+    rstep = np.random.random(lx) - 0.5
+    norm = (np.dot(rstep,rstep))**0.5
+    rstep = (stepnorm/norm)*rstep
+    xvecnew = xvec + rstep
+    if not max is None:
+        delta = max - xvecnew
+        hit = (delta < 0)
+        if hit.any():
+            for i in range(lx):
+                if hit[i]: xvecnew[i] = max[i] + delta[i]
+    if not min is None:
+        delta = min - xvecnew
+        hit = (delta > 0)
+        if hit.any():
+            for i in range(lx):
+                if hit[i]: xvecnew[i] = min[i] + delta[i]
+    return xvecnew
+
+
+def metropolisStep(xvec,pval,pfunc,pfuncargs=None,
+                   min=None,max=None,stepnorm=1.0):
+    """
+    Make a random movement, accept or reject accordint to metropolis alg.
+
+    xvec - xvec state of the vector of coordinates (list, tuple or array)
+    pval - probability value associated to the xvec position
+    pfunc - maps the xvec position in N-Dim space to a probability
+       pfuncargs - passed to pfunc, put pfunc arguments there
+
+    return
+       1. True if accepted, False if rejected
+       2. accepted or old xvec position
+       3. probability accepted point, pval retuned if not acc.
+    """
+    xnext = randomWalkStep(xvec,min=min,max=max,stepnorm=stepnorm)
+    if pfuncargs is None:
+        pnext = pfunc(xnext)
+    else:
+        pnext = pfunc(xnext,pfuncargs)
+    if pnext > pval:
+        return True,xnext,pnext
+    else:
+        p = pnext/pval
+        r = random.random()
+        if r < p:
+            return True,xnext,pnext
+        else:
+            return False,xvec,pval
+
+
+def randomWalkIntStep(xvec,xvecsize):
+    """
+    Make a random movement on a vector of integer coordinates
+
+    xvec - current state of the vector of integers (list, tuple or array)
+    xvecsize - vector with the maximum allowed value per each coordinate
+
+    return
+        1. list with the next position
+        2. index of the changed coordinate
+        3. +1 if changed in positive direction, -1 if negative
+    """
+    next = list(xvec)
+    n = len(xvec) - 1
+    i = random.randint(0,n)
+    s = 2*random.randint(1,2) - 3
+    next[i] = next[i] + s
+    if next[i] > xvecsize[i] or next[i] < 0:
+        next,i,s = randomWalkStep(xvec,xvecsize)
+    return next,i,s
+
+def metropolisIntStep(xvec,xvecsize,xvecVal,pfunc,pfuncargs=None):
+    """
+    Make a random movement, accept or reject accordint to metropolis alg.
+
+    xvec - xvec state of the vector of integers (list, tuple or array)
+    xvecsize - vector with the maximum allowed value per each coordinate
+    xvecVal - probability value associated to the xvec position
+    pfunc - maps the xvec position in N-Dim space to a probability
+            pfunc must accept 2 arguments, xvec and pfuncargs
+    pfuncargs - passed to pfunc, put pfunc arguments there
+
+    return
+       1. True if accepted, False if rejected
+       2. list with the accepted or old position
+       3. index of the changed coordinate, (-1 if no change)
+       4. +1 if changed in positive direction, -1 if negative, 0 if no change
+       5. function value of the accepted point, xvecVal retuned if not acc.
+    """
+    xnext,i,s = randomWalkStep(xvec,xvecsize)
+    xnextVal = pfunc(xnext,pfuncargs)
+    if xnextVal > xvecVal:
+        return True,xnext,i,s,xnextVal
+    else:
+        p = xnextVal/xvecVal
+        r = random.random()
+        if r < p:
+            return True,xnext,i,s,xnextVal
+        else:
+            return False,xvec,-1,0,xvecVal
+
+
+def WignerWalkQuantumStep(qnum,M_amu,w,radius2,min=None,max=None):
+    """
+    Make a random movement on a vector of real (float) coordinates
+    bound on a 1D sphere of radius [radius]
+    
+    radius2 -  radius squared of the sphere
+    min - minimum value for each coordinate
+    max - maximum value for each coordinate
+
+    return
+       - next random position
+
+    """
+    M = M_amu * au2am
+    radius = sqrt(radius2 / 2.0)
+    accepted = False
+    if qnum == 0:
+        qref = 0 
+    else:
+        qref = radius # [T]=[V] for HO
+        pref = qref
+    while not accepted:
+        pos = random.random() - 0.5
+        q1D = radius * sin(pi*pos)
+        p1D = radius * cos(pi*pos) * np.sign(pos)
+        # von Neumann scheme
+        if qnum == 0:
+            ratio = exp( - q1D**2 - p1D**2 ) 
+        else:
+            ratio = exp( - ( q1D - qref )**2 - (p1D - pref)**2 )
+        if ratio > random.random():
+            accepted = True
+
+    xvecnext1D = np.array([q1D, p1D], dtype=float)
+    return xvecnext1D
+
+
+def WignerQuantumStep(M_nmode,w_nmode,qnum_nmode,min=None,max=None):
+    """
+    Make a random movement for generating Wigner distribution
+
+    M_nmode - N masses   of normal modes
+    w_nmode - N energies of normal modes
+    qnum_nmode - N quantum numbers of normal modes 
+
+    return
+       xnext - coordinates and momenta
+    """
+    hbar = 1.0
+    ncoords = len(w_nmode)
+    xnext = np.zeros(2*ncoords, dtype=float) # [q,p] 2N vector
+    for i in range(ncoords):   
+        # energy of the normal modes
+        ET_nmode = hbar * (float(qnum_nmode[i]) + 0.5)
+        # generate a 2-unit vector on sphere of radius squared [ET_nmode]
+        # [q,p]
+        xnext1D = WignerWalkQuantumStep(qnum_nmode[i],M_nmode[i],w_nmode[i],ET_nmode,min=min,max=max)
+        # scale unit of q and p backwards
+        xnext[i]         = xnext1D[0] * sqrt(2.0) # q
+        xnext[i+ncoords] = xnext1D[1] * sqrt(2.0) # p 
+    #
+    return xnext
+
+
+##############################################################################
+#       --- Statistical Functions ---
+##############################################################################
+
+# rmsError() removed: it referred to project-specific globals
+# (parametersS0, parlist, table, potevb) that were never part of this package.
+
+##############################################################################
+#       ---  Orthonormal functions ---
+##############################################################################
+
+def generateOrthonormalSpace(vs,n):
+    """
+    Given an initial vector generate n-1 additional orthonormal vectors
+
+    Discrete orthonormality is preserved:
+    dot(v_n,v_m) = delta(n,m)
+
+    v0 - initial vector
+    n - size of orthonormal space generated
+    """
+    m = len(vs)
+    if n > m:
+        raise ValueError("n > m, maximum m orthonormal vectors can be generated")
+    v0 = np.asarray(vs)
+    vspace = np.zeros((n,m),type(v0[0]))
+    vspace[0] = v0
+    x = np.linspace(0.0,1.0,m+2)[1:-1]
+    for i in range(1,n):
+        vspace[i] = np.sin((i+1)*np.pi*x) # particle in a box excited states
+    gramSchmidt(vspace)
+    return vspace
+
+
+def gramSchmidt(vecs):
+    """
+    Perform a Gram-Schmidt orthonormalization on a given list of arrays
+
+    vecs -- list of arrays to orthonormalize
+    """
+    vecs[0] = vecs[0] / sqrt(np.vdot(vecs[0],vecs[0]))
+    if len(vecs) > 1:
+        for i in range(1,len(vecs)):
+            for j in range(0,i):
+                vecs[i] = vecs[i] - np.vdot(vecs[j],vecs[i])*vecs[j]
+            vecs[i] = vecs[i] / np.sqrt(np.vdot(vecs[i],vecs[i]))
+
+
+##############################################################################
+#       --- Function analysis ---
+##############################################################################
+
+def convolutionFilter(input,fwhm,step=None,lbound=None,hbound=None,
+                      filter='gaussian',externalFilter=None):
+    """
+    Filter the x,y input array with a gaussian filter
+
+    input -- x,y input array
+    fwhm  -- full width at half maximum of the filter
+
+    step -- discretization interval in the abcisas axis
+    lbound -- lower bound of for the output data
+    hbound -- higher bound for the output data
+    filter -- string: type of function used for filtering, gaussian
+              and lorentzian shapes are implemented
+    externalFilter -- externally provided function for filtering,
+                      must take two parameters:
+                          x - value of the abcisa
+                          b - center of the filter
+
+    return: an x,y array with the convolved function
+    """
+    if externalFilter:
+        f=externalFilter
+    else:
+        if filter == 'gaussian':
+            def f(x,b):
+                k = 4.0*math.log(2.0)
+                N = 4.0*math.log(2.0)/math.pi
+                N = N/fwhm
+                return N*math.exp(-k*((x-b)/fwhm)**2)
+        elif filter == 'lorentzian':
+            def f(x,b):
+                k=0.5*fwhm
+                k=k*k
+                return k/((x-b)**2 + k)
+
+    if lbound is None: lbound=input[0][0]
+    if hbound is None: hbound=input[0][-1]
+    if step is None: step=fwhm*0.05
+
+    xvec = np.arange(lbound,hbound+step,step)
+    nstep = len(xvec)
+
+    yinp = np.zeros(nstep,float)
+
+    # Map input data to the inp array
+    for i,x in enumerate(input[0]):
+        xi = (x-lbound)/step
+        ii = int(np.round(xi))
+        yinp[ii] = yinp[ii] + input[1][i]
+
+    # I(w) = Sum_t Func(t)*Filt(w-t)
+    yfltMat = [[f(t,w) for t in xvec] for w in xvec]
+    yfltMat = np.array(yfltMat)
+    yout = np.dot(yfltMat,yinp)
+    return np.array([xvec,yout])
+
+
+# convolution() removed: it referenced an undefined `si` module and was
+# strictly slower than numpy/scipy alternatives. Use scipy.signal.fftconvolve
+# (or numpy.convolve for short kernels).
+
+
+def rectangularConvolve(X,N,**kwargs):
+    Xpad = np.pad(X,N,'edge')
+    Xcon = np.convolve(np.ones(N,float)/N,Xpad,'same')
+    return Xcon[N:-N]
+
+
+# fourierTransform moved to quadlib.tools.spectra.
+
+
+##############################################################################
+#       ---  OTHER functions ---
+##############################################################################
+
+def wignerHarmonic1D(q,p,m,w,hbar=1.0,q0=0.0,p0=0.0):
+    """
+    Compute a probability density in phase space for the harmonic case.
+
+    Given a point in phase space compute the probability density using
+    the wigner transform of the vibrational ground state in harmonic
+    approximation. The wigner transform of a gaussian is another gaussian.
+
+    If hbar is not specified atomic units are assumed.
+
+    q -- position in phase space
+    p -- momentum in phase space
+    m -- mass
+    w -- frequency of the harmonic oscillator
+    """
+    qexp = math.exp(-(m*w/hbar)*(q-q0)**2)
+    pexp = math.exp(-(1.0/(m*w*hbar))*(p-p0)**2)
+    return (1.0/(hbar*math.pi))*qexp*pexp
+
+def wignerHarmonicND(q,p,m,w,hbar=1.0):
+    """
+    Compute a probability density in phase space for the N-Dim harmonic case.
+
+    Given a point in phase space compute the probability density using
+    the wigner transform of the vibrational ground state in harmonic
+    approximation. The wigner transform of a gaussian is another gaussian.
+
+    If hbar is not specified atomic units are assumed.
+
+    q -- list of positions in phase space
+    p -- list of momenta in phase space
+    m -- list of masses
+    w -- list of harmonic frequencies
+    """
+    wprob = 1.0
+    for i in range(len(q)):
+        wprob = wprob*wignerHarmonic1D(q[i],p[i],m[i],w[i],hbar)
+    return wprob
+
+
+# wignerHarmonicFT1D / wignerHarmonicFTND removed: they referenced an
+# undefined KBAU constant (Boltzmann constant in atomic units) and the
+# N-dim variant called the 1D form with the wrong argument order.
+
+
+# corrspec moved to quadlib.tools.spectra.
+
+
+def makeMesh(f,grid,ctype=float):
+        """
+        make a mesh of f at the positions of a product grid
+
+        f -- function depending on N variables
+        grid -- tuple or list of N 1D arrays which define the primitive grid
+
+        on return: a N-D array with the values of f at the grid points.
+        """
+        dim = len(grid)
+        indexes = []
+        for i in range(dim):
+            indexes.append(len(grid[i]))
+        z=np.zeros(indexes,ctype)
+        x=np.zeros(dim,float)
+        mc = itr.MultiCounter()
+        mc.setPointersN(0,dim)
+        mc.setMaxIter(indexes)
+        for p in mc:
+            for i in range(dim):
+                x[i]=grid[i][p[i]]
+            z[p]=f(x)
+        return z
+
+
+def bssrSumOfStates(freqs,emax,m,E0=0.0):
+    """
+    Beyer-Swinehart-Stein-Rabinovitch (BSSR) sum of states for harmonic systems
+
+    freqs: list of vibrational frequencies (hbar * omega)
+    emax: maximum energy related to the ZPE
+    m: discretization for the sum
+    E0: energy offset (can be a reaction barrier if dealing with a TS)
+
+    On return four lists containing:
+     E      : binned energy units
+     N(E)   : number of states at energy E (+- dE)
+     rho(E) : density of states at energy E
+     S(E)   : sum of states up to energy E
+    """
+    t = np.zeros(m+1,float)
+    ta = np.zeros(m+1,float)
+    e = np.zeros(m+1,float)
+    f = np.array(freqs)
+    fzpe = f/2.0      # zero point energies of the modes
+    zpe = fzpe.sum()  # zero point energy of the system
+    EMAX = emax       # Absolute maximum energy
+    dE = emax/m
+#   E0 = E0 + zpe
+
+    R0 = int(divmod(E0,dE)[0])
+    t[R0] = 1.0
+    ta[R0] = 1.0
+    for i in range(m+1):
+        e[i] = i*dE
+    for l,fmode in enumerate(f):
+        k = 1
+        Ek = fmode*k
+        Rk = int(divmod(Ek,dE)[0])
+        while Ek < emax:
+            for j in range(m-Rk+1):
+                ta[Rk+j] = ta[Rk+j] + t[j]
+            k += 1
+            Ek = fmode*k
+            Rk = int(divmod(Ek,dE)[0])
+        t[:] = ta
+    for i in range(1,m+1):
+        ta[i] = ta[i] + ta[i-1]
+    return e,t,t/dE,ta
+
+
+def classicalSumOfStates(freqs,emax,m,E0=0.0):
+    """
+    Classical approximation to the sum of states for harmonic systems
+
+    See: W.H. Miller, JACS 101, 6810 (1979)
+
+    freqs: list of vibrational frequencies (hbar * omega)
+    emax: maximum energy related to the ZPE
+    m: discretization for the sum
+    E0: energy offset (can be a reaction barrier if dealing with a TS)
+
+    On return four lists containing:
+     E      : binned energy units
+     N(E)   : number of states at energy E (+- dE)
+     rho(E) : density of states at energy E
+     S(E)   : sum of states up to energy E
+    """
+    from math import factorial
+    E = np.zeros(m+1,float)
+    f = np.array(freqs)
+    fzpe = f/2.0      # zero point energies of the modes
+    zpe = fzpe.sum()  # zero point energy of the system
+    EMAX = emax       # Absolute maximum energy
+    dE = emax/m       # discretization
+    s = len(f)
+    for i in range(m+1):
+        E[i] = i*dE
+    E[0] = 1e-8
+    sfac = float(factorial(s))
+    den = sfac*f.prod()
+    N = (E-E0)**s/den
+    for i in range(m*1):
+        if E[i] >= E0: continue
+        if E[i] < E0: N[i] = 0.0
+    RhoE = s*N/E
+    nE = RhoE*dE
+    return E,nE,RhoE,N
+
+def GaussianFunction(x, **option):
+    """
+    Gaussian function
+
+    Parameters:
+    -----------
+    x : 1D array_like
+        variable domain.
+    xbar : float, default: 0.0, optional
+        mean value
+    std : float, default: 1.0, optional
+        standard deviation
+    fwhm : float, default: None, optional
+        full width at half maximum. If fwhm is None (or non-positive number),
+        the std (standard deviation) will be used. If fwhm is present, then it
+        is used in to calculate std. fwhm = 2.0 * std * sqrt(2.0 * ln 2.0)
+    norm : bool, default: True, optional
+        if norm == True, the gaussian function is normalized
+        else, its pre-factor is 1.0
+
+    Returns:
+    --------
+    Gaussian function
+    """
+    xbar = option.get('xbar', 0.0)
+    std = option.get('std', 1.0)
+    norm = option.get('norm', True)
+    fwhm = option.get('fwhm', None)
+    if fwhm != None and fwhm > 0.0:
+        std = fwhm / (2.0 * np.sqrt(2.0 * np.log(2.0)))
+
+    A = 1.0
+    if norm:
+        A = 1.0 / (std * np.sqrt(2.0 * np.pi))
+
+    gaussian = A * np.exp(-0.5 * ((x - xbar)/std)**2)
+
+    return gaussian
+
+
+#################################################################
+# Array manipulation
+#################################################################
+def ReverseArray(array):
+    """
+    Reverse array.
+
+    Parameters:
+    -----------
+    array : 1D array_like
+        array to be reversed
+
+    Returns
+    -------
+    Reversed array
+    """
+    reverse_array = np.zeros(len(array))
+    for i, x in enumerate(array):
+        reverse_array[-i-1] = x
+    return reverse_array
+
+def ShiftArray(array, shift, **option):
+    """
+    Shift array.
+
+    Parameters:
+    -----------
+    array : 1D array_like
+        array to be shifted
+    shift : int
+        amount of shifting,
+        positive integer will shift the array to the right,
+        negative integer will shift the array to the left.
+    periodic : Bool, optional, default: True
+        if True, use the periodic boudary condition on the array
+        edge (the right most array element which is right shifted
+        will appear on the left most, and vice versa). If False,
+        the new array element which enter the array as the right
+        most or the left most elements will be set 0.0.
+
+    Returns:
+    --------
+    Shifted array
+    """
+    periodic = option.get('periodic', True)
+
+    N = len(array)
+    shifted_array = np.zeros(N)
+    if periodic:
+        for i in range(N):
+            shifted_array[(i + shift) % N] = array[i]
+    else:
+        for i in range(N):
+            l = i + shift
+            if l < 0 or l >= N:
+                shifted_array[l % N] = 0.0
+            else:
+                shifted_array[l] = array[i]
+
+    return shifted_array
+
+##############################################################################
+#       ---  INTERNAL functions ---
+##############################################################################
+
+def _segment(vect,point):
+    """Given a list of ordered values and a value, what is the index
+    of the point at the left of the given point?
+
+    vect -- list of ordered values
+    point -- value
+    on return, an index (integer). The returned index is always 
+    at least 0 and at maximum len(vect)-2
+    """
+    if point < vect[0]: return 0
+    if point > vect[len(vect)-1]: return len(vect)-2
+    for i in range(len(vect)-1):
+        if point > vect[i] and point < vect[i+1]:
+            return i
+    return 0
+
+
+def _toPeriodic(xg,yg,order=4):
+    """Modify xg and yg vectors for a periodic interpolation of order "order"
+
+    xg -- list of x values
+    yg -- list of y(x) values
+    order -- maximum order of the interpolation
+    """
+    if len(xg) < order:
+        error = "error in periodic interpolation, too few points"
+        raise ValueError(error)
+    xgnew = []
+    ygnew = []
+    xlast = xg[len(xg)-1]
+    dx = xg[1]-xg[0]
+    for i in range(len(xg)):
+        xgnew.append(xg[i])
+        ygnew.append(yg[i])
+    for i in range(order):
+        xgnew.append(xlast+dx*(i+1))
+        xgnew.insert(0,xg[0]-dx*(i+1))
+        ygnew.append(yg[i])
+        ygnew.insert(0,yg[len(yg)-1-i])
+    return xgnew,ygnew
+
+
+def lag(x, n):
+    """
+    Compute the hypergeometric Laguerre polynomial Ln(x)
+
+    """
+    # Lm(x) [0]-[n] ord.
+    poly = np.zeros(n+1, dtype=float) 
+    poly[0] = 1
+    poly[1] = 1 - x
+    m = 2
+    while m < (n + 1):
+        mf = float(m)
+        poly[m] = ((2*mf-1-x) * poly[m-1] - (mf-1) * poly[m-2]) / mf
+        m += 1
+
+    return poly[n]
+
+
+def distributionFromList(l,fwhm,nstep=100,lbound=None,hbound=None):
+    """
+    Generate a distribution from a 1D list of values using a Gaussian kernel
+
+    l - 1D array with data
+    fwhm - full width at half maximum of the Gaussian kernel
+    nstep - number of discrete output points
+    lbound - lower bound of output;
+    hbound - higher bound of output
+    """
+    lrange = l.max() - l.min()
+    if lbound is None:
+        lbound = l.min() - 0.1*lrange
+    if hbound is None:
+        hbound = l.max() + 0.1*lrange
+    x = np.linspace(lbound,hbound,nstep)
+    y = np.zeros(len(x),float)
+    for i,xp in enumerate(x):
+        for xl in l:
+            y[i] = y[i] + _gaussian(xl-xp,fwhm)
+    return x,y
+
+
+__k = 4.0*math.log(2.0)
+__N = 4.0*math.log(2.0)/math.pi
+def _gaussian(x,fwhm=1.0,norm=True):
+    N = __N/fwhm
+    if norm: return N*np.exp(-__k*((x)/fwhm)**2)
+    else: return np.exp(-__k*((x)/fwhm)**2)
+
+