Exemple #1
0
def solve_ide_implicit_from_kicks(kicks):
    A = construct_A(kicks)

    b = np.zeros(len(kicks), dtype=np.complex128)
    b[0] = 1

    a = splinalg.spsolve_triangular(
        # a = linalg.solve_triangular(
        A,
        b,
        lower=True,
        overwrite_b=True,
        # check_finite = False,
        overwrite_A=True,
    )

    # a, info = splinalg.bicgstab(A, b, x0 = np.ones_like(b))
    # print(info)

    return a, kicks
def solve_qr(A, b):
    # TODO: return x, R s.t. Ax = b, and |Ax - b|^2 = |Rx - d|^2 + |e|^2
    # https://github.com/theNded/PySPQR
    z, R, E, rank = rz(A, b, permc_spec='NATURAL')
    x = spsolve_triangular(R, z, lower=False)
    return x, R
matpath = "..//FD_class/Apy_UW1.npz"
save_npz(matpath, A)
#
# ### --------------- 2nd-order scheme --------------- ###
scheme = "UW2"
dt = CFL_safety * buw.get_CFL_limit_1d(scheme, hx, cx)
dt = 0.25
t = dt * np.arange(0, np.ceil(Tmax / dt) + 1)
nt = t.shape[0]
print("{}: nt = {}, dt = {:.2e}, nx = {}, hx = {:.2e}, cx = {}\n".format(
    scheme, nt, dt, nx, hx, cx))
print("{}: assembling...\n".format(scheme))
A, b = buw.get_UW2_1D(nt, dt, nx, hx, cx, u0_wrapper)
A = A.tocsr()
print("{}: solving...\n".format(scheme))
z = spsolve_triangular(A, b, lower=True)
u = z[0::2].copy()
#v = z[1::2].copy()

plt.plot(x, u[nx * (nt - 1)::], label=scheme)
matpath = "..//FD_class/Apy_UW2.npz"
save_npz(matpath, A)

### --------------- 4th-order scheme --------------- ###
scheme = "UW4"
dt = CFL_safety * buw.get_CFL_limit_1d(scheme, hx, cx)
dt = 0.25
t = dt * np.arange(0, np.ceil(Tmax / dt) + 1)
nt = t.shape[0]
print("{}: nt = {}, dt = {:.2e}, nx = {}, hx = {:.2e}, cx = {}\n".format(
    scheme, nt, dt, nx, hx, cx))
Exemple #4
0
def test_spsolve_triangular(matrices):
    A_dense, A_sparse, b = matrices
    A_sparse = sparse.tril(A_sparse)

    x = splin.spsolve_triangular(A_sparse, b)
    assert_allclose(A_sparse @ x, b)
Exemple #5
0
def GS_precond(x):
    return spla.spsolve_triangular(L, x, lower=True)
Exemple #6
0
 def get_z(r):
     PLz = datdot(Dinv, linalg.spsolve_triangular(L, r[P]))
     return linalg.spsolve_triangular(U, PLz, lower=False)[Pt]
Exemple #7
0
import numpy as np

import scipy.sparse.linalg as ssl

from scipy.sparse import csr_matrix
from ssl import *


A = csr_matrix([[3, 0, 0], [1, -1, 0], [2, 0, 1]], dtype=float)
B = np.array([[2, 0], [-1, 0], [2, 0]], dtype=float)

x = ssl.spsolve_triangular(A, B)

#np.allclose(A.dot(x), B)
Exemple #8
0
 def recover_inverse(theta):
     theta2 = theta**2
     Y, _ = Xmatrix(theta2)
     params = Y.dot(theta2)
     X, _ = Xmatrix(params)
     return spsolve_triangular(X, theta2, lower=False)
Exemple #9
0
def timing():
    algorithm_runtime = [[], [], [], [], [], [], []]
    matrix_size = []

    for m in range(1, 21):
        n = m * 100
        matrix_size.append(n)
        R, diagnal, factored, factored_d = initalize_matrix(n)
        b = -1 / (n**4) * np.ones((n, ))

        dense_R = R.toarray()
        dense_f = factored.toarray()
        s0 = time.perf_counter()
        r0 = sla.solve(dense_R, b)
        e0 = time.perf_counter()
        algorithm_runtime[0].append(e0 - s0)

        ab = np.ones((5, n))
        ab[2, :] = diagnal[0]
        ab[1, 1:] = diagnal[1]
        ab[3, 0:-1] = diagnal[2]
        ab[0, 2:] = diagnal[3]
        ab[4, 0:-2] = diagnal[4]
        s1 = time.perf_counter()
        r1 = sla.solve_banded((2, 2), ab, b)
        e1 = time.perf_counter()
        algorithm_runtime[1].append(e1 - s1)

        s2 = time.perf_counter()
        r2 = spsolve(R, b)
        e2 = time.perf_counter()
        algorithm_runtime[2].append(e2 - s2)

        transpose = np.transpose(dense_f)
        s3 = time.perf_counter()
        r3 = solve_triangular(dense_f, b, lower=False)
        r3 = solve_triangular(transpose, r3, lower=True)
        e3 = time.perf_counter()
        algorithm_runtime[3].append(e3 - s3)

        AB = np.ones((3, n))
        AB[2, :] = factored_d[0]
        AB[1, 1:] = factored_d[1]
        AB[0, 2:] = factored_d[2]
        AB_t = np.empty((3, n))
        AB_t[0, :] = factored_d[0]
        AB_t[1, :-1] = factored_d[1]
        AB_t[2, :-2] = factored_d[2]
        s4 = time.perf_counter()
        r4 = solve_banded((0, 2), AB, b)
        r4 = solve_banded((2, 0), AB_t, r4)
        e4 = time.perf_counter()
        algorithm_runtime[4].append(e4 - s4)

        factored_transpose = sp.csr_matrix(factored.transpose())
        s5 = time.perf_counter()
        r5 = spsolve_triangular(factored, b, lower=False)
        r5 = spsolve_triangular(factored_transpose, r5, lower=True)
        e5 = time.perf_counter()
        algorithm_runtime[5].append(e5 - s5)

        s6 = time.perf_counter()
        c, lower = sla.cho_factor(dense_R)
        r6 = sla.cho_solve((c, lower), b)
        e6 = time.perf_counter()
        algorithm_runtime[6].append(e6 - s6)

    plt.plot(matrix_size, algorithm_runtime[0], label='LU')
    plt.plot(matrix_size, algorithm_runtime[1], label='Banded')
    plt.plot(matrix_size, algorithm_runtime[2], label='Sparse LU')
    plt.plot(matrix_size, algorithm_runtime[3], label='R')
    plt.plot(matrix_size, algorithm_runtime[4], label='Banded R')
    plt.plot(matrix_size, algorithm_runtime[5], label='Sparse R')
    plt.plot(matrix_size, algorithm_runtime[6], label='Chol')
    plt.xlabel("Matrix size")
    plt.ylabel("Runtime")
    plt.title("Performance of different solver")
    plt.legend()
    plt.savefig("Q1.png")
    plt.show()
 def applyRight(self, vec):
     '''Apply the preconditioner from the right.'''
     # Apply L^{-1}
     u = spla.spsolve_triangular(self._L, vec, lower=True)
     # Apply L^{-T}
     return spla.spsolve_triangular(self._Lt, u, lower=False)
Exemple #11
0
 def update(self, current_x, residue):
     #return current_x + self.__forward_substitution(self.__triangular_P, residue)
     return current_x + spsolve_triangular(self.__triangular_P, residue)
# + pycharm={"name": "#%%\n"}
A * x

# + pycharm={"name": "#%%\n"}
A @ x

# + pycharm={"name": "#%%\n"}
diag = sparse.spdiags(x, 0, len(x), len(x))
(A @ diag).toarray()

# + [markdown] pycharm={"name": "#%% md\n"}
# #### Solve diagonal

# + pycharm={"name": "#%%\n"}
from scipy.sparse import linalg as splinalg
splinalg.spsolve_triangular(diag, x)

# + [markdown] pycharm={"name": "#%% md\n"}
# #### Solve lower triangular

# + pycharm={"name": "#%%\n"}
L = sparse.tril(np.random.randint(0, 3, (4, 4)), k=-1) + sparse.eye(4)
splinalg.spsolve_triangular(L, x, unit_diagonal=True)

# + pycharm={"name": "#%%\n"}
#### Solving upper triangular

# + pycharm={"name": "#%%\n"}
U = sparse.triu(np.random.randint(0, 3, (4, 4)), k=1) + sparse.eye(4)
splinalg.spsolve_triangular(U, x, lower=False, unit_diagonal=True)
Exemple #13
0
def preconditionedConjugateGradient(A, b, R, tolerance):
    Rinv = sparse.linalg.inv(R.tocsc())
    y,norms = conjugateGradient(Rinv.conj().T@A@Rinv,Rinv.conj().T@b,tolerance)
    x = linalg.spsolve_triangular(R.tocsr(),y,lower=False)
    return x,norms