sparsem.h

是稀疏矩阵库以及全矩阵和稀疏矩阵分析程序源代码

	~CSparseMatrix();


private:
	void new_list(LINKED_LIST &list);
	// 生成双链表结构 list
	void clr_list(LINKED_LIST &list);
	// 清零双链表结构 list
	void delete_list(LINKED_LIST &list);
	// 删除双链表结构 list
	void new_table(INT2 rank_max,INT2 nonzero,TRIANGULAR_TABLE &table);
	// 生成三角形表结构 table, 最大阶数为 rank_max, 非零元素数为 nonzero
	void new_table(INT2 rank_max,INT2 nonzero,TRIANGULAR_TABLE_C &table);
	// 生成复数三角形表结构 table, 最大阶数为 rank_max, 非零元素数为 nonzero
	void delete_table(TRIANGULAR_TABLE &table);
	// 删除三角形表结构 table
	void delete_table(TRIANGULAR_TABLE_C &table);
	// 删除复数三角形表结构 table
	char insert_row(INT2 nza, INT2 x, INT2 y, LINKED_LIST &list);
	// 在双链接表 list 所描述的稀疏矩阵行链中, 插入第 nza 号元素 a[x][y]
	char insert_col(INT2 nza, INT2 x, INT2 y, LINKED_LIST &list);
	// 在双链接表 list 所描述的稀疏矩阵列链中, 插入第 nza 号元素 a[x][y]
	INT2 insert_ele(INT2 x, INT2 y, LINKED_LIST &list);
	/* 在双链接表 list 所描述的稀疏矩阵行链中, 插入元素 a[x][y],返回其标号;
	   如果未插入,返回 0*/
	INT2 ele_num(INT2 x, INT2 y, LINKED_LIST &list);
	// 返回 a[x][y] 在双链接表 list 中的标号。若是零元素, 返回 0。
	void del_row(INT2 m, LINKED_LIST &list);
	// 在双链接表 list 所描述的稀疏矩阵中, 作上删去第 m 行的标记。
	void del_col(INT2 m, LINKED_LIST &list);
	// 在双链接表 list 所描述的稀疏矩阵中, 作上删去第 m 列的标记。
	void nzerorc(LINKED_LIST &list, INT2 *nzr, INT2 *nzc);
	/* 计算双链接表 list 所描述的稀疏矩阵各行/列量, 即非零元素个数,置于数
	   组 nzr[]/nzc[]*/
	void fillin_f(INT2 x, INT2 y, LINKED_LIST &list, INT2 *fill);
	// x 行/y 列增加填元 a[x][y] 后, 对候选主元 x/y 填元数的影响
	void fill_in(INT2 q, LINKED_LIST &list, INT2 *fill, INT2 *fill_row,
		INT2 *fill_col, char id);
	/* 处理双链接表 list 所描述的稀疏矩阵在 LU 分解过程中, 以 a[q][q] 为主
	   元时产生的填元, 用于优化排序:	
	   (1) 生成主元或候补主元 a[q][q] 产生的填元数 fill[q]
	   (2) 将生成的填元行/列标存入 fill_row[]/fill_col[]
	   (3) 确定非零元素总数 nza 的当前值, 及当前填元号
	   (4) 插入填元, 修改双重链接表             
	   id=1 时, 作 (1)。
	   id=2 时, 作 (1),(2)。
	   id=3 时, 作 (1),(2),(3),(4)。
	*/
	void fill_in(INT2 k, INT2 mi, INT2 mj, LINKED_LIST &list, INT2 *fill, 
		INT2 *fill_row, INT2 *fill_col);
	/* 处理双链接表 list 所描述的稀疏矩阵在 LU 分解过程中, 第 k 步以 a[mi][mj]
	   为主元时产生的填元, 用于优化排序:	
	   (1) 生成主元或候补主元 a[mi][mj] 产生的填元数 fill[k]
	   (2) 将生成的填元行/列标存入 fill_row[]/fill_col[]
	   (3) 插入填元, 修改双重链接表 
	*/
	void fillmin(INT2 n, INT2 k, PRC *prc, INT2 *fill);
	/* 根据填元数数组 fill[], 在 prci=k~n] 中找出填元数最小的候选主元号, 交
	   换到 prck] 位置。*/
	void lop_min(INT2 n, INT2 k, PRC *prc, INT2 *nzr, INT2 *nzc, INT2 *lopmin);
	/* 根据行量/列量数组 nzr[]/nzc[] 计算  prci=k~n] 中各候选主元长运算量 
	   LOP, 找出 LOP 数最小的候选主元号, 交换到 prck] 位置。*/
	void lop_min(INT2 k, LINKED_LIST &list, PRC *prow, PRC *pcol, INT2 *nzr, 
		INT2 *nzc, INT2 *lopmin);
	/* 根据行量/列量数组 nzr[]/nzc[] 计算  prow/pcol[i=k~n] 中各候选主元长运算
	   量 LOP, 找出 LOP 数最小的候选主元号, 交换到 prow/pcol[k] 位置。*/
	void del_rc_p(INT2 m, LINKED_LIST &list, INT2 *nzr, INT2 *nzc);
	/* 在双链接表 list 所描述的稀疏矩阵中, 删去第 m 主行/列, 对其它候选主元
	   产生的列量/行量数组 nzc[]/nzr[] 的影响*/
	void del_r_f(INT2 m, LINKED_LIST &list, INT2 *fill);
	/* 在双链接表 list 所描述的稀疏矩阵中, 删去第 m 主行, 对其它候选主元产
	   生的填元数 fill[] 的影响*/
	void del_c_f(INT2 m, LINKED_LIST &list, INT2 *fill);
	/* 在双链接表 list 所描述的稀疏矩阵中, 删去第 m 主列, 对其它候选主元产
	   生的填元数 fill[] 的影响*/
	void del_rc_p(INT2 mi, INT2 mj, LINKED_LIST &list, INT2 *nzr, INT2 *nzc);
	/* 在双链接表 list 所描述的稀疏矩阵中, 删去第 mi 行 / mj 列, 对其它候选
	   主元产生的列量/行量数组 nzc[]/nzr[] 的影响*/
	INT2 tinney_walker(LINKED_LIST &list, PRC *prc);
	/* 用 Tinney_Walker 算法排序双链接表 list 所描述的稀疏矩阵, 排序后的
	   行/列顺序号放在数组 prc 中, 返回填元数。*/
	INT2 markowitz(LINKED_LIST &list,PRC *prc);
	/* 用 Markowitz 算法排序双链接表 list 所描述的稀疏矩阵, 排序后的行/列
	   顺序号放在数组 prc 中, 返回长运算数。*/
	INT2 markowitz(LINKED_LIST &list,PRC *prow,PRC *pcol);
	/* 用 Markowitz 算法排序双链接表 list 所描述的稀疏矩阵, 以下三角矩阵中的非
	   零元作为候选主元, 排序后的行/列顺序号放在 prow[]/pcol[] 中, 返回长运
	   算数*/
	void old_new(INT2 n, PRC *prc, OLD_NEW *old_newrc);
	// 由优化后排序号, 即新=>旧映射 prc] 生成旧=>新映射 old_newrc[]
	void old_new(INT2 n, PRC *prow, PRC *pcol, OLD_NEW *old_newr, 
		OLD_NEW *old_newc);
	/* 由优化后排序号, 即新=>旧映射 prow[] / pcol[] 生成旧=>新映
	   射 old_newr[] / old_newc[]*/
	void list_table(LINKED_LIST &list, PRC *prc, OLD_NEW *old_newrc, 
		TRIANGULAR_TABLE &table);
	// 将对角主元稀疏矩阵的双链接表 list 格式转换成三角形表 table。
	void list_table(LINKED_LIST &list, PRC *prow, PRC *pcol, OLD_NEW *old_newr, 
		OLD_NEW *old_newc, TRIANGULAR_TABLE &table);
	// 将稀疏矩阵的双链接表 list 格式转换成三角形表 table
	void list_table(LINKED_LIST &list, PRC *prow, PRC *pcol, 
		OLD_NEW *old_newr, OLD_NEW *old_newc, TRIANGULAR_TABLE_C &table);
	// 将稀疏矩阵的双链接表 list 格式转换成三角形表 table。
	INT2 ele_num(INT2 x, INT2 y, TRIANGULAR_TABLE &table);
	// 返回 a[x][y] 在三角形表 table 中的标号。若是零元素, 返回 0。
	INT2 ele_num(INT2 x, INT2 y, TRIANGULAR_TABLE_C &table);
	// 返回 a[x][y] 在三角形表 table 中的标号。若是零元素, 返回 0。
	INT2 ele_num(INT2 x, TRIANGULAR_TABLE &table);
	// 返回右端向量 b[x] 在三角形表 table 中的标号。若是零元素, 返回 0。
	INT2 ele_num(INT2 x, TRIANGULAR_TABLE_C &table);
	// 返回复数右端向量 b[x] 在三角形表 table 中的标号。若是零元素, 返回 0。
	void sym_lu(TRIANGULAR_TABLE &table);
	/* 根据稀疏矩阵的三角形表 table 进行符号 LU 分解, 确定每一步分解所需要修正
	   的元素编号, 即生成 table.lup[]。*/
	void sym_lu(TRIANGULAR_TABLE_C &table);
	/* 根据稀疏矩阵的三角形表 table 进行符号 LU 分解, 确定每一步分解所需要修正
	   的元素编号, 即生成 table.lup[]。*/
	char div_c(double are, double aim, double bre, double bim, double *cre,
		double *cim);
	// 复数除法: (*cre,*cim) = (are,aim) / (bre,bim)
	void mul_c(double are, double aim, double bre, double bim, double *cre,
	    double *cim);
	// 复数乘法: (*cre,*cim) = (are,aim) * (bre,bim)
	void xy_rp(double x, double y, double *r, double *p);
	// 复数直角表示 (x,y) => 极坐标表示 (r,p)
	char num_lu(TRIANGULAR_TABLE &table);
	// 根据稀疏矩阵的三角形表 table 进行数值 LU 分解。
	char num_lu(TRIANGULAR_TABLE_C &table);
	// 根据复数稀疏矩阵的三角形表 table 进行数值 LU 分解。 
	void vector_fillin(TRIANGULAR_TABLE &table);
	// 根据已输入右端向量的稀疏矩阵的三角形表 table 确定和插入向量填元。
	void vector_fillin(TRIANGULAR_TABLE_C &table);
	// 根据已输入右端向量的稀疏矩阵的三角形表 table 确定和插入向量填元。
	void sym_fe(TRIANGULAR_TABLE &table);
	/* 根据已输入右端向量的稀疏矩阵的三角形表 table 进行符号前消,
	   确定 table.fep[]。*/
	void sym_fe(TRIANGULAR_TABLE_C &table);
	/* 根据已输入右端向量的稀疏矩阵的三角形表 table 进行符号前消,
	   确定 table.fep[]。*/
	char num_fe(TRIANGULAR_TABLE &table);
	// 根据稀疏矩阵的三角形表 table 进行数值前消。右端向量化为中间解向量
	BOOL JudgeZeroT(TRIANGULAR_TABLE &table);
	// 判断矩阵对角元素是否为零
	char num_fe(TRIANGULAR_TABLE_C &table);
	// 根据复数稀疏矩阵的三角形表 table 进行数值前消。右端向量化为中间解向量
	BOOL JudgeZeroTC(TRIANGULAR_TABLE_C &table);
	// 判断矩阵对角元素是否为零
	void num_bs(TRIANGULAR_TABLE &table,double *x);
	// 根据数值前消后的稀疏矩阵三角形表 table 进行数值后代。 
	void num_bs(TRIANGULAR_TABLE_C &table,double *xre,double *xim);
	// 根据数值前消后的复数稀疏矩阵三角形表 table 进行数值后代。 
	char insert_coef(INT2 i,INT2 j,double val,OLD_NEW *old_newr,OLD_NEW *old_newc, 
	    TRIANGULAR_TABLE &table);
	// 给三角形表 table 赋系数值 a[i,j]=val
	char insert_coef(INT2 i,INT2 j,double val,OLD_NEW *old_newr, 
	    TRIANGULAR_TABLE &table);
	// 给三角形表 table 赋系数值 a[i,j]=val
	char insert_coef(INT2 i,INT2 j,double vre,double vim,OLD_NEW *old_newr,
	    OLD_NEW *old_newc,TRIANGULAR_TABLE_C &table);
	// 给三角形表 table 赋系数值 are[i,j]=vre, aim[i,j]=vim
	char insert_coef(INT2 i,INT2 j,double vre,double vim,OLD_NEW *old_newr,
	    TRIANGULAR_TABLE_C &table);
	// 给三角形表 table 赋系数值 are[i,j]=vre, aim[i,j]=vim
	char insert_vector(INT2 row,TRIANGULAR_TABLE &table,OLD_NEW *old_newr);
	// 在三角形表 table 中符号插入行号为 row 的一个右端向量元素;成功:返回 0
	void insert_vectorT(INT2 row,TRIANGULAR_TABLE &table);
	// 在三角形表 table 中符号插入行号为 row 的一个右端向量元素;成功:返回 0
	char insert_vector(INT2 row,TRIANGULAR_TABLE_C &table,OLD_NEW *old_newr);
	/* 在复数三角形表 table 中符号插入行号为 row 的一个右端向量元素;
	   成功:返回 0*/
	char insert_vector_val(INT2 i,double val,OLD_NEW *old_newr,
	    TRIANGULAR_TABLE &table);
	// 对三角形表 table 进行右端向量赋值: b[i]=val
	char insert_vector_val(INT2 i,double vre,double vim,OLD_NEW *old_newr,
	    TRIANGULAR_TABLE_C &table);
	// 对三角形表 table 进行右端向量赋值: b[i]=val
//	void translate_table( TRIANGULAR_TABLE *table_t );
	// 把三角形表转置为 table_t 

};

//
//复数计算 1998.11.20
//
class complex
{
public:
	double re;
	double im;	

public:
	complex(){re=0;im=0;};

	complex(double real,double image);
	
	complex operator+(complex);
	complex operator-(complex);
	complex operator*(complex);
	complex operator/(complex);
	//complex operator=(complex);
	
	complex operator+(double);
	complex operator-(double);
	complex operator*(double);
	complex operator/(double);
	complex operator=(double);
};
double Larg(complex);   //求角
double Labs(complex);   //求模
complex Conj(complex);  //求共轭
/////////////////////////////////////////////////////////////////////////////