# and iteratively compute the approximations with Riley's algorithms
# (as in (2) on slide 42 on https://drna.padovauniversitypress.it/system/files/papers/Fasshauer-2008-Lecture3.pdf)
# AUTHOR: NK, kraemer(at)ins.uni-bonn.de
import numpy as np
import sys
sys.path.insert(0, '../modules/')
from ptSetFcts import getPtsHalton
from kernelMtrcs import buildKernelMtrx, buildKernelMtrxCond
from kernelFcts import gaussKernel, tpsKernel, maternKernel, expKernel
import scipy.special
np.set_printoptions(precision=1)
dim = 2
numReps = 7
def matKernel(pt1, pt2):
return maternKernel(pt1, pt2, 0.5)
print("\nGaussian:")
for i in range(numReps):
numPts = 2**(i + 3)
ptSet = getPtsHalton(numPts, dim)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, gaussKernel, 0.0)
print("(", numPts, ",", np.abs(np.min(np.linalg.eigvals(kernelMtrx))), ")")
from functools import partial
np.random.seed(15051994)
np.set_printoptions(precision = 1)
plt.rcParams.update({'font.size': 16})
print "\nHow many points shall we work with? (e.g. 10)"
print "\tnumPts = ?"
numPts = input("Enter: ")
print ""
ptSet = np.zeros((numPts, 1))
ptSet[:,0] = np.linspace(0,1,numPts)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, gaussKernel)
invKernelMtrx = np.linalg.inv(kernelMtrx)
numEvalPts = 400
evalPtSet = np.zeros((numEvalPts, 1))
evalPtSet[:,0] = np.linspace(0,1,numEvalPts)
kernelMtrxLeft = buildKernelMtrx(evalPtSet, ptSet, gaussKernel)
lagFcts = kernelMtrxLeft.dot(invKernelMtrx)
lebConst = np.amax(lagFcts.sum(axis = 1))
randIdx = np.random.randint(numPts)
plt.plot(evalPtSet, lagFcts[0:numEvalPts,randIdx], linewidth = 3, label = "Lag. fct.", color = "darkslategray")
print "\nWhich shift for Riley? (e.g. 0.001)"
print "\trileyShift = ?"
rileyShift = input("Enter: ")
print "\nWhich accuracy for Riley? (e.g. 1e-08)"
print "\trileyAcc = ?"
rileyAcc = input("Enter: ")
print "\nWhich maximal number of iterations? (e.g. 1000)"
print "\trileyNumMaxIt = ?"
rileyNumMaxIt = input("Enter: ")
print ""
ptSet = getPtsHalton(numPts, dim)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, expKernel)
kernelMtrxShift = buildKernelMtrxShift(ptSet, ptSet, expKernel, rileyShift)
rhs = np.zeros(len(ptSet))
rhs[0] = 1
trueSol = np.linalg.solve(kernelMtrx, rhs)
startVec = np.linalg.solve(kernelMtrxShift, rhs)
currIt = np.zeros(numPts)
counter = 0
currentRelError = 1.0
relError = np.array(currentRelError)
while currentRelError >= rileyAcc and counter <= rileyNumMaxIt:
counter = counter + 1
residual = rhs - kernelMtrx.dot(currIt)
print "\nHow many points shall we work with? (e.g. 10)"
print "\tnumPts = ?"
numPts = input("Enter: ")
print "\nWhich power for the IMQ function? (e.g. 2.0)"
print "\tmaternReg = ?"
imqPower = 1.0 * input("Enter: ")
print ""
imqKernelFixedPwr = partial(imqKernel, imqPower=imqPower)
ptSet = np.zeros((numPts, 1))
ptSet[:, 0] = np.linspace(0, 1, numPts)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, imqKernelFixedPwr)
invKernelMtrx = np.linalg.inv(kernelMtrx)
numEvalPts = 400
evalPtSet = np.zeros((numEvalPts, 1))
evalPtSet[:, 0] = np.linspace(0, 1, numEvalPts)
kernelMtrxLeft = buildKernelMtrx(evalPtSet, ptSet, imqKernelFixedPwr)
lagFcts = kernelMtrxLeft.dot(invKernelMtrx)
lebConst = np.amax(lagFcts.sum(axis=1))
randIdx = np.random.randint(numPts)
plt.plot(evalPtSet,
lagFcts[0:numEvalPts, randIdx],
# print("\nWhich maximal number of iterations? (e.g. 1000)")
# print("\trileyNumMaxIt = ?")
# rileyNumMaxIt = input("Enter: ")
# rileyNumMaxIt = int(rileyNumMaxIt)
# print("")
numPts = 500
dim = 2
rileyShift = 1e-07
rileyNumMaxIt = 1000
rileyAcc = 1e-10
ptSet = getPtsHalton(numPts, dim)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, matKernel)
kernelMtrxShift = buildKernelMtrx(ptSet, ptSet, matKernel, rileyShift)
rhs = np.zeros(len(ptSet))
rhs[0] = 1
trueSol = np.linalg.solve(kernelMtrx, rhs)
startVec = np.linalg.solve(kernelMtrxShift, rhs)
currIt = np.copy(startVec)
counter = 0
currentRelError = np.linalg.norm(kernelMtrx.dot(currIt) -
rhs) / np.linalg.norm(rhs)
relError = np.array(currentRelError)
print("Matern: shift = %.1f", rileyShift)
while currentRelError >= rileyAcc and counter <= rileyNumMaxIt:
# print("\nWhich maximal number of iterations? (e.g. 1000)")
# print("\trileyNumMaxIt = ?")
# rileyNumMaxIt = input("Enter: ")
# rileyNumMaxIt = int(rileyNumMaxIt)
# print("")
numPts = 512;
dim = 2;
rileyShift = 1e-2
rileyNumMaxIt = 500
rileyAcc = 1e-10
ptSet = getPtsHalton(numPts,dim)
kernelMtrx = buildKernelMtrx(ptSet,ptSet, gaussKernel)
kernelMtrxShift = buildKernelMtrx(ptSet,ptSet, gaussKernel, rileyShift)
rhs = np.zeros(len(ptSet))
rhs[0] = 1
trueSol = np.linalg.solve(kernelMtrx,rhs)
startVec = np.linalg.solve(kernelMtrxShift,rhs)
currIt = np.copy(startVec)
counter = 0
currentRelError = np.linalg.norm(kernelMtrx.dot(currIt) - rhs)/np.linalg.norm(rhs)
relError = np.array(currentRelError)
print("Matern: shift =", rileyShift)
while currentRelError >= rileyAcc and counter <= rileyNumMaxIt:
if counter%20 == 1:
print "\nHow many points shall we compute on? (>25, e.g. 250)"
numPts = input("Enter: ")
print "\nWhich regularity of the Matern function? (e.g. 2.0)"
maternReg = input("Enter: ")
print "\nWhich spatial dimension? (e.g. 2)"
dim = input("Enter: ")
print ""
maternKernelFixReg = partial(maternKernel, maternReg=maternReg)
ptSet = getPtsHalton(numPts, dim)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, maternKernelFixReg)
invKernelMtrx = np.linalg.inv(kernelMtrx)
rhs = np.zeros((numPts, 1))
rhs[17, 0] = 1
# Check decay of Lagrange coefficients
distFrom17PtSet = np.zeros(numPts)
lagCoeff = invKernelMtrx.dot(rhs)
for idx in range(numPts):
distFrom17PtSet[idx] = np.linalg.norm(ptSet[idx, :] - ptSet[17, :])
lagCoeff[idx] = np.linalg.norm(lagCoeff[idx])
distSortPtSet = np.argsort(distFrom17PtSet)
# Check decay of Lagrange function
numEvalPts = numPts + 1
evalPtSet = np.random.rand(numEvalPts, dim)
np.set_printoptions(precision=1)
dim = 2
numReps = 7
def matKernel(pt1, pt2):
return maternKernel(pt1, pt2, 1.5)
print("\nExponential:")
for i in range(numReps):
numPts = 2**(i + 3)
ptSet = getPtsHalton(numPts, dim)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, expKernel, 0.0)
print("(", numPts, ",", np.linalg.cond(kernelMtrx), ")")
print("\nMatern(nu = 2):")
for i in range(numReps):
numPts = 2**(i + 3)
ptSet = getPtsHalton(numPts, dim)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, matKernel, 0.0)
print("(", numPts, ",", np.linalg.cond(kernelMtrx), ")")
print("\nTPS:")
for i in range(numReps):
numPts = 2**(i + 3)
ptSet = getPtsHalton(numPts, dim)
kernelMtrx = buildKernelMtrxCond(ptSet, ptSet, tpsKernel, 0.0)
print("(", numPts, ",", np.linalg.cond(kernelMtrx), ")")
from functools import partial
np.random.seed(15051994)
np.set_printoptions(precision=1)
plt.rcParams.update({'font.size': 16})
print "\nHow many points shall we work with? (e.g. 10)"
print "\tnumPts = ?"
numPts = input("Enter: ")
print ""
ptSet = np.zeros((numPts, 1))
ptSet[:, 0] = np.linspace(0, 1, numPts)
kernelMtrx = buildKernelMtrx(ptSet, ptSet, expKernel)
invKernelMtrx = np.linalg.inv(kernelMtrx)
numEvalPts = 400
evalPtSet = np.zeros((numEvalPts, 1))
evalPtSet[:, 0] = np.linspace(0, 1, numEvalPts)
kernelMtrxLeft = buildKernelMtrx(evalPtSet, ptSet, expKernel)
lagFcts = kernelMtrxLeft.dot(invKernelMtrx)
lebConst = np.amax(lagFcts.sum(axis=1))
randIdx = np.random.randint(numPts)
plt.plot(evalPtSet,
lagFcts[0:numEvalPts, randIdx],
