whb.h

Go to the documentation of this file.

#ifndef _WHB_H
#define _WHB_H

#include <mc/mc_base.h>

#include <mc/bam.h>

typedef enum HBMATtype {
    ZERO_TYPE,
    AMIN_TYPE,
    ANOR_TYPE,
    GHB_TYPE,
    GWM_TYPE
} HBMATtype;

/* Class Whb: Definition */

struct sHBmat {

    Vmem       *vmem;        
    int        iMadeVmem;   

    HBMATtype  type;

    int        numB;   

    Bmat       *A12; 
    Bmat       *A21;  
    Bmat       *A22;  

    struct sHBmat *next;    

};

typedef struct sHBmat HBmat;

struct sHBvec {

    Vmem       *vmem;     
    int        iMadeVmem; 
    int        state;

    int        numB;  

    Bvec       *bv;   
    Bvec       *bv2;  

    struct sHBvec *next;  

};

typedef struct sHBvec HBvec;

struct sBchar {
    Vmem       *vmem;     
    int        iMadeVmem;  

    char       name[10];    
    int        n;     
    char       *uflat;  

    struct sBchar *coarse;  

    int        numB;       
    int        numR[MAXV];
    char       *u[MAXV];  

};

typedef struct sBchar Bchar;

/*
 * ***************************************************************************
 * Class Whb: Inlineable methods (whb.c)
 * ***************************************************************************
 */

#if !defined(VINLINE_WHB)
#else /* if defined(VINLINE_WHB) */
#endif /* if !defined(VINLINE_WHB) */

/*
 * ***************************************************************************
 * Class Whb: Non-Inlineable methods (whb.c)
 * ***************************************************************************
 */

void HBvec_hbVcyc(HBvec *dd, HBmat *Ahb, HBvec *rr,
    HBmat *Ghb, HBvec *ww, int key, int csolv);

void HBvec_initStructure(HBvec *thee, HBmat *Ahb);

void HBvec_killStructure(HBvec *thee);

void HBmat_initG(HBmat *thee, Bmat *Ppro, Bmat *Mlink, int meth);

void HBmat_initA(HBmat *Ahb, HBmat *Ghb, Bmat *Alink);

void HBmat_killStructure(HBmat *thee);
/*
 * ***************************************************************************
 * Class Whb: Non-Inlineable methods (bvechb.c)
 * ***************************************************************************
 */

void Bvec_hlmethod(Bvec *thee, Bmat *A, Bvec *f, Bvec *r, Bvec *ut,
    int key, int flag, int itmax, double etol, int prec, int cycle, Bmat *P,
    Bmat *M, int meth);

void Bvec_hb(Bvec *thee, Bmat *A, Bvec *f, Bvec *r, Bvec *ut,
    int key, int flag, int itmax, double etol, int meth, Bmat *Ppro, Bmat *M);

void Bvec_hcg(Bvec *thee, Bmat *A, Bvec *f, Bvec *r, Bvec *ut,
    int key, int flag, int itmax, double etol, int prec, Bmat *P, Bmat *M,
    Bvec *p, Bvec *ap, Bvec *bap, Bvec *po, Bvec *apo, Bvec *tp);

void Bvec_hbcg(Bvec *thee, Bmat *A, Bvec *f, Bvec *r, Bvec *ut,
    int key, int flag, int itmax, double etol, int prec, Bmat *P, Bmat *M,
    Bvec *s,
    Bvec *p, Bvec *ap, Bvec *bap, Bvec *po, Bvec *apo,
    Bvec *q, Bvec *atq, Bvec *btatq, Bvec *qo, Bvec *atqo);

void HBmat_initMulti( HBmat **Ahb, HBmat **Ghb,
    Bmat *A, Bmat *M, Bmat *Ppro, int meth );

void HBmat_killMulti( HBmat **Ahb, HBmat **Ghb );

/*
 * ***************************************************************************
 * Class Whb: Non-Inlineable methods (hbtools.c)
 * ***************************************************************************
 */

HBmat* HBmat_ctor(Vmem *vmem, const char *bname, int pnumB);

void HBmat_dtor(HBmat **thee);

HBvec* HBvec_ctor(Vmem *vmem, const char *bname, int pnumB);

void HBvec_dtor(HBvec **thee);

Bvec * Bvec_ctorPoint(Bvec *v, const char *name, int *ibase, int *numR);

void Bvec_dtorPoint(Bvec **thee);

Vec * Vec_ctorPoint(Vec *v, const char *name, int sep, int numR);

void Vec_dtorPoint(Vec **thee);

Bmat *Bmat_ctorPoint(Bmat *P,
    const char *name, int *ibase, int *numR);

void Bmat_dtorPoint(Bmat **thee);

Mat *Mat_ctorPoint(Mat *P, const char *name, int ibase, int numR);

void Mat_dtorPoint(Mat **thee);

void HBmat_printSp(HBmat *thee, char *fname, int pflag);

void Bmat_printDiriSp(Bmat *thee, char *fname, int pflag);

void Mat_printDiriSp(Mat *thee, char *fname, int pflag);

Mat *Bmat_AD(Bmat *thee, int p, int q);

void HBvec_matvec(HBvec *thee, HBmat *Gmat, int key, Bvec *work);

double Bmat_lnDet(Bmat *thee);

/*
 * ***************************************************************************
 * Class Whb: Non-Inlineable methods (brcmat.c)
 * ***************************************************************************
 */

void BXLN_copyBmat(Bmat *thee, Bmat *Amat);

void Bmat_copyBXLN(Bmat *thee, Bmat *Alink);

void BXLN_hbTriple(Bmat *thee, HBmat *G);

void BXLN_copyBlocks(Bmat *A, Bmat *A12, Bmat *A21, Bmat *A22);

void BXLN_shrinkLogical(Bmat *A, Bmat *A12, Bmat *A21);

void HBmat_GHB2WMHB(HBmat *thee, Bmat *M);

/*
 * ***************************************************************************
 * Class Whb: Non-Inlineable methods (rcmat.c)
 * ***************************************************************************
 */

void XLN_hbTriple(Mat *thee,
    Mat *GL21, Mat *GL12, Mat *GL22, Mat *GR21, Mat *GR12, Mat *GR22 );

void XLN_matmatContrib(Mat *thee,
    Mat *Ablock1, int ibase, int flag1, Mat *Ablock2, int jbase, int flag2);

void XLN_copySubblock(Mat *thee, Mat *Amat, int flag);

void XLN_copyBlocks(Mat *Ablock, Mat *A12, Mat *A21, Mat *A22);

void XLN_shrinkLogical(Mat *A, Mat *A12, Mat *A21);

void Mat_initGWMHB(Mat *G12, Mat *G22, Mat *G21, Mat *Mblock);

/*
 * ***************************************************************************
 * Class Whb: Non-Inlineable methods (subopt.c)
 * ***************************************************************************
 */

void Bvec_submethod(Bvec *thee, Bmat *A, Bvec *f, Bvec *r, Bvec *ut,
    int key, int flag, int itmax, double etol, int prec, int cycle, Bmat *P,
    int meth);

void Bvec_fsmooth(Bvec *thee, Bmat *amat, Bvec *f, Bvec *w,
    int key, int ioflag, int meth, int adj, int itmax, Bchar *fc);

Bchar* Bchar_ctor(Vmem *vmem,
    const char *name, int pnumB, int pnumR[MAXV]);

void Bchar_dtor(Bchar **thee);

void Bchar_assem(Bchar *thee, int key, Bmat *Ppro);


void Bchar_assem2(Bchar *thee, int key, Bmat *amat, Bmat *Ppro);

#endif /* _WHB_H_ */

---