harith.h

Go to the documentation of this file.

/* ------------------------------------------------------------
 * This is the file "harith.h" of the H2Lib package.
 * All rights reserved, Steffen Boerm 2014
 * ------------------------------------------------------------ */

#ifndef HARITH_H
#define HARITH_H

#include "hmatrix.h"
#include "truncation.h"

/* ------------------------------------------------------------
 Truncation of an rkmatrix
 ------------------------------------------------------------ */

HEADER_PREFIX void
trunc_rkmatrix(pctruncmode tm, real eps, prkmatrix r);

/* ------------------------------------------------------------
 * Matrix addition
 * ------------------------------------------------------------ */

HEADER_PREFIX void
add_amatrix_rkmatrix(field alpha, bool atrans, pcamatrix a, pctruncmode tm,
    real eps, prkmatrix b);

// *  in @ref rkmatrix representation,
// *  @f$B \gets \operatorname{trunc}(B+\alpha A,\epsilon)@f$.
// *
// *  This version uses a rank-revealing QR factorization instead
// *  of the standard singular value decomposition. This method
// *  may lead to larger ranks, but may also be faster in some
// *  applications.
// *
// *  @param alpha Scaling factor @f$\alpha@f$.
// *  @param a Source matrix @f$A@f$.
// *  @param atrans Set if @f$A^*@f$ is to be used instead of @f$A@f$.
// *  @param tm Truncation mode.
// *  @param eps Truncation accuracy @f$\epsilon@f$.
// *  @param b Target matrix @f$B@f$. */
//HEADER_PREFIX void
//add2_amatrix_rkmatrix(field alpha, bool atrans, pcamatrix a,
//          pctruncmode tm, real eps, prkmatrix b);

HEADER_PREFIX void
add_rkmatrix_amatrix(field alpha, bool atrans, pcrkmatrix a, pamatrix b);

HEADER_PREFIX void
add_hmatrix_amatrix(field alpha, bool atrans, pchmatrix a, pamatrix b);

HEADER_PREFIX void
add_rkmatrix(field alpha, pcrkmatrix src, pctruncmode tm, real eps,
    prkmatrix trg);

// *  representation,
// *  @f$B \gets \operatorname{trunc}(B+\alpha A,\epsilon)@f$.
// *
// *  This version uses a rank-revealing QR factorization instead
// *  of the standard singular value decomposition. This method
// *  may lead to larger ranks, but may also be faster in some
// *  applications.
// *
// *  @param alpha Scaling factor @f$\alpha@f$.
// *  @param a Source matrix @f$A@f$.
// *  @param tm Truncation mode.
// *  @param eps Truncation accuracy @f$\epsilon@f$.
// *  @param b Target matrix @f$B@f$. */
//HEADER_PREFIX void
//add2_rkmatrix(field alpha, pcrkmatrix a,
//        pctruncmode tm, real eps, prkmatrix b);

HEADER_PREFIX void
add_amatrix_hmatrix(field alpha, bool atrans, pcamatrix a, pctruncmode tm,
    real eps, phmatrix b);

HEADER_PREFIX void
add_lower_amatrix_hmatrix(field alpha, bool atrans, pcamatrix a, pctruncmode tm,
    real eps, phmatrix b);

HEADER_PREFIX void
add_rkmatrix_hmatrix(field alpha, pcrkmatrix a, pctruncmode tm, real eps,
    phmatrix b);

HEADER_PREFIX void
add_lower_rkmatrix_hmatrix(field alpha, pcrkmatrix a, pctruncmode tm, real eps,
    phmatrix b);

HEADER_PREFIX void
add_hmatrix(field alpha, pchmatrix a, pctruncmode tm, real eps, phmatrix b);

/* ------------------------------------------------------------
 * Splitting and merging H-matrices
 * ------------------------------------------------------------ */

// *
// *  @param f Original matrix.
// *  @param rc Row cluster.
// *  @param cc Column cluster.
// *  @param rsplit Set to split in row direction.
// *  @param csplit Set to split in column direction.
// *  @param copy Set to copy values into new matrix, otherwise it
// *     will be zero.
// *  @returns Block matrix of depth one. */
//HEADER_PREFIX phmatrix
//split_amatrix(pcamatrix f, pccluster rc, pccluster cc,
//        bool rsplit, bool csplit, bool copy);
HEADER_PREFIX phmatrix
split_sub_amatrix(pcamatrix f, pccluster rc, pccluster cc, bool rsplit,
    bool csplit);

HEADER_PREFIX phmatrix
split_rkmatrix(pcrkmatrix r, pccluster rc, pccluster cc, bool rsplit,
    bool csplit, bool copy);

HEADER_PREFIX phmatrix
split_sub_rkmatrix(pcrkmatrix r, pccluster rc, pccluster cc, bool rsplit,
    bool csplit);

// *
// *  @param hm Leaf @ref hmatrix.
// *  @param rsplit Set to split in row direction.
// *  @param csplit Set to split in column direction.
// *  @param copy Set to copy values into new matrix, otherwise it
// *     will be zero.
// *  @returns Block matrix of depth one or zero according to
// *     <tt>rsplit</tt> and <tt>csplit</tt>. */
//HEADER_PREFIX phmatrix
//split_hmatrix(phmatrix hm, bool rsplit, bool csplit, bool copy);
//
// *  the original matrix.
// *
// *  @attention Since the blocks of the result contain only references
// *  to the original matrix, they cannot be resized, and changing
// *  them changes the original matrix.
// *
// *  @param hm Leaf @ref hmatrix.
// *  @param rsplit Set to split in row direction.
// *  @param csplit Set to split in column direction.
// *  @returns Block matrix of depth one or zero according to
// *     <tt>rsplit</tt> and <tt>csplit</tt>. */
//HEADER_PREFIX phmatrix
//split_sub_hmatrix(phmatrix hm,
//      bool rsplit, bool csplit);

HEADER_PREFIX void
merge_rkmatrix(bool colmerge, pcrkmatrix src, pctruncmode tm, real eps,
    prkmatrix trg);

HEADER_PREFIX prkmatrix
merge_hmatrix_rkmatrix(pchmatrix s, pctruncmode tm, real eps);

/* ------------------------------------------------------------
 * Matrix multiplication
 * ------------------------------------------------------------ */

HEADER_PREFIX void
addmul_rkmatrix_amatrix_amatrix(field alpha, bool atrans, pcrkmatrix a,
    bool btrans, pcamatrix b, bool ctrans, pamatrix c);

HEADER_PREFIX void
addmul_hmatrix_amatrix_amatrix(field alpha, bool atrans, pchmatrix a,
    bool btrans, pcamatrix bp, bool ctrans, pamatrix cp);

HEADER_PREFIX void
addmul_hmatrix(field alpha, bool xtrans, pchmatrix x, bool ytrans, pchmatrix y,
    pctruncmode tm, real eps, phmatrix z);

HEADER_PREFIX void
addmul_lower_hmatrix(field alpha, bool xtrans, pchmatrix x, bool ytrans,
    pchmatrix y, pctruncmode tm, real eps, phmatrix z);

/* ------------------------------------------------------------
 * Matrix inversion
 * ------------------------------------------------------------ */

HEADER_PREFIX void
invert_hmatrix(phmatrix a, phmatrix work, pctruncmode tm, real eps);

/* ------------------------------------------------------------
 * Triangular matrices
 * ------------------------------------------------------------ */

HEADER_PREFIX phmatrix
clone_lower_hmatrix(bool aunit, pchmatrix a);

HEADER_PREFIX phmatrix
clone_upper_hmatrix(bool aunit, pchmatrix a);

/* ------------------------------------------------------------
 * Solve triangular systems
 * ------------------------------------------------------------ */

HEADER_PREFIX void
triangularinvmul_hmatrix_avector(bool alower, bool aunit, bool atrans,
    pchmatrix a, pavector xp);

HEADER_PREFIX void
triangularsolve_hmatrix_avector(bool alower, bool aunit, bool atrans,
    pchmatrix a, pavector x);

HEADER_PREFIX void
triangularinvmul_hmatrix_amatrix(bool alower, bool aunit, bool atrans,
    pchmatrix a, bool xtrans, pamatrix xp);

HEADER_PREFIX void
triangularinvmul_hmatrix(bool alower, bool aunit, bool atrans, pchmatrix a,
    pctruncmode tm, real eps, bool xtrans, phmatrix xp);

HEADER_PREFIX void
triangularinvmul_amatrix_hmatrix(bool alower, bool aunit, bool atrans,
    pcamatrix a, pctruncmode tm, real eps, bool xtrans, phmatrix xp);

/* ------------------------------------------------------------
 * Evaluate triangular matrices
 * ------------------------------------------------------------ */

HEADER_PREFIX void
triangularmul_hmatrix_avector(bool alower, bool aunit, bool atrans, pchmatrix a,
    pavector xp);

HEADER_PREFIX void
triangulareval_hmatrix_avector(bool alower, bool aunit, bool atrans,
    pchmatrix a, pavector x);

HEADER_PREFIX void
triangularmul_hmatrix_amatrix(bool alower, bool aunit, bool atrans, pchmatrix a,
    bool xtrans, pamatrix xp);

HEADER_PREFIX void
triangularmul_hmatrix(bool alower, bool aunit, bool atrans, pchmatrix a,
    pctruncmode tm, real eps, bool xtrans, phmatrix xp);

/* ------------------------------------------------------------
 * Triangular factorizations
 * ------------------------------------------------------------ */

HEADER_PREFIX void
lrdecomp_hmatrix(phmatrix a, pctruncmode tm, real eps);

HEADER_PREFIX void
lrsolve_n_hmatrix_avector(pchmatrix a, pavector x);

HEADER_PREFIX void
lrsolve_t_hmatrix_avector(pchmatrix a, pavector x);

HEADER_PREFIX void
lrsolve_hmatrix_avector(bool atrans, pchmatrix a, pavector x);

HEADER_PREFIX void
lreval_n_hmatrix_avector(pchmatrix a, pavector x);

HEADER_PREFIX void
lreval_t_hmatrix_avector(pchmatrix a, pavector x);

HEADER_PREFIX void
lreval_hmatrix_avector(bool atrans, pchmatrix a, pavector x);

HEADER_PREFIX void
choldecomp_hmatrix(phmatrix a, pctruncmode tm, real eps);

HEADER_PREFIX void
cholsolve_hmatrix_avector(pchmatrix a, pavector x);

HEADER_PREFIX void
choleval_hmatrix_avector(pchmatrix a, pavector x);

#endif