def solveBVP2(f, N):
# calc step size
h = 1/N
# set boundary conditions
y0 = 0
yN = 0
# define nodes
x = np.linspace(0, 1, N)
# define internal nodes
x_int = x[1:N-1]
# create LHS (banded) matrix
n_mat = N - 2
Ah = np.zeros((2, n_mat))
# Fill banded matrix Ab
Ah[0][:] = -1
Ah[1][:] = 2 - (h**2)
# create RHS matrix
b = np.zeros((N-2,1))
# fill RHS with f(x_int)
for i in range(n_mat):
b[i] = f(x_int[i]) * h**2
# solve system
y_int = solveh_banded(Ah,b)
output = np.append(y0, y_int)
output = np.append(output, yN)
# plot solns
plt.plot(x,output)
plt.title("Fin Diff Approximation for " + f.__name__)
plt.title("N =" + str(N), loc = 'left')
return output
def smooth(self, w):
foo = self.upper_bands.copy()
foo[-1] += w # last row is the diagonal
return solveh_banded(foo,
w * self.y,
overwrite_ab=True,
overwrite_b=True)
def minimize_Z_EL_cython(A, l1, l2, rho):
""""""
# build banded matrix:
n = len(A)
Bmat = numpy.zeros((2,n))
Bmat[0,:] = -2*l2/rho
Bmat[1,1:n-1] = 1 +4*l2/rho
Bmat[1,0] = Bmat[1,n-1] = 1 + 2*l2/rho
# convert A into an array:
A_ = numpy.zeros((len(A), A[0].shape[0], A[0].shape[0]))
for i in range(len(A)):
A_[i,:,:] = A[i]
sudoZ = A_[:]
for i in range(A[0].shape[0]):
for j in range(i, A[0].shape[0]):
resp = A_[:,i,j]
# get LS solution:
beta_hat = solveh_banded(Bmat, resp, overwrite_ab=True, overwrite_b=True)
# shooting algorithm:
beta_hat = Z_shooting.Z_shooting(B=beta_hat, y=resp, l1=l1, l2=l2, tol=0.1, max_iter=100)
sudoZ[:,i,j] = beta_hat
sudoZ[:,j,i] = beta_hat
# return to a list (terribly inefficient! I have to change this!)
Z_ = [None] * len(A)
for i in range(len(A)):
Z_[i] = sudoZ[i,:,:]
return Z_
def fit(self, y, x=None, weights=None, pen=0.):
banded = True
if x is None:
x = self.tau[(self.M-1):-(self.M-1)] # internal knots
if pen == 0.: # can't use cholesky for singular matrices
banded = False
if x.shape != y.shape:
raise ValueError, 'x and y shape do not agree, by default x are the Bspline\'s internal knots'
bt = self.basis(x)
if pen >= self.penmax:
pen = self.penmax
if weights is None:
weights = N.array(1.)
wmean = weights.mean()
_w = N.sqrt(weights / wmean)
bt *= _w
# throw out rows with zeros (this happens at boundary points!)
mask = N.flatnonzero(1 - N.alltrue(N.equal(bt, 0), axis=0))
bt = bt[:, mask]
y = y[mask]
self.df_total = y.shape[0]
if bt.shape[1] != y.shape[0]:
raise ValueError, "some x values are outside range of B-spline knots"
bty = N.dot(bt, _w * y)
self.N = y.shape[0]
if not banded:
self.btb = N.dot(bt, bt.T)
_g = _band2array(self.g, lower=1, symmetric=True)
self.coef, _, self.rank = L.lstsq(self.btb + pen*_g, bty)[0:3]
self.rank = min(self.rank, self.btb.shape[0])
else:
self.btb = N.zeros(self.g.shape, N.float64)
nband, nbasis = self.g.shape
for i in range(nbasis):
for k in range(min(nband, nbasis-i)):
self.btb[k, i] = (bt[i] * bt[i+k]).sum()
bty.shape = (1, bty.shape[0])
self.chol, self.coef = solveh_banded(self.btb +
pen*self.g,
bty, lower=1)
self.coef = N.squeeze(self.coef)
self.resid = N.sqrt(wmean) * (y * _w - N.dot(self.coef, bt))
self.pen = pen
def test_03_upper(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 2D array with shape (3,1).
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0]).reshape(-1,1)
x = solveh_banded(ab, b)
assert_array_almost_equal(x, array([0.0, 1.0, 0.0]).reshape(-1,1))
def test_01_float32(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]], dtype=float32)
b = array([1.0, 4.0, 1.0], dtype=float32)
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_01_complex(self):
# Solve
# [ 4 -j 0] [ -j]
# [ j 4 -j] X = [4-j]
# [ 0 j 4] [4+j]
#
ab = array([[-99, -1.0j, -1.0j], [4.0, 4.0, 4.0]])
b = array([-1.0j, 4.0-1j, 4+1j])
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 1.0])
def test_03_upper(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 2D array with shape (3,1).
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0]).reshape(-1, 1)
x = solveh_banded(ab, b)
assert_array_almost_equal(x, array([0.0, 1.0, 0.0]).reshape(-1, 1))
def test_01_upper(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 1D array.
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0])
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_tridiag_01_lower(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[4.0, 4.0, 4.0], [1.0, 1.0, -99]])
b = array([1.0, 4.0, 1.0])
x = solveh_banded(ab, b, lower=True)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_01_upper(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 1D array.
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0])
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_01_float32(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]], dtype=float32)
b = array([1.0, 4.0, 1.0], dtype=float32)
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_01_lower(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[4.0, 4.0, 4.0], [1.0, 1.0, -99]])
b = array([1.0, 4.0, 1.0])
x = solveh_banded(ab, b, lower=True)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_check_finite(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 1D array.
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0])
x = solveh_banded(ab, b, check_finite=False)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_01_complex(self):
# Solve
# [ 4 -j 0] [ -j]
# [ j 4 -j] X = [4-j]
# [ 0 j 4] [4+j]
#
ab = array([[-99, -1.0j, -1.0j], [4.0, 4.0, 4.0]])
b = array([-1.0j, 4.0 - 1j, 4 + 1j])
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 1.0])
def test_check_finite(self):
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 1D array.
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0])
x = solveh_banded(ab, b, check_finite=False)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def timestep(self, input_signal, output_condition=0,
curr_noise=0, sub_noise=0, cond_noise=0):
"""
Compute the time evolution for one timestep using increments of
the driving noise (current, subunit or conductance or a mixture)
and the corresponding input signal at the soma. The output as an
outflux current can also be specified.
Note that the noise has to be initialized outside the class in
order to be able to compare models for given trajectories of the
noise. Shape of the noise has to be
curr_noise.shape = (N_axon+1, M)
sub_noise.shape = (3, N_axon+1, M)
cond_noise.shape = (11, N_axon+1, M)
"""
[v, m, h, n] = self.state.copy()
# Explicit Euler(-Maruyama) step for gating variables
self.state[1] += self.dt * self.t_m(v) * (self.m_inf(v)-m)
self.state[2] += self.dt * self.t_h(v) * (self.h_inf(v)-h)
self.state[3] += self.dt * self.t_n(v) * (self.n_inf(v)-n)
# If subunit noise is switched on
if np.max(self.sigma_sub):
N = self.N_axon + 1
self.state[1][:N, :] += (np.sqrt(self.alpha_m(v[:N, :]) *
(1-m[:N, :]) + self.beta_m(v[:N, :]) * m[:N, :]) *
self.sigma_sub[0] * sub_noise[0])
self.state[2][:N, :] += (np.sqrt(self.alpha_h(v[:N, :]) *
(1-h[:N, :]) + self.beta_h(v[:N, :]) * h[:N, :]) *
self.sigma_sub[1] * sub_noise[1])
self.state[3][:N, :] += (np.sqrt(self.alpha_n(v[:N, :]) *
(1-n[:N, :]) + self.beta_n(v[:N, :]) * n[:N, :]) *
self.sigma_sub[2] * sub_noise[2])
# Respect boundaries!
for i in xrange(3):
self.state[i][self.state[i]>1] = 1
self.state[i][self.state[i]<0] = 0
# Semi-implicit Euler step for voltage variable
rhs = v - self.dt*self.fv(v, m, h, n)
rhs[:self.N_axon+1, :] += self.sigma_curr*curr_noise
# If conductance noise is switched on
if self.sigma_cond:
rhs[:self.N_axon+1,:] -= self.compute_cond_noise(cond_noise)
# Input signal as Neumann boundary condition for left axon endpoint
rhs[0] += self.boundary * input_signal
# Output condition as Neumann boundary condition for right axon endpoint
rhs[-1] += self.boundary * output_condition
# Modification of RHS to make discrete Neumann Laplacian symmetric
rhs[0] *= 0.5
rhs[-1] *= 0.5
# Solve the linear problem
self.state[0] = lng.solveh_banded(self.bandedmatrix, rhs,
check_finite=False)
# Update state
#self.state = [v_neu, m_neu, h_neu, n_neu]
self.time_elapsed += self.dt
def test_01_lower(self):
# Solve
# [ 4 1 2 0] [1]
# [ 1 4 1 2] X = [4]
# [ 2 1 4 1] [1]
# [ 0 2 1 4] [2]
#
ab = array([[4.0, 4.0, 4.0, 4.0], [1.0, 1.0, 1.0, -99], [2.0, 2.0, 0.0, 0.0]])
b = array([1.0, 4.0, 1.0, 2.0])
x = solveh_banded(ab, b, lower=True)
assert_array_almost_equal(x, [0.0, 1.0, 0.0, 0.0])
def test_01_complex(self):
# Solve
# [ 4 -j 2 0] [2-j]
# [ j 4 -j 2] X = [4-j]
# [ 2 j 4 -j] [4+j]
# [ 0 2 j 4] [2+j]
#
ab = array([[0.0, 0.0, 2.0, 2.0], [-99, -1.0j, -1.0j, -1.0j], [4.0, 4.0, 4.0, 4.0]])
b = array([2 - 1.0j, 4.0 - 1j, 4 + 1j, 2 + 1j])
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 1.0, 0.0])
def test_tridiag_02_complex(self):
# Solve
# [ 4 -j 0] [ -j 4j]
# [ j 4 -j] X = [4-j -1-j]
# [ 0 j 4] [4+j 4 ]
#
ab = array([[-99, -1.0j, -1.0j], [4.0, 4.0, 4.0]])
b = array([[-1j, 4.0j], [4.0 - 1j, -1.0 - 1j], [4.0 + 1j, 4.0]])
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0j], [1.0, 0.0], [1.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_tridiag_02_float32(self):
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]], dtype=float32)
b = array([[1.0, 4.0], [4.0, 2.0], [1.0, 4.0]], dtype=float32)
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_tridiag_02_lower(self):
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[4.0, 4.0, 4.0], [1.0, 1.0, -99]])
b = array([[1.0, 4.0], [4.0, 2.0], [1.0, 4.0]])
x = solveh_banded(ab, b, lower=True)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_tridiag_02_float32(self):
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]], dtype=float32)
b = array([[1.0, 4.0], [4.0, 2.0], [1.0, 4.0]], dtype=float32)
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_tridiag_02_lower(self):
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[4.0, 4.0, 4.0], [1.0, 1.0, -99]])
b = array([[1.0, 4.0], [4.0, 2.0], [1.0, 4.0]])
x = solveh_banded(ab, b, lower=True)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_02_complex(self):
# Solve
# [ 4 -j 0] [ -j 4j]
# [ j 4 -j] X = [4-j -1-j]
# [ 0 j 4] [4+j 4 ]
#
ab = array([[-99, -1.0j, -1.0j], [4.0, 4.0, 4.0]])
b = array([[-1j, 4.0j], [4.0 - 1j, -1.0 - 1j], [4.0 + 1j, 4.0]])
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0j], [1.0, 0.0], [1.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_01_float32(self):
warnings.simplefilter("ignore", category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]], dtype=float32)
b = array([1.0, 4.0, 1.0], dtype=float32)
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_03_upper(self):
warnings.simplefilter("ignore", category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 2D array with shape (3,1).
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0]).reshape(-1, 1)
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, array([0.0, 1.0, 0.0]).reshape(-1, 1))
def test_01_lower(self):
warnings.simplefilter("ignore", category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[4.0, 4.0, 4.0], [1.0, 1.0, -99]])
b = array([1.0, 4.0, 1.0])
c, x = solveh_banded(ab, b, lower=True)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def scipy_solve_symm_block_tridiag(H_diag, H_upper_diag, v, ab=None):
"""
use scipy.linalg.solve_banded to solve a symmetric block tridiagonal system
see https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.solveh_banded.html
"""
from scipy.linalg import solveh_banded
ab = convert_block_tridiag_to_banded(H_diag, H_upper_diag) \
if ab is None else ab
x = solveh_banded(ab, v.ravel(), lower=True)
return x.reshape(v.shape)
def test_01_lower(self):
warnings.simplefilter('ignore', category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[4.0, 4.0, 4.0], [1.0, 1.0, -99]])
b = array([1.0, 4.0, 1.0])
c, x = solveh_banded(ab, b, lower=True)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_03_upper(self):
warnings.simplefilter('ignore', category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 2D array with shape (3,1).
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0]).reshape(-1, 1)
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, array([0.0, 1.0, 0.0]).reshape(-1, 1))
def test_01_float32(self):
warnings.simplefilter('ignore', category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]], dtype=float32)
b = array([1.0, 4.0, 1.0], dtype=float32)
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
def test_01_complex(self):
warnings.simplefilter('ignore', category=DeprecationWarning)
# Solve
# [ 4 -j 0] [ -j]
# [ j 4 -j] X = [4-j]
# [ 0 j 4] [4+j]
#
ab = array([[-99, -1.0j, -1.0j], [4.0, 4.0, 4.0]])
b = array([-1.0j, 4.0 - 1j, 4 + 1j])
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 1.0])
def test_01_complex(self):
warnings.simplefilter("ignore", category=DeprecationWarning)
# Solve
# [ 4 -j 0] [ -j]
# [ j 4 -j] X = [4-j]
# [ 0 j 4] [4+j]
#
ab = array([[-99, -1.0j, -1.0j], [4.0, 4.0, 4.0]])
b = array([-1.0j, 4.0 - 1j, 4 + 1j])
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 1.0])
def test_02_upper(self):
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([[1.0, 4.0], [4.0, 2.0], [1.0, 4.0]])
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_02_upper(self):
warnings.simplefilter("ignore", category=DeprecationWarning)
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([[1.0, 4.0], [4.0, 2.0], [1.0, 4.0]])
c, x = solveh_banded(ab, b)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_01_complex(self):
# Solve
# [ 4 -j 2 0] [2-j]
# [ j 4 -j 2] X = [4-j]
# [ 2 j 4 -j] [4+j]
# [ 0 2 j 4] [2+j]
#
ab = array([[0.0, 0.0, 2.0, 2.0], [-99, -1.0j, -1.0j, -1.0j],
[4.0, 4.0, 4.0, 4.0]])
b = array([2 - 1.0j, 4.0 - 1j, 4 + 1j, 2 + 1j])
x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 1.0, 0.0])
def test_02_upper(self):
warnings.simplefilter('ignore', category=DeprecationWarning)
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([[1.0, 4.0], [4.0, 2.0], [1.0, 4.0]])
c, x = solveh_banded(ab, b)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
assert_array_almost_equal(x, expected)
def test_02_lower(self):
# Solve
# [ 4 1 2 0] [1 6]
# [ 1 4 1 2] X = [4 2]
# [ 2 1 4 1] [1 6]
# [ 0 2 1 4] [2 1]
#
ab = array([[4.0, 4.0, 4.0, 4.0], [1.0, 1.0, 1.0, -99], [2.0, 2.0, 0.0, 0.0]])
b = array([[1.0, 6.0], [4.0, 2.0], [1.0, 6.0], [2.0, 1.0]])
x = solveh_banded(ab, b, lower=True)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0], [0.0, 0.0]])
assert_array_almost_equal(x, expected)
def test_02_float32(self):
# Solve
# [ 4 1 2 0] [1 6]
# [ 1 4 1 2] X = [4 2]
# [ 2 1 4 1] [1 6]
# [ 0 2 1 4] [2 1]
#
ab = array([[0.0, 0.0, 2.0, 2.0], [-99, 1.0, 1.0, 1.0], [4.0, 4.0, 4.0, 4.0]], dtype=float32)
b = array([[1.0, 6.0], [4.0, 2.0], [1.0, 6.0], [2.0, 1.0]], dtype=float32)
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0], [0.0, 0.0]])
assert_array_almost_equal(x, expected)
def test_02_complex(self):
# Solve
# [ 4 -j 2 0] [2-j 2+4j]
# [ j 4 -j 2] X = [4-j -1-j]
# [ 2 j 4 -j] [4+j 4+2j]
# [ 0 2 j 4] [2+j j]
#
ab = array([[0.0, 0.0, 2.0, 2.0], [-99, -1.0j, -1.0j, -1.0j], [4.0, 4.0, 4.0, 4.0]])
b = array([[2 - 1j, 2 + 4j], [4.0 - 1j, -1 - 1j], [4.0 + 1j, 4 + 2j], [2 + 1j, 1j]])
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0j], [1.0, 0.0], [1.0, 1.0], [0.0, 0.0]])
assert_array_almost_equal(x, expected)
def inverse_pfb(ts_pfb, ntap, window=hamming):
"""Invert the SWARM PFB timestream.
Parameters
----------
ts_pfb : np.ndarray[nsamp, nfreq]
The PFB timestream.
ntap : integer
The number of number of blocks combined into the final timestream.
window : function (ntap, lblock) -> np.ndarray[lblock * ntap]
The window function to apply to each block.
"""
# Inverse fourier transform to get the pseudo-timestream
pseudo_ts = np.fft.irfft(ts_pfb, axis=-1)
# Transpose timestream
pseudo_ts = pseudo_ts.T.copy()
# Pull out the number of blocks and their length
lblock, nblock = pseudo_ts.shape
ntsblock = nblock + ntap - 1
# Coefficients for the P matrix
coeff_P = window(ntap, lblock).reshape(ntap, lblock) # Create the window array
# Coefficients for the PP^T matrix
coeff_PPT = np.array([ ( coeff_P[:, np.newaxis, :]
* coeff_P[np.newaxis, :, :] ).diagonal(offset=k).sum(axis=-1)
for k in range(ntap) ])
rec_ts = np.zeros((lblock, ntsblock), dtype=np.float64)
for i_off in range(lblock):
# Create band matrix representation of P
band_P = np.zeros((ntap, ntsblock), dtype=np.float64)
band_P[:] = coeff_P[::-1, i_off, np.newaxis]
# Create band matrix representation of PP^T (symmetric)
band_PPT = np.zeros((ntap, nblock), dtype=np.float64)
band_PPT[:] = coeff_PPT[::-1, i_off, np.newaxis]
# Solve for intermediate vector
yh = la.solveh_banded(band_PPT, pseudo_ts[i_off])
# Project into timestream estimate
rec_ts[i_off] = band_mv(band_P, 0, ntap-1, ntsblock, nblock, yh, trans=True)
# Transpose timestream back
rec_ts = rec_ts.T.copy()
return rec_ts
def test_02_lower(self):
# Solve
# [ 4 1 2 0] [1 6]
# [ 1 4 1 2] X = [4 2]
# [ 2 1 4 1] [1 6]
# [ 0 2 1 4] [2 1]
#
ab = array([[4.0, 4.0, 4.0, 4.0], [1.0, 1.0, 1.0, -99],
[2.0, 2.0, 0.0, 0.0]])
b = array([[1.0, 6.0], [4.0, 2.0], [1.0, 6.0], [2.0, 1.0]])
x = solveh_banded(ab, b, lower=True)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0], [0.0, 0.0]])
assert_array_almost_equal(x, expected)
def minimize_Z_EL_parallel_Approx(resp, Bmat, l1):
"""Parallel implementation of Z_EL step
INPUT:
- resp: vector for (i,j) partial correlation estimates
- Bmat: tridiagonal matrix used to solve L2 problem
- l1, l2, rho: penalty parameters
"""
beta_hat = stVec(solveh_banded(Bmat, resp, overwrite_ab=True, overwrite_b=True), l1)
return beta_hat
def minimize_Z_EL_parallel_cython(resp, Bmat, l1, l2):
"""Parallel implementation of Z_EL step
INPUT:
- resp: vector for (i,j) partial correlation estimates
- Bmat: tridiagonal matrix used to solve L2 problem
- l1, l2, rho: penalty parameters
"""
beta_hat = solveh_banded(Bmat, resp, overwrite_ab=True, overwrite_b=True)
beta_hat = Z_shooting.Z_shooting(B=beta_hat, y=resp, l1=l1, l2=l2, tol=.1, max_iter=100)
return beta_hat
def solve(self, n=20, kappa=1e6):
t0 = timer()
#n support points including boundary points
X = sp.linspace(self.dmleft, self.dmright, n).reshape([1, n])
self.xi_x = X
#stiffness at mid of points
#print a
#interval size
h = (self.dmright - self.dmleft) / (n - 1)
A = sp.zeros([2, n])
for i in xrange(n - 1):
a = self.problem.lhs(0.5 * (X[:, i] + X[:, i + 1]))[0]
A[1, i] += -a / h
A[1, i + 1] += -a / h
A[0, i + 1] -= -a / h
A[1, 0] += kappa
A[1, n - 1] += kappa
b = sp.zeros([n, 1])
b[0, 0] = self.problem.rhs(
X[:, 0]) * h * 0.5 + kappa * self.problem.bcleft
b[n - 1, 0] = self.problem.rhs(
X[:, n - 1]) * h * 0.5 + kappa * self.problem.bcright
for i in xrange(1, n - 1):
b[i, 0] = self.problem.rhs(X[:, i]) * h
self.xi = spl.solveh_banded(A, b, lower=False)
self.solvetime = timer() - t0
logger.info('solvetime = {}'.format(self.solvetime))
def xtoif(x):
i, r = divmod(min(x, self.dmright - 1e-9) - self.dmleft, h)
return int(i), r / h
def u(x):
i, f = xtoif(x[0])
u = (1. - f) * self.xi[i, 0] + f * self.xi[i + 1, 0]
return sp.array([[u]])
def du(x):
i, f = xtoif(x[0])
du = (self.xi[i + 1, 0] - self.xi[i, 0]) / h
return sp.array([[du]])
def d2u(x):
return sp.array([[0.]])
self.soln = solution(self.D, u, du, d2u)
return
def minimize_Z_EL_parallel_Approx(resp, Bmat, l1):
"""Parallel implementation of Z_EL step
INPUT:
- resp: vector for (i,j) partial correlation estimates
- Bmat: tridiagonal matrix used to solve L2 problem
- l1, l2, rho: penalty parameters
"""
beta_hat = stVec(
solveh_banded(Bmat, resp, overwrite_ab=True, overwrite_b=True), l1)
return beta_hat
def test_02_complex(self):
# Solve
# [ 4 -j 2 0] [2-j 2+4j]
# [ j 4 -j 2] X = [4-j -1-j]
# [ 2 j 4 -j] [4+j 4+2j]
# [ 0 2 j 4] [2+j j]
#
ab = array([[0.0, 0.0, 2.0, 2.0], [-99, -1.0j, -1.0j, -1.0j],
[4.0, 4.0, 4.0, 4.0]])
b = array([[2 - 1j, 2 + 4j], [4.0 - 1j, -1 - 1j], [4.0 + 1j, 4 + 2j],
[2 + 1j, 1j]])
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0j], [1.0, 0.0], [1.0, 1.0], [0.0, 0.0]])
assert_array_almost_equal(x, expected)
def test_02_float32(self):
# Solve
# [ 4 1 2 0] [1 6]
# [ 1 4 1 2] X = [4 2]
# [ 2 1 4 1] [1 6]
# [ 0 2 1 4] [2 1]
#
ab = array(
[[0.0, 0.0, 2.0, 2.0], [-99, 1.0, 1.0, 1.0], [4.0, 4.0, 4.0, 4.0]],
dtype=float32)
b = array([[1.0, 6.0], [4.0, 2.0], [1.0, 6.0], [2.0, 1.0]],
dtype=float32)
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0], [1.0, 0.0], [0.0, 1.0], [0.0, 0.0]])
assert_array_almost_equal(x, expected)
def test_02_upper(self):
# Solve
# [ 4 1 0] [1 4]
# [ 1 4 1] X = [4 2]
# [ 0 1 4] [1 4]
#
ab = array([[-99, 1.0, 1.0],
[4.0, 4.0, 4.0]])
b = array([[1.0, 4.0],
[4.0, 2.0],
[1.0, 4.0]])
x = solveh_banded(ab, b)
expected = array([[0.0, 1.0],
[1.0, 0.0],
[0.0, 1.0]])
assert_array_almost_equal(x, expected)
def hpfilter02(x, penalty=1600): """Return: (cycle, trend), based on Heer and Maussner. Requires ``scipy`` (for sparse matrices). Parameters ---------- x : array-like The 1d timeseries to filter. penalty : float The Hodrick-Prescott smoothing parameter. A value of 1600 is suggested for quarterly data. Ravn and Uhlig suggest using a value of 6.25 (1600/4**4) for annual data and 129600 (1600*3**4) for monthly data. Assumes x is 1d; penalty is often called 'lambda'. Conceptualize the calculation as follows: eye <- diag( length(y) ) d2 <- diff( eye, d=2 ) z <- solve( eye + penalty * crossprod(d2), y ) """ #local m, i, nobs; import numpy as np from scipy.linalg import solveh_banded nobs = len(x) m = np.zeros((3, nobs)) #construct the banded matrix for i in range(nobs): m[0,i] = penalty; m[1,i] = -4*penalty; m[2,i] = 1 + 6*penalty; m[0,0] = 0 m[1,0] = 0 m[2,0] = 1+penalty m[0,1] = 0 m[1,1] = -2*penalty m[2,1] = 1+5*penalty m[1,nobs-1] = m[1,1] m[2,nobs-1] = m[2,0] m[2,nobs-2] = m[2,1] trend = solveh_banded(m, x) cycle = x - trend return cycle, trend
def hpfilter02(x, penalty=1600):
"""Return: (cycle, trend), based on Heer and Maussner.
Requires ``scipy`` (for sparse matrices).
Parameters
----------
x : array-like
The 1d timeseries to filter.
penalty : float
The Hodrick-Prescott smoothing parameter. A value of 1600 is
suggested for quarterly data. Ravn and Uhlig suggest using a value
of 6.25 (1600/4**4) for annual data and 129600 (1600*3**4) for monthly
data.
Assumes x is 1d; penalty is often called 'lambda'.
Conceptualize the calculation as follows:
eye <- diag( length(y) )
d2 <- diff( eye, d=2 )
z <- solve( eye + penalty * crossprod(d2), y )
"""
#local m, i, nobs;
import numpy as np
from scipy.linalg import solveh_banded
nobs = len(x)
m = np.zeros((3, nobs))
#construct the banded matrix
for i in range(nobs):
m[0, i] = penalty
m[1, i] = -4 * penalty
m[2, i] = 1 + 6 * penalty
m[0, 0] = 0
m[1, 0] = 0
m[2, 0] = 1 + penalty
m[0, 1] = 0
m[1, 1] = -2 * penalty
m[2, 1] = 1 + 5 * penalty
m[1, nobs - 1] = m[1, 1]
m[2, nobs - 1] = m[2, 0]
m[2, nobs - 2] = m[2, 1]
trend = solveh_banded(m, x)
cycle = x - trend
return cycle, trend
def test_01_upper(self):
warnings.simplefilter('ignore', category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 1D array.
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0])
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
# Remove the following part of this test in scipy 0.9.
a = array([[4.0, 1.0, 0.0], [1.0, 4.0, 1.0], [0.0, 1.0, 4.0]])
fac = zeros_like(a)
fac[range(3), range(3)] = c[-1]
fac[(0, 1), (1, 2)] = c[0, 1:]
assert_array_almost_equal(a, dot(fac.T, fac))
def test_01_upper(self):
warnings.simplefilter("ignore", category=DeprecationWarning)
# Solve
# [ 4 1 0] [1]
# [ 1 4 1] X = [4]
# [ 0 1 4] [1]
# with the RHS as a 1D array.
ab = array([[-99, 1.0, 1.0], [4.0, 4.0, 4.0]])
b = array([1.0, 4.0, 1.0])
c, x = solveh_banded(ab, b)
assert_array_almost_equal(x, [0.0, 1.0, 0.0])
# Remove the following part of this test in scipy 0.9.
a = array([[4.0, 1.0, 0.0], [1.0, 4.0, 1.0], [0.0, 1.0, 4.0]])
fac = zeros_like(a)
fac[range(3), range(3)] = c[-1]
fac[(0, 1), (1, 2)] = c[0, 1:]
assert_array_almost_equal(a, dot(fac.T, fac))
def test_02_complex(self):
warnings.simplefilter('ignore', category=DeprecationWarning)
# Solve
# [ 4 -j 0] [ -j 4j]
# [ j 4 -j] X = [4-j -1-j]
# [ 0 j 4] [4+j 4 ]
#
ab = array([[-99, -1.0j, -1.0j],
[4.0, 4.0, 4.0]])
b = array([[ -1j, 4.0j],
[4.0-1j, -1.0-1j],
[4.0+1j, 4.0]])
c, x = solveh_banded(ab, b)
expected = array([[0.0, 1.0j],
[1.0, 0.0],
[1.0, 1.0]])
assert_array_almost_equal(x, expected)
def solveBVP2(f,N):
h = 1.0/N
x = zeros(N-1)
for i in range(N-1):
x[i] = (i+1)*h
f_h = [f(num) for num in x]
diag_h = [2+h**2]*(N-1)
sub_diag_h = [-1]*(N-2)
a_h = array([[0]+sub_diag_h, diag_h])
u_h = solveh_banded(a_h,f_h)
figure()
plot(x,u_h)
xlabel('x')
ylabel('u')
title('n='+ str(N))
show()
def minimize_Z_EL(A, l1, l2, rho):
"""2nd step: Minimize Z step of the ADMM algorithm for solving SIGL
input:
- A is a list such that A[i] = thetaZ_parallel_helper_Approx[i] + U[i]
outout:
- new update of Z (ie a list)"""
# build banded matrix:
n = len(A)
Bmat = numpy.zeros((2, n))
Bmat[0, :] = -2 * l2 / rho
Bmat[1, 1:n - 1] = 1 + 4 * l2 / rho
Bmat[1, 0] = Bmat[1, n - 1] = 1 + 2 * l2 / rho
# convert A into an array:
A_ = numpy.zeros((len(A), A[0].shape[0], A[0].shape[0]))
for i in range(len(A)):
A_[i, :, :] = A[i]
sudoZ = A_[:]
for i in range(A[0].shape[0]):
for j in range(i, A[0].shape[0]):
resp = A_[:, i, j]
beta_hat = solveh_banded(Bmat,
resp,
overwrite_ab=True,
overwrite_b=True)
# apply soft thresholding:
beta_hat = [
math.copysign(1, x) * max(0,
abs(x) - l1) for x in beta_hat
]
sudoZ[:, i, j] = beta_hat
sudoZ[:, j, i] = beta_hat
# return to a list (terribly inefficient! I have to change this!)
Z_ = [None] * len(A)
for i in range(len(A)):
Z_[i] = sudoZ[i, :, :]
return Z_
def minimize_Z_EL_parallel_cython(resp, Bmat, l1, l2):
"""Parallel implementation of Z_EL step
INPUT:
- resp: vector for (i,j) partial correlation estimates
- Bmat: tridiagonal matrix used to solve L2 problem
- l1, l2, rho: penalty parameters
"""
beta_hat = solveh_banded(Bmat, resp, overwrite_ab=True, overwrite_b=True)
beta_hat = Z_shooting.Z_shooting(B=beta_hat,
y=resp,
l1=l1,
l2=l2,
tol=.1,
max_iter=100)
return beta_hat
def minimize_Z_EL_cython(A, l1, l2, rho):
""""""
# build banded matrix:
n = len(A)
Bmat = numpy.zeros((2, n))
Bmat[0, :] = -2 * l2 / rho
Bmat[1, 1:n - 1] = 1 + 4 * l2 / rho
Bmat[1, 0] = Bmat[1, n - 1] = 1 + 2 * l2 / rho
# convert A into an array:
A_ = numpy.zeros((len(A), A[0].shape[0], A[0].shape[0]))
for i in range(len(A)):
A_[i, :, :] = A[i]
sudoZ = A_[:]
for i in range(A[0].shape[0]):
for j in range(i, A[0].shape[0]):
resp = A_[:, i, j]
# get LS solution:
beta_hat = solveh_banded(Bmat,
resp,
overwrite_ab=True,
overwrite_b=True)
# shooting algorithm:
beta_hat = Z_shooting.Z_shooting(B=beta_hat,
y=resp,
l1=l1,
l2=l2,
tol=0.1,
max_iter=100)
sudoZ[:, i, j] = beta_hat
sudoZ[:, j, i] = beta_hat
# return to a list (terribly inefficient! I have to change this!)
Z_ = [None] * len(A)
for i in range(len(A)):
Z_[i] = sudoZ[i, :, :]
return Z_
def solve(self):
if(self.theSOE==None):
print('WARNING BandSPDLinLapackSolver::solve() - No LinearSOE object has been set. \n')
return -1
A = self.theSOE.A
B = self.theSOE.B
# first copy B into X ???
# for i in range(0, n):
# X[i] = B[i]
# now solve AX = B
if self.theSOE.factored == False:
# factored == cholesky decomposition
# factored and solve
self.theSOE.X = solveh_banded(A, B)
self.theSOE.factored = True
return 0
