Exemplo n.º 1
0
    def test_basic(self):
        h3 = array([[1.0, 1 / 2.0, 1 / 3.0], [1 / 2.0, 1 / 3.0, 1 / 4.0], [1 / 3.0, 1 / 4.0, 1 / 5.0]])
        assert_array_almost_equal(hilbert(3), h3)

        assert_array_equal(hilbert(1), [[1.0]])

        h0 = hilbert(0)
        assert_equal(h0.shape, (0, 0))
Exemplo n.º 2
0
    def test_basic(self):
        h3 = array([[1.0, 1 / 2., 1 / 3.], [1 / 2., 1 / 3., 1 / 4.],
                    [1 / 3., 1 / 4., 1 / 5.]])
        assert_array_almost_equal(hilbert(3), h3)

        assert_array_equal(hilbert(1), [[1.0]])

        h0 = hilbert(0)
        assert_equal(h0.shape, (0, 0))
Exemplo n.º 3
0
    def setUp(self):
        super().setUp()

        random = np.abs(np.hstack([np.random.rand(30), np.zeros(10)]))
        random[::-1].sort()
        random[0] += np.abs(random[1:]).sum()

        def up(x):
            return np.diag(np.arange(x) + 1)

        def down(x):
            return up(x)[::-1, ::-1]

        self.eigtol = 1e-3

        self.raw_examples = [
            # Square
            [up(1), down(1)],
            [up(3), down(2)],
            [up(2), down(3)],
            [la.hilbert(3), la.hilbert(3)],
            [self._rpsd(3), np.identity(2)],
            [self._rpsd(2), self._rpsd(3)],
            [up(3), Toeplitz(np.arange(10)[::-1] + 1)],
            [Toeplitz(random), self._rpsd(5)],
            [self._rpsd(100), self._rpsd(5)],
            [np.identity(2), np.identity(3) * self.eigtol / 2],
            [np.identity(2), np.identity(3) * self.eigtol],
            [np.identity(2), np.identity(3) * self.eigtol * 2],
            [self._rpsd(5), Toeplitz(utils.exp_decr_toep(10))],
            [self._rpsd(5), Toeplitz(utils.exp_decr_toep(100))],
            [
                Toeplitz(utils.exp_decr_toep(10)),
                Toeplitz(utils.exp_decr_toep(10))
            ],
            [np.random.rand(2, 2) for _ in range(4)],
            [up(2), down(2), up(2)],
            # Rectangle
            [np.random.rand(2, 3), up(1)],
            [np.random.rand(2, 3), np.random.rand(3, 2)],
            [np.random.rand(4, 3),
             np.random.rand(5, 2),
             np.random.rand(1, 2)]
        ]
        self.raw_examples = [[
            x if isinstance(x, Matrix) else NumpyMatrix(x) for x in ls
        ] for ls in self.raw_examples]

        self.examples = [reduce(Kronecker, x) for x in self.raw_examples]
Exemplo n.º 4
0
    def test_svd_maxiter(self):
        # check that maxiter works as expected: should not return accurate
        # solution after 1 iteration, but should with default `maxiter`
        if self.solver == 'propack':
            if not has_propack:
                pytest.skip("PROPACK not available")
        A = hilbert(6)
        k = 1
        u, s, vh = sorted_svd(A, k)

        if self.solver == 'arpack':
            message = "ARPACK error -1: No convergence"
            with pytest.raises(ArpackNoConvergence, match=message):
                svds(A, k, ncv=3, maxiter=1, solver=self.solver)
        elif self.solver == 'lobpcg':
            message = "Not equal to tolerance"
            with pytest.raises(AssertionError, match=message):
                with pytest.warns(UserWarning, match="Exited at iteration"):
                    u2, s2, vh2 = svds(A, k, maxiter=1, solver=self.solver)
                assert_allclose(np.abs(u2), np.abs(u))
        elif self.solver == 'propack':
            message = "k=1 singular triplets did not converge within"
            with pytest.raises(np.linalg.LinAlgError, match=message):
                svds(A, k, maxiter=1, solver=self.solver)

        u, s, vh = svds(A, k, solver=self.solver)  # default maxiter
        _check_svds(A, k, u, s, vh)
def uloha1(n):
    from scipy import linalg
    import numpy
    A = linalg.hilbert(n)
    xexact = numpy.ones((n, 1))
    b = A.dot(xexact)
    return A, b
Exemplo n.º 6
0
 def test_badcall(self):
     A = hilbert(5).astype(np.float32)
     assert_raises(ValueError,
                   pymatrixid.interp_decomp,
                   A,
                   1e-6,
                   rand=False)
Exemplo n.º 7
0
def problem4():
    n = 50
    H = splin.hilbert(n)
    Hi = splin.invhilbert(n)
    U, S, V = splin.svd(H)
    b = U[:, 0] * S[0]
    db = U[:, -1] * S[-1]
    print(S[-1])
    x = Hi.dot(b)
    dx = Hi.dot(db)
    k = S[0] / S[-1]
    print('Condition number of H50: {}'.format(k))
    dxx = np.linalg.norm(dx) / np.linalg.norm(x)
    dbb = np.linalg.norm(db) / np.linalg.norm(b)
    q = dxx / dbb
    print('Quotient of pertubations: {}'.format(q))
    print('Quotient: {}'.format(q / k))

    maxq = 0
    for j in range(0, 100):
        num_vecs = 1000
        b_collection = np.random.rand(n, num_vecs)
        db_collection = np.random.rand(n, num_vecs) * 1e-16
        x_collection = Hi.dot(b_collection)
        dx_collection = Hi.dot(db_collection)
        q_collection = np.zeros((num_vecs, 1))
        for k in range(0, num_vecs):
            q_collection[k] = np.linalg.norm(
                dx_collection[:, k]) * np.linalg.norm(b_collection[:, k])
            q_collection[k] /= np.linalg.norm(
                db_collection[:, k]) * np.linalg.norm(x_collection[:, k])
        maxq = max(maxq, max(q_collection))
        print(j)
    print(max(maxq))
Exemplo n.º 8
0
    def test_initialize_A_condition(self):
        dummy = hilbert(14)
        dummy = dummy[:, :-1]
        dummy[:, 0] = 1.0

        with pytest.raises(ValueError, match="The condition number .*"):
            _initialize_rot_matrix(dummy)
Exemplo n.º 9
0
def main():

    np.set_printoptions(precision=4)

    A = hilbert(4)
    print("\nA = \n", A)

    # without Wilkinson shift
    eigvals = get_eigvals(A, 'hilbert4')
    print_eigvals(eigvals)

    # with Wilkinson shift
    eigvals = get_eigvals(A, 'hilbert4_Wilkinson', True)
    print_eigvals(eigvals, True)

    v = np.array([i for i in range(15, 0, -1)])
    A = np.diag(v) + np.ones((15, 15))
    print("\nA = \n", A)

    # without Wilkinson shift
    eigvals = get_eigvals(A, 'diagones15')
    print_eigvals(eigvals)

    # with Wilkinson shift
    eigvals = get_eigvals(A, 'diagones15_Wilkinson', True)
    print_eigvals(eigvals, True)
Exemplo n.º 10
0
def test_conjgrad_solver(n):
    H = linalg.hilbert(n)
    x0 = matlib.ones([n, 1])
    b = H @ x0
    x = [0, 1]
    y1 = []
    y2 = []
    for xi in tqdm(x):
        x1, niter = conjgrad(H, b, ind=xi, eps=1e-15)
        y1.append(linalg.norm(x0 - x1, ord=np.inf))
        y2.append(niter)
        sleep(0.01)
    fig, left_axis = plt.subplots()
    right_axis = left_axis.twinx()
    plt.title("Conjugate gradient results for "+ \
        "$H_{"+str(n)+"}\bf{x}=\bf{b}$")
    left_axis.plot(x, y1, 'ro-')
    left_axis.set_xlabel("Preprocessing index")
    left_axis.set_ylabel("Infinite-norm error", color='r')
    left_axis.tick_params(axis='y', colors='r')
    right_axis.plot(x, y2, 'bo-')
    right_axis.set_xlabel("Same")
    right_axis.set_ylabel("Iteration step", color='b')
    right_axis.tick_params(axis='y', colors='b')
    plt.show()
Exemplo n.º 11
0
def test_simpleit_solver(n):
    H = linalg.hilbert(n)
    x0 = matlib.ones([n, 1])
    b = H @ x0
    x = np.arange(0.1, 2.0, 0.1)
    y1 = []
    y2 = []
    #x1, niter = jacobi(H,b)
    #print(x1,niter)
    for xi in tqdm(x):
        x1, niter = gs_sor(H, b, omg=xi, eps=1e-15)
        y1.append(math.log(linalg.norm(x0 - x1, ord=np.inf), 10))
        y2.append(niter)
        sleep(0.01)
    fig, left_axis = plt.subplots()
    right_axis = left_axis.twinx()
    plt.title("SOR results for $H_{" + str(n) + "}\bf{x}=\bf{b}$")
    left_axis.plot(x, y1, 'ro-')
    left_axis.set_xlabel("Relaxation coefficient")
    left_axis.set_ylabel("log(Infinite-norm error)", color='r')
    left_axis.tick_params(axis='y', colors='r')
    right_axis.plot(x, y2, 'bo-')
    right_axis.set_xlabel("Same")
    right_axis.set_ylabel("Iteration step", color='b')
    right_axis.tick_params(axis='y', colors='b')
    plt.show()
Exemplo n.º 12
0
def bench(Observations, Features):
    N = max(Observations, Features)
    k = 40

    # Create a known ill-conditionned matrix for testing
    # This requires 20k * 20k * 4 bytes (float32) = 1.6 GB
    start = time.time()
    H = hilbert(N)[:Observations, :Features]
    stop = time.time()

    print(f'Hilbert matrix creation too: {stop-start:>4.4f} seconds.')
    print(f'Matrix of shape: [{Observations}, {Features}]')
    print(f'Target SVD: [{Observations}, {k}]')

    start = time.time()
    (U, S, Vh) = pca(H, k=k, raw=True, n_iter=2, l=k + 5)  # Raw=True for SVD
    stop = time.time()

    print(f'Randomized SVD took: {stop-start:>4.4f} seconds')
    print("U: ", U.shape)
    print("S: ", S.shape)
    print("Vh: ", Vh.shape)

    print(
        "---------------------------------------------------------------------------------"
    )
Exemplo n.º 13
0
    def test_initialize_A_condition_warning(self):
        dummy = hilbert(6)
        dummy = dummy[:, :-1]
        dummy[:, 0] = 1.0

        with pytest.warns(UserWarning):
            _ = _initialize_rot_matrix(dummy)
Exemplo n.º 14
0
 def test_inverse(self):
     for n in xrange(1, 10):
         a = hilbert(n)
         b = invhilbert(n)
         # The Hilbert matrix is increasingly badly conditioned,
         # so take that into account in the test
         c = cond(a)
         assert_allclose(a.dot(b), eye(n), atol=1e-15*c, rtol=1e-15*c)
Exemplo n.º 15
0
def test_svd_which():
    # check that the which parameter works as expected
    x = hilbert(6)
    for which in ['LM', 'SM']:
        _, s, _ = sorted_svd(x, 2, which=which)
        ss = svds(x, 2, which=which, return_singular_vectors=False)
        ss.sort()
        assert_allclose(s, ss, atol=np.sqrt(1e-15))
Exemplo n.º 16
0
 def test_inverse(self):
     for n in xrange(1, 10):
         a = hilbert(n)
         b = invhilbert(n)
         # The Hilbert matrix is increasingly badly conditioned,
         # so take that into account in the test
         c = cond(a)
         assert_allclose(a.dot(b), eye(n), atol=1e-15 * c, rtol=1e-15 * c)
Exemplo n.º 17
0
def Norm_Wska(n):
    c = hilbert(n)

    norm = np.linalg.norm(c)
    wska = np.linalg.cond(c)

    print("Wskażnik uwarunkowania = ", wska)
    print("Norma = ", norm)
def test_svd_which():
    # check that the which parameter works as expected
    x = hilbert(6)
    for which in ['LM', 'SM']:
        _, s, _ = sorted_svd(x, 2, which=which)
        ss = svds(x, 2, which=which, return_singular_vectors=False)
        ss.sort()
        assert_allclose(s, ss, atol=np.sqrt(1e-15))
Exemplo n.º 19
0
def main():
    a = np.asmatrix(la.hilbert(4))
    h = tridiag(a)
    h_std = la.hessenberg(a)
    print("Solution:")
    print(h)
    print('\n')
    print("Standard Solution:")
    print(h_std)
def test_svd_maxiter():
    # check that maxiter works as expected
    x = hilbert(6)
    # ARPACK shouldn't converge on such an ill-conditioned matrix with just
    # one iteration
    assert_raises(ArpackNoConvergence, svds, x, 1, maxiter=1, ncv=3)
    # but 100 iterations should be more than enough
    u, s, vt = svds(x, 1, maxiter=100, ncv=3)
    assert_allclose(s, [1.7], atol=0.5)
Exemplo n.º 21
0
def funkcja(n):
    h = hilbert(n)

    norm = np.linalg.norm(h)
    cond = np.linalg.cond(h)

    print("Dla macierzy Hilberta " + str(n) + "x" + str(n))
    print("Norma " + " = " + str(norm))
    print("Wskaznik uwarunkowania " + " = " + str(cond))
Exemplo n.º 22
0
def test_svd_maxiter():
    # check that maxiter works as expected
    x = hilbert(6)
    # ARPACK shouldn't converge on such an ill-conditioned matrix with just
    # one iteration
    assert_raises(ArpackNoConvergence, svds, x, 1, maxiter=1)
    # but 100 iterations should be more than enough
    u, s, vt = svds(x, 1, maxiter=100)
    assert_allclose(s, [1.7], atol=0.5)
Exemplo n.º 23
0
def main():
    # create the matrix and the right hand sides
    N = 1000
    A = sp.coo_matrix(
        hilbert(N) + np.identity(N)
    )  # a well-condition, symmetric, positive-definite matrix with off-diagonal entries
    true_x1 = np.arange(N)
    true_x2 = np.array(list(reversed(np.arange(N))))
    b1 = A * true_x1
    b2 = A * true_x2

    # solve
    solver = MumpsCentralizedAssembledLinearSolver()
    x1, res = solver.solve(A, b1)
    x2, res = solver.solve(A, b2)
    assert np.allclose(x1, true_x1)
    assert np.allclose(x2, true_x2)

    # only perform factorization once
    solver = MumpsCentralizedAssembledLinearSolver()
    solver.do_symbolic_factorization(A)
    solver.do_numeric_factorization(A)
    x1, res = solver.do_back_solve(b1)
    x2, res = solver.do_back_solve(b2)
    assert np.allclose(x1, true_x1)
    assert np.allclose(x2, true_x2)

    # Tell Mumps the matrix is symmetric
    # Note that the answer will be incorrect if both the lower
    # and upper portions of the matrix are given.
    solver = MumpsCentralizedAssembledLinearSolver(sym=2)
    A_lower_triangular = sp.tril(A)
    x1, res = solver.solve(A_lower_triangular, b1)
    assert np.allclose(x1, true_x1)

    # Tell Mumps the matrix is symmetric and positive-definite
    solver = MumpsCentralizedAssembledLinearSolver(sym=1)
    A_lower_triangular = sp.tril(A)
    x1, res = solver.solve(A_lower_triangular, b1)
    assert np.allclose(x1, true_x1)

    # Set options
    solver = MumpsCentralizedAssembledLinearSolver(
        icntl_options={11: 2})  # compute error stats
    solver.set_cntl(2,
                    1e-4)  # set the stopping criteria for iterative refinement
    solver.set_icntl(
        10, 5
    )  # set the maximum number of iterations for iterative refinement to 5
    x1, res = solver.solve(A, b1)
    assert np.allclose(x1, true_x1)

    # Get information after the solve
    print('Number of iterations of iterative refinement performed: ',
          solver.get_infog(15))
    print('scaled residual: ', solver.get_rinfog(6))
Exemplo n.º 24
0
def solve(size, delta=0):

    print(f'size = {size}, delta = {delta}')
    H = hilbert(size)
    x = np.zeros(size) + delta + 1
    b = H.dot(x)
    _H = cholesky(H, size)
    xp = np.linalg.solve(_H.T, np.linalg.solve(_H, b))
    print(f'||r||_inf: {abs(b - H.dot(xp)).max()}')
    print(f'||delta||_inf: {abs(xp - x).max()}')
Exemplo n.º 25
0
def createHilbertFractionMatrix(sq_size):
    fract_hill = []
    hill = hilbert(sq_size)  # for decimals just use this line (from library)
    for h in hill:
        for i in h:
            fract_hill.append(Fraction(str(i)))

    reshaped_array = np.split(np.asarray(fract_hill), sq_size)
    print "The Hilbert Matrix shape: " + str(
        np.asarray(reshaped_array).shape) + "\n"
    return np.asmatrix(reshaped_array)
Exemplo n.º 26
0
def hilbertLA(n):
    """ Utilisise scipy.linalg for populating an nxn hilbert matrix
    Param:
        n : int
            square size of matrix

    Returns:
        H : matrix
            The hilbert matrix
    """
    return lasc.hilbert(n)
Exemplo n.º 27
0
def test_arlsgt():
    x = np.array([6.0, 5.0, 4.0, 3.0])
    A = hilbert(5)
    A = np.delete(A, 4, 1)  # delete last column
    b = A @ x
    G = np.array([0.0, 0.0, 0.0, 1.0])
    h = 5
    x = arlsgt(A, b, G, h)[0]
    res = A @ x - b
    assert_(norm(res) < 0.002, "Residual too large in arlsgt hilbert test.")
    return
Exemplo n.º 28
0
def get_hilbert_cond2(n):
    x = []
    y = []
    for i in range(2, n):
        cur_mat = hilbert(i)
        cur_cond = cond(cur_mat, 2)
        x.append(i)
        y.append(math.log(cur_cond))
    plt.scatter(x, y)
    plt.xlabel('order')
    plt.ylabel('log(cond2)')
    plt.show()
Exemplo n.º 29
0
 def testIllConditioned(self):
     # Modified G-S handles ill-conditioned matrices much better (numerically)
     # than original G-S.
     dim = 200
     mat = tf.eye(200, dtype=tf.float64) * 1e-5 + scipy_linalg.hilbert(dim)
     mat = tf.math.l2_normalize(mat, axis=-1)
     ortho = tfp.math.gram_schmidt(mat)
     xtx = tf.matmul(ortho, ortho, transpose_a=True)
     self.assertAllClose(
         0.,
         tf.linalg.norm(tf.eye(dim, dtype=tf.float64) - xtx,
                        ord='fro',
                        axis=(-1, -2)))
Exemplo n.º 30
0
def Hilbert_test(dim, func):
    A = hilbert(dim)
    eigenvec, eigenval, iterations = func(A)

    residue = np.linalg.norm(A.dot(eigenvec) - eigenval * eigenvec)

    eigenval_real, eigenvec_real = Hilbert_dominant_eigenpair_dict[dim][
        1], Hilbert_dominant_eigenpair_dict[dim][0]
    eigenvec_real = eigenvec_real / np.linalg.norm(eigenvec_real)
    dist = np.linalg.norm(eigenvec_real - eigenvec)
    residue_real_val = np.linalg.norm(
        A.dot(eigenvec) - eigenval_real * eigenvec)
    return residue, dist, residue_real_val
Exemplo n.º 31
0
def draw_hilbert_cond(max_n=15):
    """ This function draws the condition for the Hilbert matrix.

    Parameters
    ----------
    max_n : int
        The plot is drawn from 3 upto this int.
    """
    condition = []
    for i in range(3, max_n):
        condition.append(np.linalg.cond(hilbert(i), np.inf))

    plt.loglog(range(3, max_n),
               [np.linalg.cond(hilbert(i), np.inf) for i in range(3, max_n)],
               label="Condition of the Hilbert Matrix",
               linewidth=3)
    axis = plt.gca()
    axis.set_yscale('log')

    plt.xlabel("Number of Rows/Columns of the Hilbert Matrix", fontsize=18)
    plt.ylabel("Condition", fontsize=18)
    plt.legend(fontsize=24)
    plt.show()
Exemplo n.º 32
0
Arquivo: hw6.py Projeto: shawsa/m565
def p1():
    cond = []
    est = []
    ratio = []
    for n in range(5, 20):
        H = la.hilbert(n)
        K = np.linalg.cond(H, p=np.inf)
        cond.append(K)
        E = (1 + np.sqrt(2))**(4 * n) / np.sqrt(n)
        est.append(E)
        ratio.append(K / E)
    latex_table((range(5,
                       len(cond) + 5), cond, est, ratio),
                ('$n$', '$K(H_n)$', 'est', '$K(H_n)/$est'))
Exemplo n.º 33
0
def solve(n, delta=0):
    print('n =', n, ', delta =', delta)
    H = hilbert(n)
    x = np.zeros(n) + 1 + delta
    b = H.dot(x)
    L = cholesky(H)
    # Hx = b, H = LL'
    # LL'x = b
    # x = L'^-1 L^-1 b
    xp = np.linalg.solve(L.T, np.linalg.solve(L, b))
    r = b - H.dot(xp)
    dx = xp - x
    print('||r||_inf:', abs(r).max())
    print('||dx||_inf:', abs(dx).max())
Exemplo n.º 34
0
    def __init__(self, dim, r_s=None):
        """
        Initialisiert ein neues Hilbert-Objekt.

        Input:

            dim (int):
                Dimension der Hilbertmatrix.

        Return: -
        """
        self.dim = dim
        self.hil_matr = lina.hilbert(self.dim)
        self.inv_hil_matr = lina.invhilbert(self.dim)
        self.r_s = r_s
Exemplo n.º 35
0
Arquivo: no3.py Projeto: hallliu/f2013
def run_stats(dimension):
    matrices = {}
    # Generation of the 4 relevant matrices
    matrices['normal'] = np.matrix(np.random.randn(dimension, dimension))
    matrices['hilbert'] = np.matrix(sp.hilbert(dimension))
    matrices['pascal'] = np.matrix(pascal(dimension))
    if dimension != 100:
        matrices['magic'] = np.matrix(magic(dimension))
    else:
        matrices['magic'] = np.matrix(np.identity(100))

    x = np.matrix(np.ones((dimension,1)))

    data = {} # these are just bookkeeping things that keep track of variables for future use
    for name, matr in matrices.items():
        this_matrix_data = {}

        b = matr * x
        try:
            xhat = sp.solve(matr, b)
            xhat1 = np.linalg.inv(matr) * b
        except np.linalg.LinAlgError:
            xhat = x
            xhat1 = x

        this_matrix_data['delta_b'] = matr * xhat - b
        norm_data = {}

        # Loop through the three norms we're asked to do
        for norm_type in [1, 2, np.inf]:
            values = {}
            values['x_relative_error'] = sp.norm(x - xhat, norm_type) / sp.norm(x, norm_type)
            values['x_relative_error_inv'] = sp.norm(x - xhat1, norm_type) / sp.norm(x, norm_type)

            try:
                values['condition_no'] = np.linalg.cond(matr, norm_type)
            except:
                values['condition_no'] = 0

            values['cond_rel_b_err'] = values['condition_no'] * (sp.norm(this_matrix_data['delta_b'], norm_type) / sp.norm(b, norm_type))
            norm_data[norm_type] = values

        this_matrix_data['norm_dep_vals'] = norm_data
        data[name] = this_matrix_data

    return data
Exemplo n.º 36
0
def demo(n):
    from numpy import random
    from scipy import linalg
    A = random.randn(n, n)
    x = random.randn(n)
    
    print('\n\t\t Random matrix of dimension', n)
    showerr(A, x)

    A = linalg.hilbert(n)
    print('\n\t\t Hilbert matrix of dimension', n)
    showerr(A, x)

    from . import cond
    A = cond.laplace(n)
    print('\n\t\t Disc Laplacian of dimension', n)
    showerr(A, x)
Exemplo n.º 37
0
def main():
    for n in range(12, 20):
        H = hilbert(n)
        x = [1000 for _ in range(n)]
        b = H.dot(x)

        x = np.linalg.solve(H, b)

        Hx = H.dot(x)
        r = b - Hx

        print np.linalg.norm(r, np.inf)

        iter = 0
        while np.linalg.norm(r, np.inf) > 1e-5 and iter < 50:
            z = np.linalg.solve(H, r)
            x = x + z
            Ax = H.dot(x)
            r = b - Ax
            iter += 1

        print iter, x
Exemplo n.º 38
0
 def time_hilbert(self, size):
     sl.hilbert(size)
Exemplo n.º 39
0
def test_svd_return():
    # check that the return_singular_vectors parameter works as expected
    x = hilbert(6)
    _, s, _ = sorted_svd(x, 2)
    ss = svds(x, 2, return_singular_vectors=False)
    assert_allclose(s, ss)
Exemplo n.º 40
0
Arquivo: e1a6.py Projeto: laevar/mapy
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 25 19:08:23 2013

@author: jschulz1
"""

import numpy as np  # NumPy (multidimensional arrays, linear algebra, ...)
import scipy as sp  # SciPy (signal and image processing library)
import matplotlib as mpl         # Matplotlib (2D/3D plotting library)
import matplotlib.pyplot as plt  # Matplotlib's pyplot: MATLAB-like syntax
from pylab import *              # Matplotlib's pylab interface

from scipy.linalg import hilbert

A = hilbert(50)
print dot(A[:,2].T,ones((len(A[:,2]),)))
# alternativ
print sum(A[:,2])
Exemplo n.º 41
0
    if isspmatrix(m):
        m = m.todense()
    u, s, vh = svd(m)
    if which == 'LM':
        ii = np.argsort(s)[-k:]
    elif which == 'SM':
        ii = np.argsort(s)[:k]
    else:
        raise ValueError("unknown which=%r" % (which,))
    return u[:, ii], s[ii], vh[ii]


def svd_estimate(u, s, vh):
    return np.dot(u, np.dot(np.diag(s), vh))


n = 5
x = hilbert(n)
# u,s,vh = svd(x)
# s[2:-1] = 0
# x = svd_estimate(u, s, vh)

which = 'SM'
k = 2
u, s, vh = sorted_svd(x, k, which=which)
su,ss,svh = old_svds(x, k, which=which)
ssu,sss,ssvh = new_svds(x, k, which=which)

m_hat = svd_estimate(u, s, vh)
sm_hat = svd_estimate(su, ss, svh)
ssm_hat = svd_estimate(ssu, sss, ssvh)
Exemplo n.º 42
0
np.linalg.cond(A)
np.linalg.cond(A_delta)
b=np.matrix('1;1;1') #noise free right hand side


l=.01
k=100
ip.invert(A_delta,b,k,l)
np.linalg.pinv(A_delta)*b

#####################
#Example 3 Hilbert A
#####################

from scipy.linalg import hilbert
A=hilbert(3)
np.linalg.cond(A)
x=np.matrix('1;1;1')
b=A*x

#Now add noise to b of size ro
# dimension of A
r= np.matrix(A.shape)[0,0]
nb= np.random.normal(0, .50, r) #compute vector of normal variants mean=0,std=0.1
#nb= np.random.normal(0, 50, r) #compute vector of normal variants mean=0,std=50
#note that nb is 3 by 1, so we need to flip it
be=b+np.matrix(nb).transpose() #add noise

l=1
k=100
    for k in range(n-1,-1,-1):
        b[k] = (b[k] - np.dot(L[k+1:n,k],b[k+1:n]))/L[k,k]
    return b

choleski(a2)
print ("The answer for problem 11 is:")
print (choleskiSol(a2,b2))
"""





#Problem 15
#Code is not working correctly. I did not have enough time to finish it.
a3 = hilbert(2) 
b3 = []
x = []
i = 0
actNorm = 1*10**-6

while True:
    b3.append(a3[i].sum())
    x.append([1])
    xNorm = np.linalg.norm(x, np.inf)
    xApprox = np.linalg.solve(a3, b3)
    xHat = np.linalg.norm(xApprox, np.inf)
    approxErr = xNorm - xHat
    if abs(approxErr) < actNorm:
        break
    i = i + 1
Exemplo n.º 44
0
B


# Out[3]:

#     array([[ 1.,  2.,  3.,  4.],
#            [ 2.,  3.,  4.,  5.],
#            [ 3.,  4.,  5.,  6.],
#            [ 4.,  5.,  6.,  7.]])

# In[4]:

A = 1/B

from scipy.linalg import hilbert
A2 = hilbert(n)

print "difference: %g" % la.norm(A-A2)
print "cond: %g" % np.linalg.cond(A)


# Out[4]:

#     difference: 0
#     cond: 15513.7
# 

#     /usr/lib/pymodules/python2.7/numpy/oldnumeric/__init__.py:11: ModuleDeprecationWarning: The oldnumeric module will be dropped in Numpy 1.9
#       warnings.warn(_msg, ModuleDeprecationWarning)
# 
Exemplo n.º 45
0
 def test_badcall(self):
     A = hilbert(5).astype(np.float32)
     assert_raises(ValueError, pymatrixid.interp_decomp, A, 1e-6, rand=False)
Exemplo n.º 46
0
    def check_id(self, dtype):
        # Test ID routines on a Hilbert matrix.

        # set parameters
        n = 300
        eps = 1e-12

        # construct Hilbert matrix
        A = hilbert(n).astype(dtype)
        if np.issubdtype(dtype, np.complexfloating):
            A = A * (1 + 1j)
        L = aslinearoperator(A)

        # find rank
        S = np.linalg.svd(A, compute_uv=False)
        try:
            rank = np.nonzero(S < eps)[0][0]
        except:
            rank = n

        # print input summary
        _debug_print("Hilbert matrix dimension:        %8i" % n)
        _debug_print("Working precision:               %8.2e" % eps)
        _debug_print("Rank to working precision:       %8i" % rank)

        # set print format
        fmt = "%8.2e (s) / %5s"

        # test real ID routines
        _debug_print("-----------------------------------------")
        _debug_print("Real ID routines")
        _debug_print("-----------------------------------------")

        # fixed precision
        _debug_print("Calling iddp_id / idzp_id  ...",)
        t0 = time.clock()
        k, idx, proj = pymatrixid.interp_decomp(A, eps, rand=False)
        t = time.clock() - t0
        B = pymatrixid.reconstruct_matrix_from_id(A[:, idx[:k]], idx, proj)
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddp_aid / idzp_aid ...",)
        t0 = time.clock()
        k, idx, proj = pymatrixid.interp_decomp(A, eps)
        t = time.clock() - t0
        B = pymatrixid.reconstruct_matrix_from_id(A[:, idx[:k]], idx, proj)
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddp_rid / idzp_rid ...",)
        t0 = time.clock()
        k, idx, proj = pymatrixid.interp_decomp(L, eps)
        t = time.clock() - t0
        B = pymatrixid.reconstruct_matrix_from_id(A[:, idx[:k]], idx, proj)
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        # fixed rank
        k = rank

        _debug_print("Calling iddr_id / idzr_id  ...",)
        t0 = time.clock()
        idx, proj = pymatrixid.interp_decomp(A, k, rand=False)
        t = time.clock() - t0
        B = pymatrixid.reconstruct_matrix_from_id(A[:, idx[:k]], idx, proj)
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddr_aid / idzr_aid ...",)
        t0 = time.clock()
        idx, proj = pymatrixid.interp_decomp(A, k)
        t = time.clock() - t0
        B = pymatrixid.reconstruct_matrix_from_id(A[:, idx[:k]], idx, proj)
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddr_rid / idzr_rid ...",)
        t0 = time.clock()
        idx, proj = pymatrixid.interp_decomp(L, k)
        t = time.clock() - t0
        B = pymatrixid.reconstruct_matrix_from_id(A[:, idx[:k]], idx, proj)
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        # check skeleton and interpolation matrices
        idx, proj = pymatrixid.interp_decomp(A, k, rand=False)
        P = pymatrixid.reconstruct_interp_matrix(idx, proj)
        B = pymatrixid.reconstruct_skel_matrix(A, k, idx)
        assert_(np.allclose(B, A[:,idx[:k]], eps))
        assert_(np.allclose(B.dot(P), A, eps))

        # test SVD routines
        _debug_print("-----------------------------------------")
        _debug_print("SVD routines")
        _debug_print("-----------------------------------------")

        # fixed precision
        _debug_print("Calling iddp_svd / idzp_svd ...",)
        t0 = time.clock()
        U, S, V = pymatrixid.svd(A, eps, rand=False)
        t = time.clock() - t0
        B = np.dot(U, np.dot(np.diag(S), V.T.conj()))
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddp_asvd / idzp_asvd...",)
        t0 = time.clock()
        U, S, V = pymatrixid.svd(A, eps)
        t = time.clock() - t0
        B = np.dot(U, np.dot(np.diag(S), V.T.conj()))
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddp_rsvd / idzp_rsvd...",)
        t0 = time.clock()
        U, S, V = pymatrixid.svd(L, eps)
        t = time.clock() - t0
        B = np.dot(U, np.dot(np.diag(S), V.T.conj()))
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        # fixed rank
        k = rank

        _debug_print("Calling iddr_svd / idzr_svd ...",)
        t0 = time.clock()
        U, S, V = pymatrixid.svd(A, k, rand=False)
        t = time.clock() - t0
        B = np.dot(U, np.dot(np.diag(S), V.T.conj()))
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddr_asvd / idzr_asvd ...",)
        t0 = time.clock()
        U, S, V = pymatrixid.svd(A, k)
        t = time.clock() - t0
        B = np.dot(U, np.dot(np.diag(S), V.T.conj()))
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        _debug_print("Calling iddr_rsvd / idzr_rsvd ...",)
        t0 = time.clock()
        U, S, V = pymatrixid.svd(L, k)
        t = time.clock() - t0
        B = np.dot(U, np.dot(np.diag(S), V.T.conj()))
        _debug_print(fmt % (t, np.allclose(A, B, eps)))
        assert_(np.allclose(A, B, eps))

        # ID to SVD
        idx, proj = pymatrixid.interp_decomp(A, k, rand=False)
        Up, Sp, Vp = pymatrixid.id_to_svd(A[:, idx[:k]], idx, proj)
        B = U.dot(np.diag(S).dot(V.T.conj()))
        assert_(np.allclose(A, B, eps))

        # Norm estimates
        s = svdvals(A)
        norm_2_est = pymatrixid.estimate_spectral_norm(A)
        assert_(np.allclose(norm_2_est, s[0], 1e-6))

        B = A.copy()
        B[:,0] *= 1.2
        s = svdvals(A - B)
        norm_2_est = pymatrixid.estimate_spectral_norm_diff(A, B)
        assert_(np.allclose(norm_2_est, s[0], 1e-6))

        # Rank estimates
        B = np.array([[1, 1, 0], [0, 0, 1], [0, 0, 1]], dtype=dtype)
        for M in [A, B]:
            ML = aslinearoperator(M)

            rank_np = np.linalg.matrix_rank(M, 1e-9)
            rank_est = pymatrixid.estimate_rank(M, 1e-9)
            rank_est_2 = pymatrixid.estimate_rank(ML, 1e-9)

            assert_(rank_est >= rank_np)
            assert_(rank_est <= rank_np + 10)

            assert_(rank_est_2 >= rank_np)
            assert_(rank_est_2 <= rank_np + 10)
Exemplo n.º 47
0
print(A)


#b)
b=np.array([npr.rand(),npr.rand(),npr.rand()])
print(b)
#c)
x=solve(A,b)
print(x)

#sprawdzenie poprawności rozwiązania
print(npl.norm(np.dot(A,x)-b))
# powinno wyjść coś bliskiego zeru

#d)
H=sclin.hilbert(4)
print(H)

#e)
c=np.array([npr.rand(),npr.rand(),npr.rand(),npr.rand()])
print(c)

#f)
y=solve(H,c)
print(y)

#sprawdzenie poprawności rozwiązania
print(npl.norm(np.dot(H,y)-c))
# powinno wyjść coś bliskiego zeru

#g
Exemplo n.º 48
0
            r = linalg.norm([ A[j , k] , A[j + 1, k] ], 2)
            if r>0:
                c=A[j, k]/r; s=A[j + 1, k]/r
                A[[j, j + 1],(k + 1):(n+1)] = \
                    mat([[c, s],[-s, c]])* \
                    A[[j, j + 1],(k + 1):(n+1)]
            A[j, k] = r; A[j+1,k] = 0
    z = A[:, n].copy()
    rbacksolve(A[:, :n], z, n)
    return z
    
if __name__ == '__main__':
    
    N = 20
    
    H_ = hilbert(N)
    xe_ = mat(ones(N)).T
    err = empty(N)
    errAlt = empty(N)
    iterations = arange(N)
    for n in iterations:
#        H = H_[:n+1, :n+1]; xe = xe_[:n+1]
        H = hilbert(n+1); xe = mat(ones(n+1)).T
        b = H*xe
        x = rotsolve(H, b)
        err[n] = linalg.norm(x - xe, 2)
        y = rotsolveAlt(H, b)
        errAlt[n] = linalg.norm(y - xe, 2)
    
    plt.plot(1+iterations, err, 'b')
    plt.plot(1 +iterations, errAlt, 'r')