feectools 0.1.0__py3-none-any.whl

feectools/linalg/tests/test_matrix_free.py

@@ -0,0 +1,128 @@
+import pytest
+import numpy as np
+
+from feectools.linalg.block import BlockLinearOperator, BlockVector, BlockVectorSpace
+from feectools.linalg.basic import LinearOperator, ZeroOperator, IdentityOperator, ComposedLinearOperator, SumLinearOperator, PowerLinearOperator, ScaledLinearOperator
+from feectools.linalg.basic import MatrixFreeLinearOperator
+from feectools.linalg.stencil import StencilVectorSpace, StencilVector, StencilMatrix
+from feectools.linalg.solvers import ConjugateGradient, inverse
+from feectools.ddm.cart       import DomainDecomposition, CartDecomposition
+
+from feectools.linalg.tests.test_linalg import get_StencilVectorSpace, get_positive_definite_StencilMatrix, assert_pos_def
+
+def get_random_StencilMatrix(domain, codomain):
+
+    np.random.seed(2)
+    V = domain
+    W = codomain
+    assert isinstance(V, StencilVectorSpace)
+    assert isinstance(W, StencilVectorSpace)
+    [n1, n2] = V._npts
+    [p1, p2] = V._pads
+    [P1, P2] = V._periods
+    assert (P1 == False) and (P2 == False)
+
+    [m1, m2] = W._npts
+    [q1, q2] = W._pads
+    [Q1, Q2] = W._periods
+    assert (Q1 == False) and (Q2 == False)
+
+    S = StencilMatrix(V, W)
+
+    for i in range(0, q1+1):
+        if i != 0:
+            for j in range(-q2, q2+1):
+                S[:, :, i, j] = 2*np.random.random()-1
+        else:
+            for j in range(1, q2+1):
+                S[:, :, i, j] = 2*np.random.random()-1
+    S.remove_spurious_entries()
+
+    return S
+
+def get_random_StencilVector(V):
+    np.random.seed(3)
+    assert isinstance(V, StencilVectorSpace)
+    [n1, n2] = V._npts
+    v = StencilVector(V)
+    for i in range(n1):
+        for j in range(n2):
+            v[i,j] = np.random.random()
+    return v
+
+#===============================================================================
+@pytest.mark.parametrize('n1', [6, 5])
+@pytest.mark.parametrize('n2', [6, 8])
+@pytest.mark.parametrize('p1', [1, 2])
+@pytest.mark.parametrize('p2', [2, 3])
+
+def test_fake_matrix_free(n1, n2, p1, p2):
+    P1 = False
+    P2 = False
+    m1 = (n2+n1)//2
+    m2 = n1+1
+    q1 = p1 # using same degrees because both spaces must have same padding for now
+    q2 = p2 
+    V1 = get_StencilVectorSpace([n1, n2], [p1, p2], [P1, P2])
+    V2 = get_StencilVectorSpace([m1, m2], [q1, q2], [P1, P2])
+    S = get_random_StencilMatrix(codomain=V2, domain=V1)
+    O = MatrixFreeLinearOperator(codomain=V2, domain=V1, dot=lambda v: S @ v)
+
+    print(f'O.domain = {O.domain}')
+    print(f'S.domain = {S.domain}')
+    print(f'V1:      = {V1}')
+    v = get_random_StencilVector(V1)
+    tol = 1e-10
+    y = S.dot(v)
+    x = O.dot(v)
+    print(f'error = {np.linalg.norm( (x - y).toarray() )}')
+    assert np.linalg.norm( (x - y).toarray() ) < tol
+    O.dot(v, out=x)
+    print(f'error = {np.linalg.norm( (x - y).toarray() )}')
+    assert np.linalg.norm( (x - y).toarray() ) < tol
+
+@pytest.mark.parametrize('solver', ['cg', 'pcg', 'bicg', 'minres', 'lsmr'])
+
+def test_solvers_matrix_free(solver):
+    print(f'solver = {solver}')
+    n1 = 4
+    n2 = 3
+    p1 = 5
+    p2 = 2
+    P1 = False
+    P2 = False
+    V = get_StencilVectorSpace([n1, n2], [p1, p2], [P1, P2])
+    A_SM = get_positive_definite_StencilMatrix(V)
+    assert_pos_def(A_SM)
+    AT_SM = A_SM.transpose()
+    A = MatrixFreeLinearOperator(domain=V, codomain=V, dot=lambda v: A_SM @ v, dot_transpose=lambda v: AT_SM @ v)
+
+    # get rhs and solution
+    b = get_random_StencilVector(V)
+    x = A.dot(b)
+
+    # Create Inverse with A
+    tol = 3e-5
+    if solver == 'pcg':
+        inv_diagonal = A_SM.diagonal(inverse=True)
+        A_inv = inverse(A, solver, pc=inv_diagonal, tol=tol)
+    else:
+        A_inv = inverse(A, solver, tol=tol)    
+
+    AA = A_inv._A
+    xx = AA.dot(b)
+    print(f'norm(xx) = {np.linalg.norm( xx.toarray() )}')
+    print(f'norm(x)  = {np.linalg.norm( x.toarray() )}')
+
+    # Apply inverse and check
+    y = A_inv @ x
+    error = np.linalg.norm( (b - y).toarray())
+    assert np.linalg.norm( (b - y).toarray() ) < tol
+
+#===============================================================================
+# SCRIPT FUNCTIONALITY
+#===============================================================================
+if __name__ == "__main__":
+    # import sys
+    # pytest.main( sys.argv )
+    test_fake_matrix_free(5, 4, 1, 2)

feectools/linalg/tests/test_solvers.py

@@ -0,0 +1,213 @@
+
+import numpy as np
+import pytest
+from feectools.linalg.solvers import inverse
+from feectools.linalg.stencil import StencilVectorSpace, StencilMatrix, StencilVector
+from feectools.linalg.basic import LinearSolver
+from feectools.ddm.cart import DomainDecomposition, CartDecomposition
+
+
+def define_data_hermitian(n, p, dtype=float):
+    domain_decomposition = DomainDecomposition([n - p], [False])
+    cart = CartDecomposition(domain_decomposition, [n], [np.array([0])], [np.array([n - 1])], [p], [1])
+    # ... Vector Spaces
+    V = StencilVectorSpace(cart,dtype=dtype)
+    e = V.ends[0]
+    s = V.starts[0]
+
+    # Build banded matrix with 2p+1 diagonals: must be symmetric and positive definite
+    # Here we assign value 2*p on main diagonal and -1 on other diagonals
+    if dtype==complex:
+        factor=1+1j
+    else:
+        factor=1
+    A = StencilMatrix(V, V)
+    A[:, -p:0] = 1-1*factor
+    A[:, 0:1] = 2 * p
+    A[:, 1:p + 1] = 1-1*factor.conjugate()
+    A.remove_spurious_entries()
+
+    # Build exact solution
+    xe = StencilVector(V)
+    xe[s:e + 1] = factor*np.random.random(e + 1 - s)
+    return(V, A, xe)
+
+def define_data(n, p, matrix_data, dtype=float):
+    domain_decomposition = DomainDecomposition([n - p], [False])
+    cart = CartDecomposition(domain_decomposition, [n], [np.array([0])], [np.array([n - 1])], [p], [1])
+    # ... Vector Spaces
+    V = StencilVectorSpace(cart, dtype=dtype)
+    e = V.ends[0]
+    s = V.starts[0]
+
+    # Build banded matrix with 2p+1 diagonals: must be symmetric and positive definite
+    # Here we assign value 2*p on main diagonal and -1 on other diagonals
+
+    A = StencilMatrix(V, V)
+    A[:, -p:0] = -matrix_data[0]
+    A[:, 0:1] = matrix_data[1]
+    A[:, 1:p + 1] = matrix_data[2]
+    A.remove_spurious_entries()
+
+    # Build exact solution
+    xe = StencilVector(V)
+    xe[s:e + 1] = np.random.random(e + 1 - s)
+    return(V, A, xe)
+
+
+#===============================================================================
+@pytest.mark.parametrize( 'n', [5, 10, 13] )
+@pytest.mark.parametrize('p', [2, 3])
+@pytest.mark.parametrize('dtype', [float])
+@pytest.mark.parametrize('solver', ['cg', 'pcg', 'bicg', 'bicgstab', 'pbicgstab', 'minres', 'lsmr', 'gmres'])
+
+def test_solver_tridiagonal(n, p, dtype, solver, verbose=False):
+
+    #---------------------------------------------------------------------------
+    # PARAMETERS
+    #---------------------------------------------------------------------------
+
+    if solver in ['bicg', 'bicgstab', 'pbicgstab', 'lsmr']:
+        if dtype==complex:
+            diagonals = [1-10j,6+9j,3+5j]
+        else:
+            diagonals = [1,6,3]
+            
+        if solver == 'pbicgstab' and dtype == complex:
+            # pbicgstab only works for real matrices
+            return
+    elif solver == 'gmres':
+        if dtype==complex:
+            diagonals = [-7-2j,-6-2j,-1-10j]
+        else:
+            diagonals = [-7,-1,-3]
+
+    if solver in ['cg', 'pcg', 'minres']:
+        # pcg runs with Jacobi preconditioner
+        V, A, xe = define_data_hermitian(n, p, dtype=dtype)
+        if solver == 'minres' and dtype == complex:
+            # minres only works for real matrices
+            return
+    else:
+        V, A, xe = define_data(n, p, diagonals, dtype=dtype)
+
+    # Tolerance for success: 2-norm of error in solution
+    tol = 1e-8
+
+    #---------------------------------------------------------------------------
+    # TEST
+    #---------------------------------------------------------------------------
+    if verbose:
+        # Title
+        print()
+        print( "="*80 )
+        print( f"SERIAL TEST: solve linear system A*x = b using {solver}")
+        print( "="*80 )
+        print()
+
+    #Create the solvers
+    if solver in ['pcg', 'pbicgstab']:
+        pc = A.diagonal(inverse=True)
+        solv = inverse(A, solver, pc=pc, tol=1e-13, verbose=verbose, recycle=True)
+    else:
+        solv = inverse(A, solver, tol=1e-13, verbose=verbose, recycle=True)
+    solvt = solv.transpose()
+    solvh = solv.H
+    solv2 = inverse(A@A, solver, tol=1e-13, verbose=verbose, recycle=True) # Test solver of composition of operators
+
+    # Manufacture right-hand-side vector from exact solution
+    be  = A @ xe
+    be2 = A @ be # Test solver with consecutive solves
+    bet = A.T @ xe
+    beh = A.H @ xe
+
+    # Solve linear system
+    # Assert x0 got updated correctly and is not the same object as the previous solution, but just a copy
+    x = solv @ be
+    info = solv.get_info()
+    solv_x0 = solv._options["x0"]
+    assert np.array_equal(x.toarray(), solv_x0.toarray())
+    assert x is not solv_x0
+
+    x2 = solv @ be2
+    solv_x0 = solv._options["x0"]
+    assert np.array_equal(x2.toarray(), solv_x0.toarray())
+    assert x2 is not solv_x0
+
+    xt = solvt.solve(bet)
+    solvt_x0 = solvt._options["x0"]
+    assert np.array_equal(xt.toarray(), solvt_x0.toarray())
+    assert xt is not solvt_x0
+
+    xh = solvh.dot(beh)
+    solvh_x0 = solvh._options["x0"]
+    assert np.array_equal(xh.toarray(), solvh_x0.toarray())
+    assert xh is not solvh_x0
+
+    if solver != 'pcg':
+        # PCG only works with operators with diagonal
+        xc = solv2 @ be2
+        solv2_x0 = solv2._options["x0"]
+        assert np.array_equal(xc.toarray(), solv2_x0.toarray())
+        assert xc is not solv2_x0
+
+
+    # Verify correctness of calculation: 2-norm of error
+    b = A @ x
+    b2 = A @ x2
+    bt = A.T @ xt
+    bh = A.H @ xh
+    if solver != 'pcg':
+        bc = A @ A @ xc
+
+    err = b - be
+    err_norm = np.linalg.norm( err.toarray() )
+    err2 = b2 - be2
+    err2_norm = np.linalg.norm( err2.toarray() )
+    errt = bt - bet
+    errt_norm = np.linalg.norm( errt.toarray() )
+    errh = bh - beh
+    errh_norm = np.linalg.norm( errh.toarray() )
+
+    if solver != 'pcg': 
+        errc = bc - be2
+        errc_norm = np.linalg.norm( errc.toarray() )
+
+    #---------------------------------------------------------------------------
+    # TERMINAL OUTPUT
+    #---------------------------------------------------------------------------
+    if verbose:
+        print()
+        print( 'A  =', A, sep='\n' )
+        print( 'b  =', b )
+        print( 'x  =', x )
+        print( 'xe =', xe )
+        print( 'info =', info )
+        print()
+
+        print( "-"*40 )
+        print( f"2-norm of error in solution = {err_norm:.2e}" )
+        if err_norm < tol:
+            print( "PASSED" )
+        else:
+            print( "FAIL" )
+        print( "-"*40 )
+
+    #---------------------------------------------------------------------------
+    # PYTEST
+    #---------------------------------------------------------------------------
+    # The lsmr solver does not consistently produce outputs x whose error ||Ax - b|| is less than tol.
+    if solver != 'lsmr':
+        assert err_norm < tol
+        assert err2_norm < tol
+        assert errt_norm < tol
+        assert errh_norm < tol
+        assert solver == 'pcg' or errc_norm < tol
+
+# ===============================================================================
+# SCRIPT FUNCTIONALITY
+#===============================================================================
+
+if __name__ == "__main__":
+    import sys
+    pytest.main( sys.argv )