def setup(self,
function_name,
N: int,
lambda_max_real: float = None,
lambda_max_imag: float = None):
"""
Setup coefficients for Cauchy contour integral coefficients
using an ellipse with height given by lambda_max_imag
and width given by lambda_max_real
See doc/rexi/rexi_wit_laplace for details
Args:
N (int):
Number of points on Cauchy contour.
"""
self.alphas = []
self.betas = []
self.function_name = function_name
self.N = N
gamma = lambda_max_imag
delta = lambda_max_real
r = np.sqrt((1 - delta / gamma) / (1 + delta / gamma))
d = r + (1.0 / r)
self.fun = Functions(function_name, efloat_mode=self.efloat_mode)
#print("Setting up ellipse:")
#print("gamma: ", gamma)
#print("delta: ", delta)
#print("r: ", r)
if lambda_max_real == None or lambda_max_imag == None:
raise Exception(
"ELREXI: please provide max imag and real values of contour")
c1 = (gamma * self.efloat.i / d)
c2 = -(gamma / d)
for j in range(N):
theta_j = self.efloat.pi2 * (j + self.efloat.to(0.5)) / N
# sampling position of support point
sn = c1 * (r * self.efloat.exp(self.efloat.i * theta_j) +
(1.0 / r) * self.efloat.exp(-self.efloat.i * theta_j))
#metric term
sn_prime = c2 * (
r * self.efloat.exp(self.efloat.i * theta_j) -
(1.0 / r) * self.efloat.exp(-self.efloat.i * theta_j))
self.betas.append(-self.efloat.i * self.fun.eval(sn) * sn_prime /
N)
self.alphas.append(sn)
coeffs = REXICoefficients()
coeffs.alphas = self.alphas[:]
coeffs.betas = self.betas[:]
coeffs.gamma = 0
coeffs.function_name = self.function_name
self.unique_id_string = ""
self.unique_id_string += self.function_name
self.unique_id_string += "_N" + str(self.N)
self.unique_id_string += "_im" + str(self.efloat.re(lambda_max_imag))
self.unique_id_string += "_re" + str(self.efloat.re(lambda_max_real))
coeffs.unique_id_string = self.getUniqueId()
return coeffs
class CIREXI:
#
# Constructor
# See setup(...) for documentation on parameters
#
def __init__(self, efloat_mode="float"):
self.efloat_mode = efloat_mode
self.efloat = EFloat(efloat_mode)
self.alphas = []
self.betas = []
self.unique_id_string = ""
def setup(self,
function_name,
N: int,
R: float = None,
lambda_shift: complex = None,
lambda_max_real: float = None,
lambda_include_imag: float = None):
self.alphas = []
self.betas = []
self.function_name = ""
if lambda_shift != None:
self.setup_shifted_circle(function_name,
N=N,
R=R,
lambda_shift=lambda_shift)
elif lambda_max_real != None:
self.setup_limited_circle(function_name,
N=N,
lambda_max_real=lambda_max_real,
lambda_include_imag=lambda_include_imag)
else:
self.setup_circle(function_name, N=N, R=R)
coeffs = REXICoefficients()
coeffs.alphas = self.alphas[:]
coeffs.betas = self.betas[:]
coeffs.gamma = 0
coeffs.function_name = self.function_name
coeffs.unique_id_string = self.getUniqueId()
return coeffs
def setup_shifted_circle(self, function_name, N: int, R: float,
lambda_shift: complex):
"""
Setup coefficients for Cauchy contour integral coefficients
using a shifted circle with the shift given by lambda_shift
which fulfills the constraints given by lambda_*
Args:
N (int):
Number of points on Cauchy contour.
R (float):
Radius of circle for Cauchy contour
lambda_shift (complex):
` Shift of center of circle on complex plane
"""
self.function_name = function_name
self.lambda_shift = lambda_shift
self.fun = Functions(function_name, efloat_mode=self.efloat_mode)
for j in range(N):
theta_j = self.efloat.pi2 * (j + self.efloat.to(0.5)) / N
# sampling position of support point
pos = R * self.efloat.exp(self.efloat.i * theta_j)
# shifted position
gamma_j = pos + lambda_shift
self.betas.append(-self.fun.eval(gamma_j) * pos / N)
self.alphas.append(-gamma_j)
self.unique_id_string = "shic"
self.unique_id_string += "_" + function_name
self.unique_id_string += "_" + str(N)
self.unique_id_string += "_" + str(self.efloat.re(lambda_shift))
self.unique_id_string += "_" + str(self.efloat.im(lambda_shift))
def setup_circle(self, function_name, N: int, R: float):
"""
Setup circle contour integral centered at origin
Args:
N (int):
Number of quadrature poles
R (float):
Radius of circle
"""
self.setup_shifted_circle(function_name, N, R, 0.0)
self.unique_id_string = "circ"
self.unique_id_string += "_" + function_name
self.unique_id_string += "_" + str(N)
self.unique_id_string += "_" + str(lambda_max_real)
self.unique_id_string += "_" + str(lambda_include_imag)
def setup_limited_circle(self, function_name: str, N: int,
lambda_max_real: float,
lambda_include_imag: float):
"""
Setup coefficients for Cauchy contour integral coefficients circle
which fulfills the constraints given by lambda_*
Args:
N (int):
Number of points on Cauchy contour.
lambda_max_real (float):
Maximum allowed real number on contour.
lambda_include_imag (float):
Include at least this imaginary value as part of the contour.
Even, if the contour has to be enlarged
"""
# If the maximal real number is larger than the max to be included imaginary number, set a lower value for the max real number
if lambda_max_real > lambda_include_imag:
lambda_max_real = lambda_include_imag
x0 = lambda_max_real
xm = lambda_include_imag
r = (x0 * x0 + xm * xm) / (2.0 * x0)
center = lambda_max_real - r
self.setup_shifted_circle(function_name, N, r, center)
self.unique_id_string = "limc"
self.unique_id_string += "_" + str(N)
self.unique_id_string += "_" + function_name
self.unique_id_string += "_" + str(lambda_max_real)
self.unique_id_string += "_" + str(lambda_include_imag)
def getUniqueId(self):
return "CIREXI_" + self.unique_id_string
#! /usr/bin/env python3
import sys
import os
import numpy as np
d = os.path.dirname(os.path.realpath(__file__))
sys.path.append(d + "/..")
from mule_local.rexi.Functions import *
sys.path.pop()
funs = Functions()
funs_mp = Functions(efloat_mode="mpfloat")
eps = 1e-10
eps_series = 1e-6
eps_direct = 1e-1
minmax = 2.0
numsamples = 123 * 2
#
# Test A)
#
# phiNDirect == '''method'''
#
for method in ['phiNDirectFormula', 'phiNRec', 'phiNSeries', 'phiN']:
#for method in []:
plt.clf()
plt.scatter(x, y, s=np.log(np.absolute(coeffs.betas)) + 1.0)
plt.savefig('output_' + filepre + '_alphas_scaled.pdf')
x = np.real(coeffs.betas)
y = np.imag(coeffs.betas)
plt.clf()
plt.scatter(x, y)
plt.savefig('output_' + filepre + '_betas.pdf')
#
# Error plot
#
plt.clf()
function = Functions(function_name="phi0", efloat_mode="float")
test_range = [-N, N]
num_test_samples = 4096
max_error = 0
xpts = np.linspace(test_range[0], test_range[1], num_test_samples)
yvals = np.zeros(num_test_samples)
for i in range(num_test_samples):
x = xpts[i]
lam = 1j * x
y = function.eval(lam)
yn = coeffs.eval(lam)