global_mc class

Global group for MC. More...


Files

file  mtool.h
 Some sparse matrix tools.
file  mc_base.h
 The base (or foundation) header for MC.
file  dyn.h
 Class Dyn: dynamics library.
file  vel.h
 Class Vel: a canonical set element object.
file  ves.h
 Class V,E,S: the fundamental simplex geometry objects.
file  nam.h
 The primary header for the Nolinear Algebraic Mutilevel methods.
file  whb.h
 Class Whb: stabilized hierarchical basis library.
file  mc.h
 The foundation header for MC.

Classes

struct  aNode
 Class Node: Parameters and datatypes. More...
struct  Link
 A sparse matrix tool. More...
struct  LinkA
 A sparse matrix tool. More...
struct  LinkRC
 A sparse matrix tool. More...
struct  LinkRCS
 A sparse matrix tool. More...
struct  LinkRCN
 A sparse matrix tool. More...
struct  DynPDE
 Class DynPDE definition. More...
struct  Gip
 struct Gip (2*4=8 bytes) More...
struct  Vip
 struct Vip (3*8+3*4=36 bytes) More...
struct  Eip
 struct Eip (6*4=24 bytes) More...
struct  Fip
 struct Fip (3*4=12 bytes) More...
struct  Sip
 (14*4=56 bytes OR 24*4=96 bytes) More...
union  VES
 typedef union VES (40 bytes=max[36,24,40] OR 80 bytes=max[36,24,80]) More...
struct  Vel
 Class Vel: Definition (8+80 bytes). More...
struct  TT
 Class T: Definition. More...

Enumerations

enum  MATformat {
  ZERO_FORMAT, DRC_FORMAT, ROW_FORMAT, COL_FORMAT,
  SLU_FORMAT, RLN_FORMAT, CLN_FORMAT, XLN_FORMAT,
  RFL_FORMAT, CFL_FORMAT
}
 A sparse matrix tool. More...
enum  MATsym { ISNOT_SYM, IS_SYM, STRUC_SYM }
 matrix symmantec options More...
enum  MATmirror { ISNOT_MIRROR, IS_MIRROR }
 matrix mirrow options More...
enum  MATimpl { ISNOT_IMPL, IS_IMPL }
 the sparse matrix impl More...
enum  MATstate { NULL_STATE, ZERO_STATE, ASSEMBLED_STATE, FACTORED_STATE }
 different states of the sparse matrix More...
enum  DYNtype { SIMP_TYPE, TDEP_TYPE, NLIN_TYPE }
 Class Dyn: Parameters and datatypes. More...
enum  HBMATtype {
  ZERO_TYPE, AMIN_TYPE, ANOR_TYPE, GHB_TYPE,
  GWM_TYPE
}
 Class Whb: Parameters and datatypes.

Functions

void mPlaceit (int *IA, int *JA, double *A, int key, int i, int j, double val)
 Set or add a value to a matrix row/column.
void mContrib (Vset *mtpool, int key, int *count, int i, int j, double val)
 Set or add a value to a linked matrix entry list.
void lContrib (Vset *mtpool, int *count, int i, int j)
 Add a link to a linked graph entry list.
void mBuildGraphT (Vmem *vmem, int **IJAT, double **AT, int *ATnumO, int *IJA, double *A, int n, int m, int flag, int *work)
 Builds an index (and value) array in transposed format given the index and value array of a ROW or COL matrix.
void buildG (Vmem *vmem, MATformat frmt, MATsym sym, int m, int n, int *numO, int *numA, int **ijb, double **b, int **ib, int **jb, double **diagb, double **offUb, double **offLb, int *ir, int *jr, double *r, int *ia, int *ja, double *a, double *diag, double *offU, double *offL, int *ip, int *jp, double *p)
 Produce the sparse triple matrix product: B = R*A*P, where A is a sparse NxN square matrix, R is a sparse MxN retangular matrix, and P is a sparse NxM rectangular matrix, with M < N (possibly M << N).
The result is a smaller (but possibly much more dense) square MxM matrix B.

Detailed Description

Global group for MC.

Enumeration Type Documentation

enum DYNtype

Class Dyn: Parameters and datatypes.

Author:
Michael Holst

enum MATformat

A sparse matrix tool.

Author:
Michael Holst
Note:
Class MTOOL: Parameters and datatypes

enum MATimpl

the sparse matrix impl

Author:
Michael Holst
Note:
Class MTOOL: Parameters and datatypes

enum MATmirror

matrix mirrow options

Author:
Michael Holst
Note:
Class MTOOL: Parameters and datatypes

enum MATstate

different states of the sparse matrix

Author:
Michael Holst
Note:
Class MTOOL: Parameters and datatypes

enum MATsym

matrix symmantec options

Author:
Michael Holst
Note:
Class MTOOL: Parameters and datatypes

Function Documentation

void buildG ( Vmem *  vmem,
MATformat  frmt,
MATsym  sym,
int  m,
int  n,
int *  numO,
int *  numA,
int **  ijb,
double **  b,
int **  ib,
int **  jb,
double **  diagb,
double **  offUb,
double **  offLb,
int *  ir,
int *  jr,
double *  r,
int *  ia,
int *  ja,
double *  a,
double *  diag,
double *  offU,
double *  offL,
int *  ip,
int *  jp,
double *  p 
)

Produce the sparse triple matrix product: B = R*A*P, where A is a sparse NxN square matrix, R is a sparse MxN retangular matrix, and P is a sparse NxM rectangular matrix, with M < N (possibly M << N).
The result is a smaller (but possibly much more dense) square MxM matrix B.

Author:
Michael Holst
Note:
Class MTOOL: Non-inlineable methods (mtool.c)
 *           The input matrices R,A,P are assumed to have the following 
 *           storage formats:  R is stored column-wise (ROW-format), P is
 *           stored row-wise (ROW-format), and A is stored in one of three
 *           forms, namely, either row-wise (ROW), col-wise (COL), or by
 *           diagonal followed by upper-triangle row-wise and then by lower
 *           triangle columne-wise (DRC).  The resulting B is stored in the
 *           same format as the input matrix A.  I.e., the matrices have the
 *           following possible storage format combinations:
 *
 *           The matrices A and B in DRC format:
 *
 *                B  =       R       *    A    *  P
 *
 *               \--   | | | | | | |   \------   ---
 *               |\- = | | | | | | | * |\----- * ---
 *               ||\   | | | | | | |   ||\----   ---
 *                                     |||\---   ---
 *                                     ||||\--   ---
 *                                     |||||\-   ---
 *                                     ||||||\   ---
 *
 *           Or, the matrices A and B in ROW format:
 *
 *                B  =       R       *    A    *  P
 *
 *               ---   | | | | | | |   -------   ---
 *               --- = | | | | | | | * ------- * ---
 *               ---   | | | | | | |   -------   ---
 *                                     -------   ---
 *                                     -------   ---
 *                                     -------   ---
 *                                     -------   ---
 *
 *           Or, finally, the matrices A and B in COL format:
 *
 *                B  =       R       *    A    *  P
 *
 *               |||   | | | | | | |   |||||||   ---
 *               ||| = | | | | | | | * ||||||| * ---
 *               |||   | | | | | | |   |||||||   ---
 *                                     |||||||   ---
 *                                     |||||||   ---
 *                                     |||||||   ---
 *                                     |||||||   ---
 *
 *           We compute the product B = R*A*P by splitting up A into its
 *           three structures A=D+L+U, and then by splitting up the sum:
 *
 *               B = R*D*P + R*L*P + R*U*P
 *
 *           In the case of A in ROW form, only the last term is
 *           present.  In the case of COL form, only the middle
 *           term is present.  In the DRC case, all terms are present.
 *           Note that in the ROW and COL forms, U and L are not
 *           actually upper and lower triangular, but general rectangular
 *           matrices; this is all that we need here.  In the DRC form,
 *           they are strict triangles, but we never use this fact directly.
 *
 *           The first and last terms are easy to compute using the 
 *           datastructures used for R,D,U,P.  However, the middle term
 *           R*L*P is not straightforward to compute directly, since the
 *           lower-triangle L of A is stored column-wise rather than
 *           row-wise.  However, this product can be easily formed by 
 *           computing its transpose instead:
 *
 *               B = R*D*P + (P^T*L^T*R^T)^T + R*U*P
 *
 *           The product P^T*L^T*R^T is easy to compute using the column-wise
 *           structure of L, hence row-wise structure of L^T; the result is 
 *           then transposed and added into B.
 *
 *           The product is formed component-wise; no temporary matrices
 *           are stored, except for a linked-list structure to build the
 *           non-zero structure of B, which is not possible to predict
 *           without actually doing the product (at least symbolically).
 *
Returns:
None
Parameters:
vmem Memory management object
frmt possible format types of this matrix
sym symmetry keys for the matrix
m an index
n an index
numO num of nonzeros we are actually storing in the strict upper-triangle of matrix. (DRC only)
numA num of nonzeros we are actually storing, counting the diagonal, the strict upper-triangle, and also the strict lower-triangle if we are actually storing the lower-triangle (sym=0).
ijb Pointer to memory location of the arry ijb
b Pointer to memory location of the arry b
ib Pointer to memory location of the arry ib
jb Pointer to memory location of the arry jb
diagb Pointer to memory location of the arry diagb
offUb Pointer to memory location of the arry offUb
offLb Pointer to memory location of the arry offLb
ir Pointer to the arry ir
jr Pointer to the arry jr
r Pointer to the arry r
ia Pointer to the arry ia
ja Pointer to the arry ja
a Pointer to the arry a
diag Pointer to the arry diag
offU Pointer to the arry offU
offL Pointer to the arry offL
ip Pointer to the arry ip
jp Pointer to the arry jp
p Pointer to the arry p

void lContrib ( Vset *  mtpool,
int *  count,
int  i,
int  j 
)

Add a link to a linked graph entry list.

Authors:
Michael Holst and Stephen Bond
Note:
Class MTOOL: Non-inlineable methods (mtool.c)
Returns:
None
Parameters:
mtpool Pointer to a Class Vset
count Pointer to the inserted position
i an index
j an index

void mBuildGraphT ( Vmem *  vmem,
int **  IJAT,
double **  AT,
int *  ATnumO,
int *  IJA,
double *  A,
int  n,
int  m,
int  flag,
int *  work 
)

Builds an index (and value) array in transposed format given the index and value array of a ROW or COL matrix.

Author:
Stephen Bond
Note:
Class MTOOL: Non-inlineable methods (mtool.c)
(flag == 0) Build index array only, don't use matrix values.
(flag == 1) Build index array only, guard against zero values.
(flag == 2) Build index and val array, don't guard for zeros.
(flag == 3) Build index and val arrays, guard for zero values.

If the original A is ROW (COL) it must be of size nxm (mxn).
Hence, IJA, A, and work are n+1+numO, numO, and m respectively.
Returns:
None
Parameters:
vmem Memory management object
IJAT Pointer to the index array
AT Pointer to the trasposed A array
ATnumO number of nonzeros in each row (col)
IJA integer structure [ IA ; JA ]
A packed nozeros: DRC: [ diag ; offU ; offL ] ROW: [ offU ] COL: [ offL ] RFL: [ everything; stored row-wise ] CFL: [ everything; stored col-wise ]
n an index
m an index
flag 0 ==> Build index array only, don't use matrix values.
1 ==> Build index array only, guard against zero values.
2 ==> Build index and val array, don't guard for zeros.
3 ==> Build index and val arrays, guard for zero values.
work Pointer to the work array with zeros

void mContrib ( Vset *  mtpool,
int  key,
int *  count,
int  i,
int  j,
double  val 
)

Set or add a value to a linked matrix entry list.

Author:
Michael Holst
Note:
Class MTOOL: Non-inlineable methods (mtool.c)
Returns:
None
Parameters:
mtpool Pointer to a Class Vset
key 0 ==> Set the value, 1 ==> Add the value
count Pointer to the inserted position
i an index
j an index
val the value of the matrix component

void mPlaceit ( int *  IA,
int *  JA,
double *  A,
int  key,
int  i,
int  j,
double  val 
)

Set or add a value to a matrix row/column.

Author:
Michael Holst
Note:
Class MTOOL: Non-inlineable methods (mtool.c)
Returns:
None
Parameters:
IA pos in JA/offU/offL for row/col start
JA row/col indices for nonzeros in col/row
A packed nozeros: DRC: [ diag ; offU ; offL ] ROW: [ offU ] COL: [ offL ] RFL: [ everything; stored row-wise ] CFL: [ everything; stored col-wise ]
key 0 ==> Set the value, 1 ==> Add the value
i an index
j an index
val the value of the matrix component

Generated on Mon Aug 9 11:13:45 2010 for MC by  doxygen 1.5.6