
{{alias}}( N, D, E )
    Computes the `L * D * L^T` factorization of a real symmetric positive
    definite tridiagonal matrix `A`.

    Indexing is relative to the first index. To introduce an offset, use typed
    array views.

    The function mutates both `D` and `E`.

    Parameters
    ----------
    N: integer
        Order of matrix `A`.

    D: Float64Array
        The `N` diagonal elements of `A`. Upon successful factorization, `D`
        will contain the `N` diagonal elements of the diagonal matrix `D` from
        the `L * D * L^T` factorization of `A`.

    E: Float64Array
        The `N-1` subdiagonal elements of `A`. Upon successful factorization,
        `E` will contain the `N-1` subdiagonal elements of the unit bidiagonal
        factor `L` from the `L * D * L^T` factorization of `A`. `E` can also be
        regarded as the superdiagonal of the unit bidiagonal factor `U` from the
        `U^T * D * U` factorization of `A`.

    Returns
    -------
    info: integer
        Status code. The status code indicates the following conditions:

        - if equal to zero, then the factorization was successful.
        - if less than zero, then the k-th argument had an illegal value, where
          `k = -info`.
        - if greater than zero, then the leading principal minor of order `k` is
          not positive, where `k = info`. If `k < N`, then the factorization
          could not be completed. If `k = N`, then the factorization was
          completed, but `D(N) <= 0`, meaning that the matrix `A` is not
          positive definite.

    Examples
    --------
    > var D = new {{alias:@stdlib/array/float64}}( [ 4.0, 5.0, 6.0 ] );
    > var E = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0 ] );
    > {{alias}}( 3, D, E )
    0
    > D
    <Float64Array>[ 4, 4.75, ~5.15789 ]
    > E
    <Float64Array>[ 0.25, ~0.42105 ]

    // Using typed array views:
    > var D0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0, 5.0, 6.0 ] );
    > var E0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 2.0 ] );
    > D = new Float64Array( D0.buffer, D0.BYTES_PER_ELEMENT*1 );
    > E = new Float64Array( E0.buffer, E0.BYTES_PER_ELEMENT*1 );
    > {{alias}}( 3, D, E )
    0
    > D0
    <Float64Array>[ 0.0, 4.0, 4.75, ~5.15789 ]
    > E0
    <Float64Array>[ 0.0, 0.25, ~0.42105 ]


{{alias}}.ndarray( N, D, strideD, offsetD, E, strideE, offsetE )
    Computes the `L * D * L^T` factorization of a real symmetric positive
    definite tridiagonal matrix `A` using alternative indexing semantics.

    While typed array views mandate a view offset based on the underlying
    buffer, the offset parameters support indexing semantics based on starting
    indices.

    The function mutates both `D` and `E`.

    Parameters
    ----------
    N: integer
        Order of matrix `A`.

    D: Float64Array
        The `N` diagonal elements of `A`. Upon successful factorization, `D`
        will contain the `N` diagonal elements of the diagonal matrix `D` from
        the `L * D * L^T` factorization of `A`.

    strideD: integer
        Stride length for `D`.

    offsetD: integer
        Starting index for `D`.

    E: Float64Array
        The `N-1` subdiagonal elements of `A`. Upon successful factorization,
        `E` will contain the `N-1` subdiagonal elements of the unit bidiagonal
        factor `L` from the `L * D * L^T` factorization of `A`. `E` can also be
        regarded as the superdiagonal of the unit bidiagonal factor `U` from the
        `U^T * D * U` factorization of `A`.

    strideE: integer
        Stride length for `E`.

    offsetE: integer
        Starting index for `E`.

    Returns
    -------
    info: integer
        Status code. The status code indicates the following conditions:

        - if equal to zero, then the factorization was successful.
        - if less than zero, then the k-th argument had an illegal value, where
          `k = -info`.
        - if greater than zero, then the leading principal minor of order `k` is
          not positive, where `k = info`. If `k < N`, then the factorization
          could not be completed. If `k = N`, then the factorization was
          completed, but `D(N) <= 0`, meaning that the matrix `A` is not
          positive definite.

    Examples
    --------
    > var D = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0, 5.0, 6.0 ] );
    > var E = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 2.0 ] );
    > {{alias}}.ndarray( 3, D, 1, 1, E, 1, 1 )
    0
    > D
    <Float64Array>[ 0.0, 4.0, 4.75, ~5.15789 ]
    > E
    <Float64Array>[ 0.0, 0.25, ~0.42105 ]

    See Also
    --------
