def test_function_overloading():
a = pe.pseudo_Obs(17, 2.9, 'e1')
b = pe.pseudo_Obs(4, 0.8, 'e1')
fs = [
lambda x: x[0] + x[1], lambda x: x[1] + x[0], lambda x: x[0] - x[1],
lambda x: x[1] - x[0], lambda x: x[0] * x[1], lambda x: x[1] * x[0],
lambda x: x[0] / x[1], lambda x: x[1] / x[0], lambda x: np.exp(x[0]),
lambda x: np.sin(x[0]), lambda x: np.cos(x[0]), lambda x: np.tan(x[0]),
lambda x: np.log(x[0]), lambda x: np.sqrt(np.abs(x[0])),
lambda x: np.sinh(x[0]), lambda x: np.cosh(x[0]),
lambda x: np.tanh(x[0])
]
for i, f in enumerate(fs):
t1 = f([a, b])
t2 = pe.derived_observable(f, [a, b])
c = t2 - t1
assert c.is_zero()
assert np.log(np.exp(b)) == b
assert np.exp(np.log(b)) == b
assert np.sqrt(b**2) == b
assert np.sqrt(b)**2 == b
np.arcsin(1 / b)
np.arccos(1 / b)
np.arctan(1 / b)
np.arctanh(1 / b)
np.sinc(1 / b)
def sinc2D(y, x):
'''
2-D sinc function based on the product of 2 1-D sincs
Parameters
----------
x, y: arrays
Coordinates where to evaluate the 2-D sinc
Returns
-------
result: array
2-D sinc evaluated in x and y
'''
return np.sinc(y) * np.sinc(x)
def __init__(self, **kwargs):
# set default values for layer sizes, activation, and scale
activation = 'relu'
# decide on these parameters via user input
if 'activation' in kwargs:
activation = kwargs['activation']
# switches
if activation == 'linear':
self.activation = lambda data: data
elif activation == 'tanh':
self.activation = lambda data: np.tanh(data)
elif activation == 'relu':
self.activation = lambda data: np.maximum(0, data)
elif activation == 'sinc':
self.activation = lambda data: np.sinc(data)
elif activation == 'sin':
self.activation = lambda data: np.sin(data)
else: # user-defined activation
self.activation = kwargs['activation']
# select layer sizes and scale
N = 1
M = 1
U = 10
self.layer_sizes = [N, U, M]
self.scale = 0.1
if 'layer_sizes' in kwargs:
self.layer_sizes = kwargs['layer_sizes']
if 'scale' in kwargs:
self.scale = kwargs['scale']
def __init__(self, layer_sizes, **kwargs):
# set default values for layer sizes, activation, and scale
activation = 'relu'
# decide on these parameters via user input
if 'activation' in kwargs:
activation = kwargs['activation']
# switches
if activation == 'linear':
self.activation = lambda data: data
elif activation == 'tanh':
self.activation = lambda data: np.tanh(data)
elif activation == 'relu':
self.activation = lambda data: np.maximum(0, data)
elif activation == 'sinc':
self.activation = lambda data: np.sinc(data)
elif activation == 'sin':
self.activation = lambda data: np.sin(data)
elif activation == 'maxout':
self.activation = lambda data1, data2: np.maximum(data1, data2)
# select layer sizes and scale
self.layer_sizes = layer_sizes
self.scale = 0.1
if 'scale' in kwargs:
self.scale = kwargs['scale']
# assign initializer / feature transforms function
if activation == 'linear' or activation == 'tanh' or activation == 'relu' or activation == 'sinc' or activation == 'sin':
self.initializer = self.standard_initializer
self.feature_transforms = self.standard_feature_transforms
elif activation == 'maxout':
self.initializer = self.maxout_initializer
self.feature_transforms = self.maxout_feature_transforms
def sinc_interp(new_samples, samples, fvals, left=None, right=None):
"""
Interpolates x, sampled at "s" instants
Output y is sampled at "u" instants ("u" for "upsampled")
from Matlab:
http://phaseportrait.blogspot.com/2008/06/sinc-interpolation-in-matlab.html
"""
if len(fvals) != len(samples):
raise Exception, 'function vals (fvals) and samples must be the same length'
# Find the period
T = (samples[1:] - samples[:-1]).max()
# sinc resample
sincM = np.tile(new_samples, (len(samples), 1)) - \
np.tile(samples[:, np.newaxis], (1, len(new_samples)))
y = np.dot(fvals, np.sinc(sincM / T))
# set outside values to left/right inputs if given
if left is not None:
y[new_samples < samples[0]] = np.nan
if right is not None:
y[new_samples > samples[-1]] = np.nan
return y
def lanczos(dx, a=3):
"""Lanczos kernel
Parameters
----------
dx: float
amount to shift image
a: int
Lanczos window size parameter
Returns
-------
result: array-like
1D Lanczos kernel
"""
if np.abs(dx) > 1:
raise ValueError("The fractional shift dx must be between -1 and 1")
window = np.arange(-a + 1, a + 1) + np.floor(dx)
y = np.sinc(dx - window) * np.sinc((dx - window) / a)
return y, window.astype(int)
def test_sinc():
fun = lambda x : 3.0 * np.sinc(x)
d_fun = grad(fun)
check_grads(fun, 10.0*npr.rand())
check_grads(d_fun, 10.0*npr.rand())
def test_sinc():
fun = lambda x : 3.0 * np.sinc(x)
d_fun = grad(fun)
check_grads(fun, 10.0*npr.rand())
check_grads(d_fun, 10.0*npr.rand())
def test_sinc():
fun = lambda x: 3.0 * np.sinc(x)
check_grads(fun)(10.0 * npr.rand())
def fun_owen(ep):
sigma = np.imag(ep)/np.abs(ep-1)**2
fun = lambda h:h-2/np.pi*sigma/(1-np.sinc(2*h)**2)
init = 1/np.imag(np.sqrt(ep))/2/np.pi
return solve(fun,init)[0]
def test_sinc():
fun = lambda x : 3.0 * np.sinc(x)
check_grads(fun)(10.0*npr.rand())
def f_3(self, x):
return np.sinc(10 * x + 1)
def sinc(x):
return autonp.sinc(
(x - x0) / np.pi * L) * L / (2 * np.pi)**0.5 + autonp.sinc(
(x + x0) / np.pi * L) * L / (2 * np.pi)**0.5
