kernel_approximation_error Namespace Reference

Functions
def	ExactIntegrationOfSinus (t, a=None, b=None)
def	ExactIntegrationOfSinusWithExponentialKernel (ti, t, a, b)
def	IntegrationWithSumOfExponentialsKernel (t, a, b, ais, tis)

Variables
float	t = 5.0
float	t_win = 3.0
string	t0 = "MinusInfinity"
float	t_tail = t - t_win
list	best_as = []
list	best_ts = []
list	error_bounds = []
list	best_as_L1 = []
list	best_ts_L1 = []
list	error_bounds_L1 = []
list	hinsberg_as = [0.23477481312586, 0.28549576238194, 0.28479416718255, 0.26149775537574, 0.32056200511938, 0.35354490689146, 0.39635904496921, 0.42253908596514, 0.48317384225265, 0.63661146557001]
list	hinsberg_ts = [0.1, 0.3, 1., 3., 10., 40., 190., 1000., 6500., 50000.]
list	numbers = []
list	errors = []
	exact_integral = float(ExactIntegrationOfSinus(t, t0, t_tail))
list	ais = best_as[i]
list	tis = best_ts[i]
	m = len(ais)
	approximate_inegral = float(IntegrationWithSumOfExponentialsKernel(t, t0, t_tail, ais, tis))
list	numbers_L1 = []
list	errors_L1 = []
list	window_kernel_errors = [exact_integral for a in best_as_L1]
	approximate_inegral_hinsberg = float(IntegrationWithSumOfExponentialsKernel(t, t0, t_tail, hinsberg_as, hinsberg_ts))
	error_hinsberg = abs(exact_integral - approximate_inegral_hinsberg) * math.sqrt(t_win)
	label

Function Documentation

ExactIntegrationOfSinus()

def kernel_approximation_error.ExactIntegrationOfSinus	(		t,
			a = None,
			b = None
	)

ExactIntegrationOfSinusWithExponentialKernel()

def kernel_approximation_error.ExactIntegrationOfSinusWithExponentialKernel	(		ti,
			t,
			a,
			b
	)

IntegrationWithSumOfExponentialsKernel()

def kernel_approximation_error.IntegrationWithSumOfExponentialsKernel	(		t,
			a,
			b,
			ais,
			tis
	)

Variable Documentation

ais

list kernel_approximation_error.ais = best_as[i]

approximate_inegral

kernel_approximation_error.approximate_inegral = float(IntegrationWithSumOfExponentialsKernel(t, t0, t_tail, ais, tis))

approximate_inegral_hinsberg

kernel_approximation_error.approximate_inegral_hinsberg = float(IntegrationWithSumOfExponentialsKernel(t, t0, t_tail, hinsberg_as, hinsberg_ts))

best_as

list kernel_approximation_error.best_as = []

best_as_L1

list kernel_approximation_error.best_as_L1 = []

best_ts

list kernel_approximation_error.best_ts = []

best_ts_L1

list kernel_approximation_error.best_ts_L1 = []

error_bounds

kernel_approximation_error.error_bounds = []

error_bounds_L1

kernel_approximation_error.error_bounds_L1 = []

error_hinsberg

kernel_approximation_error.error_hinsberg = abs(exact_integral - approximate_inegral_hinsberg) * math.sqrt(t_win)

errors

kernel_approximation_error.errors = []

errors_L1

kernel_approximation_error.errors_L1 = []

exact_integral

kernel_approximation_error.exact_integral = float(ExactIntegrationOfSinus(t, t0, t_tail))

hinsberg_as

list kernel_approximation_error.hinsberg_as = [0.23477481312586, 0.28549576238194, 0.28479416718255, 0.26149775537574, 0.32056200511938, 0.35354490689146, 0.39635904496921, 0.42253908596514, 0.48317384225265, 0.63661146557001]

hinsberg_ts

list kernel_approximation_error.hinsberg_ts = [0.1, 0.3, 1., 3., 10., 40., 190., 1000., 6500., 50000.]

label

kernel_approximation_error.label

m

kernel_approximation_error.m = len(ais)

numbers

kernel_approximation_error.numbers = []

numbers_L1

kernel_approximation_error.numbers_L1 = []

t

float kernel_approximation_error.t = 5.0

t0

string kernel_approximation_error.t0 = "MinusInfinity"

t_tail

float kernel_approximation_error.t_tail = t - t_win

t_win

float kernel_approximation_error.t_win = 3.0

tis

list kernel_approximation_error.tis = best_ts[i]

window_kernel_errors

kernel_approximation_error.window_kernel_errors = [exact_integral for a in best_as_L1]