Ejemplo n.º 1
0
    def visualize(self, U, codim=2, **kwargs):
        """Visualize scalar data associated to the grid as a patch plot.

        Parameters
        ----------
        U
            |NumPy array| of the data to visualize. If `U.dim == 2 and len(U) > 1`, the
            data is visualized as a time series of plots. Alternatively, a tuple of
            |Numpy arrays| can be provided, in which case a subplot is created for
            each entry of the tuple. The lengths of all arrays have to agree.
        codim
            The codimension of the entities the data in `U` is attached to (either 0 or 2).
        kwargs
            See :func:`~pymor.gui.qt.visualize_patch`
        """
        from pymor.gui.qt import visualize_patch
        from pymor.vectorarrays.interfaces import VectorArrayInterface
        from pymor.vectorarrays.numpy import NumpyVectorArray
        if isinstance(U, (np.ndarray, VectorArrayInterface)):
            U = (U,)
        assert all(isinstance(u, (np.ndarray, VectorArrayInterface)) for u in U)
        U = tuple(NumpyVectorArray(u) if isinstance(u, np.ndarray) else
                  u if isinstance(u, NumpyVectorArray) else
                  NumpyVectorArray(u.data)
                  for u in U)
        bounding_box = kwargs.pop('bounding_box', self.domain)
        visualize_patch(self, U, codim=codim, bounding_box=bounding_box, **kwargs)
Ejemplo n.º 2
0
 def initial_projection(U, mu):
     I = p.initial_data.evaluate(grid.quadrature_points(0, order=2), mu).squeeze()
     I = np.sum(I * grid.reference_element.quadrature(order=2)[1], axis=1) * (
         1.0 / grid.reference_element.volume
     )
     I = NumpyVectorArray(I, copy=False)
     return I.lincomb(U).data
Ejemplo n.º 3
0
 def initial_projection(U, mu):
     I = p.initial_data.evaluate(grid.quadrature_points(0, order=2),
                                 mu).squeeze()
     I = np.sum(I * grid.reference_element.quadrature(order=2)[1],
                axis=1) * (1. / grid.reference_element.volume)
     I = NumpyVectorArray(I, copy=False)
     return I.lincomb(U).data
Ejemplo n.º 4
0
Archivo: ei.py Proyecto: simon-ca/pymor
    def projected_to_subbasis(self, dim_range=None, dim_source=None, dim_collateral=None, name=None):
        assert dim_source is None or dim_source <= self.source.dim
        assert dim_range is None or dim_range <= self.range.dim
        assert dim_collateral is None or dim_collateral <= self.restricted_operator.range.dim
        if not isinstance(self.projected_collateral_basis, NumpyVectorArray):
            raise NotImplementedError
        name = name or '{}_projected_to_subbasis'.format(self.name)

        interpolation_matrix = self.interpolation_matrix[:dim_collateral, :dim_collateral]

        if dim_collateral is not None:
            restricted_operator, source_dofs = self.restricted_operator.restricted(np.arange(dim_collateral))
        else:
            restricted_operator = self.restricted_operator

        old_pcb = self.projected_collateral_basis
        projected_collateral_basis = NumpyVectorArray(old_pcb.data[:dim_collateral, :dim_range], copy=False)

        old_sbd = self.source_basis_dofs
        source_basis_dofs = NumpyVectorArray(old_sbd.data[:dim_source], copy=False) if dim_collateral is None \
            else NumpyVectorArray(old_sbd.data[:dim_source, source_dofs], copy=False)

        return ProjectedEmpiciralInterpolatedOperator(restricted_operator, interpolation_matrix,
                                                      source_basis_dofs, projected_collateral_basis, self.triangular,
                                                      solver_options=self.solver_options, name=name)
Ejemplo n.º 5
0
Archivo: ei.py Proyecto: simon-ca/pymor
    def jacobian(self, U, mu=None):
        mu = self.parse_parameter(mu)
        options = self.solver_options.get('jacobian') if self.solver_options else None

        if len(self.interpolation_dofs) == 0:
            if self.source.type == self.range.type == NumpyVectorArray:
                return NumpyMatrixOperator(np.zeros((self.range.dim, self.source.dim)), solver_options=options,
                                           name=self.name + '_jacobian')
            else:
                return ZeroOperator(self.source, self.range, name=self.name + '_jacobian')
        elif hasattr(self, 'operator'):
            return EmpiricalInterpolatedOperator(self.operator.jacobian(U, mu=mu), self.interpolation_dofs,
                                                 self.collateral_basis, self.triangular,
                                                 solver_options=options, name=self.name + '_jacobian')
        else:
            U_components = NumpyVectorArray(U.components(self.source_dofs), copy=False)
            JU = self.restricted_operator.jacobian(U_components, mu=mu) \
                                         .apply(NumpyVectorArray(np.eye(len(self.source_dofs)), copy=False))
            try:
                if self.triangular:
                    interpolation_coefficients = solve_triangular(self.interpolation_matrix, JU.data.T,
                                                                  lower=True, unit_diagonal=True).T
                else:
                    interpolation_coefficients = np.linalg.solve(self.interpolation_matrix, JU._array.T).T
            except ValueError:  # this exception occurs when AU contains NaNs ...
                interpolation_coefficients = np.empty((len(JU), len(self.collateral_basis))) + np.nan
            J = self.collateral_basis.lincomb(interpolation_coefficients)
            if isinstance(J, NumpyVectorArray):
                J = NumpyMatrixOperator(J.data.T)
            else:
                J = VectorArrayOperator(J)
            return Concatenation(J, ComponentProjection(self.source_dofs, self.source),
                                 solver_options=options, name=self.name + '_jacobian')
Ejemplo n.º 6
0
 def apply_adjoint(self,
                   U,
                   ind=None,
                   mu=None,
                   source_product=None,
                   range_product=None):
     assert U in self.range
     assert source_product is None or source_product.source == source_product.range == self.source
     assert range_product is None or range_product.source == range_product.range == self.range
     if not self.transposed:
         if range_product:
             ATPrU = NumpyVectorArray(range_product.apply2(self._array,
                                                           U,
                                                           U_ind=ind).T,
                                      copy=False)
         else:
             ATPrU = NumpyVectorArray(self._array.dot(U, o_ind=ind).T,
                                      copy=False)
         if source_product:
             return source_product.apply_inverse(ATPrU)
         else:
             return ATPrU
     else:
         if range_product:
             PrU = range_product.apply(U, ind=ind)
         else:
             PrU = U.copy(ind)
         ATPrU = self._array.lincomb(PrU.data)
         if source_product:
             return source_product.apply_inverse(ATPrU)
         else:
             return ATPrU
Ejemplo n.º 7
0
 def apply(self, U, ind=None, mu=None):
     mu = self.parse_parameter(mu)
     if self.source_basis is None:
         if self.range_basis is None:
             return self.operator.apply(U, ind=ind, mu=mu)
         elif self.product is None:
             return NumpyVectorArray(
                 self.operator.apply2(self.range_basis, U, U_ind=ind,
                                      mu=mu).T)
         else:
             V = self.operator.apply(U, ind=ind, mu=mu)
             return NumpyVectorArray(
                 self.product.apply2(V, self.range_basis))
     else:
         U_array = U._array[:U._len] if ind is None else U._array[ind]
         UU = self.source_basis.lincomb(U_array)
         if self.range_basis is None:
             return self.operator.apply(UU, mu=mu)
         elif self.product is None:
             return NumpyVectorArray(
                 self.operator.apply2(self.range_basis, UU, mu=mu).T)
         else:
             V = self.operator.apply(UU, mu=mu)
             return NumpyVectorArray(
                 self.product.apply2(V, self.range_basis))
Ejemplo n.º 8
0
Archivo: la.py Proyecto: fameyer/pymor
def test_gram_schmidt():
    for i in (1, 32):
        b = NumpyVectorArray(np.identity(i, dtype=np.float))
        a = gram_schmidt(b)
        assert np.all(b.almost_equal(a))
    c = NumpyVectorArray([[1.0, 0], [0.0, 0]])
    a = gram_schmidt(c)
    assert (a.data == np.array([[1.0, 0]])).all()
Ejemplo n.º 9
0
Archivo: la.py Proyecto: simon-ca/pymor
def test_gram_schmidt():
    for i in (1, 32):
        b = NumpyVectorArray(np.identity(i, dtype=np.float))
        a = gram_schmidt(b)
        assert np.all(almost_equal(b, a))
    c = NumpyVectorArray([[1.0, 0], [0., 0]])
    a = gram_schmidt(c)
    assert (a.data == np.array([[1.0, 0]])).all()
Ejemplo n.º 10
0
def test_projected(operator_with_arrays):
    op, mu, U, V = operator_with_arrays
    op_UV = op.projected(V, U)
    np.random.seed(4711 + U.dim + len(V))
    coeffs = np.random.random(len(U))
    X = op_UV.apply(NumpyVectorArray(coeffs, copy=False), mu=mu)
    Y = NumpyVectorArray(V.dot(op.apply(U.lincomb(coeffs), mu=mu)).T,
                         copy=False)
    assert np.all(almost_equal(X, Y))
Ejemplo n.º 11
0
def test_projected_with_product(operator_with_arrays_and_products):
    op, mu, U, V, sp, rp = operator_with_arrays_and_products
    op_UV = op.projected(V, U, product=rp)
    np.random.seed(4711 + U.dim + len(V))
    coeffs = np.random.random(len(U))
    X = op_UV.apply(NumpyVectorArray(coeffs, copy=False), mu=mu)
    Y = NumpyVectorArray(rp.apply2(op.apply(U.lincomb(coeffs), mu=mu), V),
                         copy=False)
    assert np.all(almost_equal(X, Y))
Ejemplo n.º 12
0
def test_ext(extension_alg):
    size = 5
    ident = np.identity(size)
    current = ident[0]
    for i in range(1, size):
        c = NumpyVectorArray(current)
        n, _ = extension_alg(c, NumpyVectorArray(ident[i]))
        assert np.allclose(n.data, ident[0:i+1])
        current = ident[0:i+1]
Ejemplo n.º 13
0
 def apply(self, U, ind=None, mu=None):
     assert U in self.source
     assert U.check_ind(ind)
     U_array = U._array[:U._len] if ind is None else U._array[ind]
     if self.parametric:
         mu = self.parse_parameter(mu)
         return NumpyVectorArray(self._mapping(U_array, mu=mu), copy=False)
     else:
         return NumpyVectorArray(self._mapping(U_array), copy=False)
Ejemplo n.º 14
0
def test_scal():
    v = np.array([[1, 2, 3], [4, 5, 6]], dtype=float)
    v = NumpyVectorArray(v)
    v.scal(1j)

    k = 0
    for i in range(2):
        for j in range(3):
            k += 1
            assert v.data[i, j] == k * 1j
Ejemplo n.º 15
0
def test_axpy():
    x = NumpyVectorArray(np.array([1.]))
    y = NumpyVectorArray(np.array([1.]))
    y.axpy(1 + 1j, x)
    assert y.data[0, 0] == 2 + 1j

    x = NumpyVectorArray(np.array([1 + 1j]))
    y = NumpyVectorArray(np.array([1.]))
    y.axpy(-1, x)
    assert y.data[0, 0] == -1j
Ejemplo n.º 16
0
def test_scal():
    v = np.array([[1, 2, 3],
                  [4, 5, 6]], dtype=float)
    v = NumpyVectorArray(v)
    v.scal(1j)

    k = 0
    for i in range(2):
        for j in range(3):
            k += 1
            assert v.data[i, j] == k * 1j
Ejemplo n.º 17
0
 def as_vector(self, mu=None):
     if not self.linear:
         raise TypeError(
             'This nonlinear operator does not represent a vector or linear functional.'
         )
     elif self.source.dim == 1 and self.source.type is NumpyVectorArray:
         return self.apply(NumpyVectorArray(1), mu=mu)
     elif self.range.dim == 1 and self.range.type is NumpyVectorArray:
         return self.apply_adjoint(NumpyVectorArray(1), mu=mu)
     else:
         raise TypeError(
             'This operator does not represent a vector or linear functional.'
         )
Ejemplo n.º 18
0
def thermalblock_vectorarray_factory(transposed, xblocks, yblocks, diameter, seed):
    from pymor.operators.constructions import VectorArrayOperator
    _, _, U, V, sp, rp = thermalblock_factory(xblocks, yblocks, diameter, seed)
    op = VectorArrayOperator(U, transposed)
    if transposed:
        U = V
        V = NumpyVectorArray(np.random.random((7, op.range.dim)), copy=False)
        sp = rp
        rp = NumpyMatrixOperator(np.eye(op.range.dim) * 2)
    else:
        U = NumpyVectorArray(np.random.random((7, op.source.dim)), copy=False)
        sp = NumpyMatrixOperator(np.eye(op.source.dim) * 2)
    return op, None, U, V, sp, rp
Ejemplo n.º 19
0
def test_restricted(operator_with_arrays):
    op, mu, U, _, = operator_with_arrays
    if op.range.dim == 0:
        return
    np.random.seed(4711 + U.dim)
    for num in [0, 1, 3, 7]:
        components = np.random.randint(0, op.range.dim, num)
        try:
            rop, source_dofs = op.restricted(components)
        except NotImplementedError:
            return
        op_U = NumpyVectorArray(op.apply(U, mu=mu).components(components))
        rop_U = rop.apply(NumpyVectorArray(U.components(source_dofs)), mu=mu)
        assert np.all(almost_equal(op_U, rop_U))
Ejemplo n.º 20
0
 def as_vector(self, mu=None):
     matrix = self._matrix
     if matrix.shape[0] != 1 and matrix.shape[1] != 1:
         raise TypeError(
             'This operator does not represent a vector or linear functional.'
         )
     return NumpyVectorArray(matrix.ravel(), copy=True)
Ejemplo n.º 21
0
def test_to_matrix():
    np.random.seed(0)
    A = np.random.randn(2, 2)
    B = np.random.randn(3, 3)
    C = np.random.randn(3, 3)

    X = np.bmat([[np.eye(2) + A, np.zeros((2, 3))],
                 [np.zeros((3, 2)), B.dot(C.T)]])

    C = sps.csc_matrix(C)

    Aop = NumpyMatrixOperator(A)
    Bop = NumpyMatrixOperator(B)
    Cop = NumpyMatrixOperator(C)

    Xop = BlockDiagonalOperator([
        LincombOperator([IdentityOperator(NumpyVectorSpace(2)), Aop], [1, 1]),
        Concatenation(Bop, AdjointOperator(Cop))
    ])

    assert np.allclose(X, to_matrix(Xop))
    assert np.allclose(X, to_matrix(Xop, format='csr').toarray())

    np.random.seed(0)
    V = np.random.randn(10, 2)
    Vva = NumpyVectorArray(V.T)
    Vop = VectorArrayOperator(Vva)
    assert np.allclose(V, to_matrix(Vop))
    Vop = VectorArrayOperator(Vva, transposed=True)
    assert np.allclose(V, to_matrix(Vop).T)
Ejemplo n.º 22
0
def thermalblock_vector_factory(xblocks, yblocks, diameter, seed):
    from pymor.operators.constructions import VectorOperator
    _, _, U, V, sp, rp = thermalblock_factory(xblocks, yblocks, diameter, seed)
    op = VectorOperator(U.copy(ind=0))
    U = NumpyVectorArray(np.random.random((7, 1)), copy=False)
    sp = NumpyMatrixOperator(np.eye(1) * 2)
    return op, None, U, V, sp, rp
Ejemplo n.º 23
0
Archivo: fv.py Proyecto: simon-ca/pymor
    def apply(self, U, ind=None, mu=None):
        assert isinstance(U, NumpyVectorArray)
        assert U in self.source
        mu = self.parse_parameter(mu)

        if not hasattr(self, '_grid_data'):
            self._fetch_grid_data()

        ind = range(len(U)) if ind is None else ind
        U = U.data
        R = np.zeros((len(ind), self.source.dim))

        bi = self.boundary_info
        gd = self._grid_data
        SUPE = gd['SUPE']
        VOLS0 = gd['VOLS0']
        VOLS1 = gd['VOLS1']
        BOUNDARIES = gd['BOUNDARIES']
        CENTERS = gd['CENTERS']
        DIRICHLET_BOUNDARIES = gd['DIRICHLET_BOUNDARIES']
        NEUMANN_BOUNDARIES = gd['NEUMANN_BOUNDARIES']
        UNIT_OUTER_NORMALS = gd['UNIT_OUTER_NORMALS']

        if bi.has_dirichlet:
            if hasattr(self, '_dirichlet_values'):
                dirichlet_values = self._dirichlet_values
            elif self.dirichlet_data is not None:
                dirichlet_values = self.dirichlet_data(
                    CENTERS[DIRICHLET_BOUNDARIES], mu=mu)
            else:
                dirichlet_values = np.zeros_like(DIRICHLET_BOUNDARIES)
            F_dirichlet = self.numerical_flux.evaluate_stage1(
                dirichlet_values, mu)

        for i, j in enumerate(ind):
            Ui = U[j]
            Ri = R[i]

            F = self.numerical_flux.evaluate_stage1(Ui, mu)
            F_edge = [f[SUPE] for f in F]

            for f in F_edge:
                f[BOUNDARIES, 1] = f[BOUNDARIES, 0]
            if bi.has_dirichlet:
                for f, f_d in zip(F_edge, F_dirichlet):
                    f[DIRICHLET_BOUNDARIES, 1] = f_d

            NUM_FLUX = self.numerical_flux.evaluate_stage2(
                F_edge, UNIT_OUTER_NORMALS, VOLS1, mu)

            if bi.has_neumann:
                NUM_FLUX[NEUMANN_BOUNDARIES] = 0

            iadd_masked(Ri, NUM_FLUX, SUPE[:, 0])
            isub_masked(Ri, NUM_FLUX, SUPE[:, 1])

        R /= VOLS0

        return NumpyVectorArray(R)
Ejemplo n.º 24
0
 def apply(self, U, ind=None, mu=None):
     assert U in self.source
     if not self.transposed:
         if ind is not None:
             U = U.copy(ind)
         return self._array.lincomb(U.data)
     else:
         return NumpyVectorArray(U.dot(self._array, ind=ind), copy=False)
Ejemplo n.º 25
0
Archivo: la.py Proyecto: simon-ca/pymor
def test_induced():
    grid = TriaGrid(num_intervals=(10, 10))
    boundary_info = AllDirichletBoundaryInfo(grid)
    product = L2ProductP1(grid, boundary_info)
    zero = NumpyVectorArray(np.zeros(grid.size(2)))
    norm = induced_norm(product)
    value = norm(zero)
    np.testing.assert_almost_equal(value, 0.0)
Ejemplo n.º 26
0
def thermalblock_vectorfunc_factory(product, xblocks, yblocks, diameter, seed):
    from pymor.operators.constructions import VectorFunctional
    _, _, U, V, sp, rp = thermalblock_factory(xblocks, yblocks, diameter, seed)
    op = VectorFunctional(U.copy(ind=0), product=sp if product else None)
    U = V
    V = NumpyVectorArray(np.random.random((7, 1)), copy=False)
    sp = rp
    rp = NumpyMatrixOperator(np.eye(1) * 2)
    return op, None, U, V, sp, rp
Ejemplo n.º 27
0
 def restricted(self, dofs):
     assert all(0 <= c < self.range.dim for c in dofs)
     if not self.transposed:
         restricted_value = NumpyVectorArray(self._array.components(dofs))
         return VectorArrayOperator(restricted_value,
                                    False), np.arange(self.source.dim,
                                                      dtype=np.int32)
     else:
         raise NotImplementedError
Ejemplo n.º 28
0
 def reconstruct(self, U):
     """Reconstruct high-dimensional vector from reduced vector `U`."""
     assert isinstance(U, NumpyVectorArray)
     UU = np.zeros((len(U), self.dim))
     UU[:, :self.dim_subbasis] = U.data
     UU = NumpyVectorArray(UU, copy=False)
     if self.old_recontructor:
         return self.old_recontructor.reconstruct(UU)
     else:
         return UU
Ejemplo n.º 29
0
Archivo: ei.py Proyecto: simon-ca/pymor
    def apply(self, U, ind=None, mu=None):
        mu = self.parse_parameter(mu)
        if len(self.interpolation_dofs) == 0:
            count = len(ind) if ind is not None else len(U)
            return self.range.zeros(count=count)

        if hasattr(self, 'restricted_operator'):
            U_components = NumpyVectorArray(U.components(self.source_dofs, ind=ind), copy=False)
            AU = self.restricted_operator.apply(U_components, mu=mu)
        else:
            AU = NumpyVectorArray(self.operator.apply(U, mu=mu).components(self.interpolation_dofs), copy=False)
        try:
            if self.triangular:
                interpolation_coefficients = solve_triangular(self.interpolation_matrix, AU.data.T,
                                                              lower=True, unit_diagonal=True).T
            else:
                interpolation_coefficients = np.linalg.solve(self.interpolation_matrix, AU._array.T).T
        except ValueError:  # this exception occurs when AU contains NaNs ...
            interpolation_coefficients = np.empty((len(AU), len(self.collateral_basis))) + np.nan
        return self.collateral_basis.lincomb(interpolation_coefficients)
Ejemplo n.º 30
0
def test_blk_diag_apply_inverse():
    np.random.seed(0)

    A = np.random.randn(2, 2)
    B = np.random.randn(3, 3)
    C = spla.block_diag(A, B)
    Aop = NumpyMatrixOperator(A)
    Bop = NumpyMatrixOperator(B)
    Cop = BlockDiagonalOperator((Aop, Bop))

    v1 = np.random.randn(2)
    v2 = np.random.randn(3)
    v = np.hstack((v1, v2))
    v1va = NumpyVectorArray(v1)
    v2va = NumpyVectorArray(v2)
    vva = BlockVectorArray((v1va, v2va))

    wva = Cop.apply_inverse(vva)
    w = np.hstack((wva.block(0).data, wva.block(1).data))
    assert np.allclose(spla.solve(C, v), w)
Ejemplo n.º 31
0
 def save(self):
     if not HAVE_PYVTK:
         msg = QMessageBox(QMessageBox.Critical, 'Error',
                           'VTK output disabled. Pleas install pyvtk.')
         msg.exec_()
         return
     filename = QFileDialog.getSaveFileName(self, 'Save as vtk file')[0]
     base_name = filename.split('.vtu')[0].split('.vtk')[0].split(
         '.pvd')[0]
     if base_name:
         if len(self.U) == 1:
             write_vtk(self.grid,
                       NumpyVectorArray(self.U[0], copy=False),
                       base_name,
                       codim=self.codim)
         else:
             for i, u in enumerate(self.U):
                 write_vtk(self.grid,
                           NumpyVectorArray(u, copy=False),
                           '{}-{}'.format(base_name, i),
                           codim=self.codim)
Ejemplo n.º 32
0
def test_vtkio(rect_or_tria_grid):
    grid = rect_or_tria_grid
    steps = 4
    for dim in range(1, 2):
        for codim, data in enumerate(
            (NumpyVectorArray(np.zeros((steps, grid.size(c))))
             for c in range(grid.dim + 1))):
            with NamedTemporaryFile('wb') as out:
                if codim == 1:
                    with pytest.raises(NotImplementedError):
                        write_vtk(grid, data, out.name, codim=codim)
                else:
                    write_vtk(grid, data, out.name, codim=codim)
Ejemplo n.º 33
0
def test_real_imag():
    A = np.array([[1 + 2j, 3 + 4j], [5 + 6j, 7 + 8j], [9 + 10j, 11 + 12j]])
    Ava = NumpyVectorArray(A)
    Bva = Ava.real
    Cva = Ava.imag

    k = 0
    for i in range(3):
        for j in range(2):
            k += 1
            assert Bva.data[i, j] == k
            k += 1
            assert Cva.data[i, j] == k
Ejemplo n.º 34
0
def test_complex():
    np.random.seed(0)
    I = np.eye(5)
    A = np.random.randn(5, 5)
    B = np.random.randn(5, 5)
    C = np.random.randn(3, 5)

    Iop = NumpyMatrixOperator(I)
    Aop = NumpyMatrixOperator(A)
    Bop = NumpyMatrixOperator(B)
    Cva = NumpyVectorArray(C)

    # assemble_lincomb
    assert not np.iscomplexobj(Aop.assemble_lincomb((Iop, Bop), (1, 1))._matrix)
    assert not np.iscomplexobj(Aop.assemble_lincomb((Aop, Bop), (1, 1))._matrix)
    assert not np.iscomplexobj(Aop.assemble_lincomb((Aop, Bop), (1 + 0j, 1 + 0j))._matrix)
    assert np.iscomplexobj(Aop.assemble_lincomb((Aop, Bop), (1j, 1))._matrix)
    assert np.iscomplexobj(Aop.assemble_lincomb((Bop, Aop), (1, 1j))._matrix)

    # apply_inverse
    assert not np.iscomplexobj(Aop.apply_inverse(Cva).data)
    assert np.iscomplexobj((Aop * 1j).apply_inverse(Cva).data)
    assert np.iscomplexobj(Aop.assemble_lincomb((Aop, Bop), (1, 1j)).apply_inverse(Cva).data)
    assert np.iscomplexobj(Aop.apply_inverse(Cva * 1j).data)

    # append
    for rsrv in (0, 10):
        for o_ind in (None, [0]):
            va = NumpyVectorArray.make_array(subtype=5, reserve=rsrv)
            va.append(Cva)
            D = np.random.randn(1, 5) + 1j * np.random.randn(1, 5)
            Dva = NumpyVectorArray(D)

            assert not np.iscomplexobj(va.data)
            assert np.iscomplexobj(Dva.data)
            va.append(Dva, o_ind)
            assert np.iscomplexobj(va.data)

    # scal
    assert not np.iscomplexobj(Cva.data)
    assert np.iscomplexobj((Cva * 1j).data)
    assert np.iscomplexobj((Cva * (1 + 0j)).data)

    # axpy
    assert not np.iscomplexobj(Cva.data)
    Cva.axpy(1, Dva, 0)
    assert np.iscomplexobj(Cva.data)

    Cva = NumpyVectorArray(C)
    assert not np.iscomplexobj(Cva.data)
    Cva.axpy(1j, Dva, 0)
    assert np.iscomplexobj(Cva.data)
Ejemplo n.º 35
0
def test_axpy():
    x = NumpyVectorArray(np.array([1.]))
    y = NumpyVectorArray(np.array([1.]))
    y.axpy(1 + 1j, x)
    assert y.data[0, 0] == 2 + 1j

    x = NumpyVectorArray(np.array([1 + 1j]))
    y = NumpyVectorArray(np.array([1.]))
    y.axpy(-1, x)
    assert y.data[0, 0] == -1j
Ejemplo n.º 36
0
def test_pairwise_dot():
    x = NumpyVectorArray(np.array([1 + 1j]))
    y = NumpyVectorArray(np.array([1 - 1j]))
    z = x.pairwise_dot(y)
    assert z == 2j
Ejemplo n.º 37
0
def test_dot():
    x = NumpyVectorArray(np.array([1 + 1j]))
    y = NumpyVectorArray(np.array([1 - 1j]))
    z = x.dot(y)
    assert z[0, 0] == 2j
Ejemplo n.º 38
0
def test_numpy_sparse_solvers(numpy_sparse_solver):
    op = NumpyMatrixOperator(diags([np.arange(1., 11.)], [0]), solver_options=numpy_sparse_solver)
    rhs = NumpyVectorArray(np.ones(10))
    solution = op.apply_inverse(rhs)
    assert ((op.apply(solution) - rhs).l2_norm() / rhs.l2_norm())[0] < 1e-8
Ejemplo n.º 39
0
def test_numpy_dense_solvers(numpy_dense_solver):
    op = NumpyMatrixOperator(np.eye(10) * np.arange(1, 11), solver_options=numpy_dense_solver)
    rhs = NumpyVectorArray(np.ones(10))
    solution = op.apply_inverse(rhs)
    assert ((op.apply(solution) - rhs).l2_norm() / rhs.l2_norm())[0] < 1e-8
Ejemplo n.º 40
0
def test_generic_solvers(generic_solver):
    op = GenericOperator(generic_solver)
    rhs = NumpyVectorArray(np.ones(10))
    solution = op.apply_inverse(rhs)
    assert ((op.apply(solution) - rhs).l2_norm() / rhs.l2_norm())[0] < 1e-8