Vous êtes un professionnel et vous avez besoin d'une formation ? Calcul scientifique
avec Python Voir le programme détaillé

Module « scipy.linalg »

Fonction solveh_banded - module scipy.linalg

Signature de la fonction solveh_banded

def solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True) 

Description

help(scipy.linalg.solveh_banded)

Solve equation a x = b. a is Hermitian positive-definite banded matrix.

Uses Thomas' Algorithm, which is more efficient than standard LU
factorization, but should only be used for Hermitian positive-definite
matrices.

The matrix ``a`` is stored in `ab` either in lower diagonal or upper
diagonal ordered form:

    ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)
    ab[    i - j, j] == a[i,j]        (if lower form; i >= j)

Example of `ab` (shape of ``a`` is (6, 6), number of upper diagonals,
``u`` =2)::

    upper form:
    *   *   a02 a13 a24 a35
    *   a01 a12 a23 a34 a45
    a00 a11 a22 a33 a44 a55

    lower form:
    a00 a11 a22 a33 a44 a55
    a10 a21 a32 a43 a54 *
    a20 a31 a42 a53 *   *

Cells marked with * are not used.

Parameters
----------
ab : (``u`` + 1, M) array_like
    Banded matrix
b : (M,) or (M, K) array_like
    Right-hand side
overwrite_ab : bool, optional
    Discard data in `ab` (may enhance performance)
overwrite_b : bool, optional
    Discard data in `b` (may enhance performance)
lower : bool, optional
    Is the matrix in the lower form. (Default is upper form)
check_finite : bool, optional
    Whether to check that the input matrices contain only finite numbers.
    Disabling may give a performance gain, but may result in problems
    (crashes, non-termination) if the inputs do contain infinities or NaNs.

Returns
-------
x : (M,) or (M, K) ndarray
    The solution to the system ``a x = b``. Shape of return matches shape
    of `b`.

Notes
-----
In the case of a non-positive definite matrix ``a``, the solver
`solve_banded` may be used.

Examples
--------
Solve the banded system ``A x = b``, where::

        [ 4  2 -1  0  0  0]       [1]
        [ 2  5  2 -1  0  0]       [2]
    A = [-1  2  6  2 -1  0]   b = [2]
        [ 0 -1  2  7  2 -1]       [3]
        [ 0  0 -1  2  8  2]       [3]
        [ 0  0  0 -1  2  9]       [3]

>>> import numpy as np
>>> from scipy.linalg import solveh_banded

``ab`` contains the main diagonal and the nonzero diagonals below the
main diagonal. That is, we use the lower form:

>>> ab = np.array([[ 4,  5,  6,  7, 8, 9],
...                [ 2,  2,  2,  2, 2, 0],
...                [-1, -1, -1, -1, 0, 0]])
>>> b = np.array([1, 2, 2, 3, 3, 3])
>>> x = solveh_banded(ab, b, lower=True)
>>> x
array([ 0.03431373,  0.45938375,  0.05602241,  0.47759104,  0.17577031,
        0.34733894])


Solve the Hermitian banded system ``H x = b``, where::

        [ 8   2-1j   0     0  ]        [ 1  ]
    H = [2+1j  5     1j    0  ]    b = [1+1j]
        [ 0   -1j    9   -2-1j]        [1-2j]
        [ 0    0   -2+1j   6  ]        [ 0  ]

In this example, we put the upper diagonals in the array ``hb``:

>>> hb = np.array([[0, 2-1j, 1j, -2-1j],
...                [8,  5,    9,   6  ]])
>>> b = np.array([1, 1+1j, 1-2j, 0])
>>> x = solveh_banded(hb, b)
>>> x
array([ 0.07318536-0.02939412j,  0.11877624+0.17696461j,
        0.10077984-0.23035393j, -0.00479904-0.09358128j])

Vous êtes un professionnel et vous avez besoin d'une formation ? Sensibilisation à
l'Intelligence Artificielle Voir le programme détaillé