malib.h

电力系统稀疏矩阵计算类,用法范例代码,包括三个目录,MALIB(类),MATEST(使用范例),INCLUDE(*.H),是我编写的电力系统能量管理系统基础类之一.

//===========================================================================
//
//                            EMS高级应用软件
//
//===========================================================================
//      矩阵运算函数
//      rev    0.0   6-10-2004      initial release   Qwbin
//      版本   0.0   6-10-2004      第一次发布        齐文斌
//----------------------------------------------------------------------------
//===========================================================================
//
//                            EMS高级应用软件
//
//===========================================================================
//      矩阵运算表
//      rev    0.0   6-10-2004      initial release   Qwbin
//      版本   0.0   6-10-2004      第一次发布        齐文斌
//             1.0   1-20-2006       C++ vector版     齐文斌   
//     	int Q_V;         
//		short lf_type;  状态量需要读取
//      输入数据: mastate_vt,maamtrx_vt;
//      输出数据: mastate_vt
//      其它变量,类内部自己处理
//----------------------------------------------------------------------------
#ifndef  EMSLIB_H_MATRIX
#define  EMSLIB_H_MATRIX

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "mctypes.h"
#include "matypes.h"

#include "mastate.h"
#include "maorder.h"
#include "maamtrx.h"
#include "magmtrx.h"
#include "maparm.h"
#include "matmtrx.h"
#include <vector>
#include <algorithm>
#include <functional> 

#ifdef	_WINDOWS
	#ifndef MATRIX_CLASS_EXPORT
		#define MATRIX_CLASS_EXPORT __declspec(dllimport)
	#else
		#define MATRIX_CLASS_EXPORT __declspec(dllexport)
	#endif
#else
	#define MATRIX_CLASS_EXPORT
#endif

class MATRIX_CLASS_EXPORT EmsMatrix
{

protected:

	    std::vector<struct maorderst*> maorder1_vt;
		std::vector<struct maorderst*> maorder2_vt;
	    std::vector<struct matmtrxst*> matmtrx_vt;
	
		std::vector<struct magmtrst*>  magmtr1_vt;
		std::vector<struct magmtrst*>  magmtr2_vt;

 public:
        std::vector<struct mastatest*> mastate_vt;
		std::vector<struct maorderst*> maorder_vt;
   
		std::vector<struct magmtrxst*> magmtrx_vt;
		std::vector<struct maamtrxst*> maamtrx_vt;

		char * mastateft;
		char * maorderft;
		char * maorder1ft;
		char * maorder2ft;
		char * maamtrxft;
		char * cmtrxft;
		char * magmtrxft;
		char * magmtr1ft;
		char * magmtr2ft;
		char * matmtrxft;

		struct maorderst *maorder1pt;
		struct maorderst *maorder2pt;
		struct magmtrxst *magmtr1pt;
		struct magmtrxst *magmtr2pt;
	
       //struct maparmst
        struct mastatest *mastatept;  // ptr to mastate               
		struct maorderst *maorderpt;  // ptr to maorder                
		struct maamtrxst *maamtrxpt;  // ptr to maamtrx (input order) 
		struct magmtrxst *magmtrxpt;  // ptr to magmtrx               
		struct maamtrxst *cmtrxpt;    // ptr to maamtrx (calc order)  
        
		//冗余信息,初始值如何赋????void opinitialize(struct opworkst *)处赋值;
		int nmaamtrx;              // ptr to maamtrx item count    
		int nmagmtrx;              // ptr to magmtrx item count    
		int divg_state_pt;         // ptr to divergent state number
		int nmastate;              // ptr to mastate item count   
		//
		int Q_V;
		short lf_type;
       //
private:

	   //for maoptim
		void opinitialize(struct opworkst *);
		int  test_symmetry( struct opworkst * );
		void make_symmetric( struct opworkst * );
		void scheme1( struct opworkst * );
		void reorder_scheme1( struct opworkst * );
		void pivot( struct oporderst *, struct oporderst * );
		void shift_order( struct oporderst *, struct oporderst * );
		void scheme2( struct opworkst * );
		void opterminate( struct opworkst * );
		void fillin( struct opstatest *, struct opstatest *, struct opworkst * );
		void eliminate( struct opstatest *, struct opstatest *, struct opworkst * );
        
		//triang
		void luinitialize (struct workst * );
        void initialize_row (struct orderst *, struct workst * );
        void evaluate_row (struct orderst *, struct workst * );
        int  normalize_row (struct orderst *, struct workst * );
        void luterminate (struct workst *, int );
        
		//mainvent
		int  check_parms (void);
        void calc_matmtrx  (void);
		void proc_ainv_calc (void);
		void calc_diag (struct maorderst *, double *);
		void proc_off_diags(int,struct maorderst *, double);
		void calc_off_diag (int,struct maorderst *, struct magmtrxst *,double);
        double get_zkj (int, int, int,double);

		void forward_substitution(void);
        void backward_substitution(void);

		//for opf maaasolve() 
		void opfinitialize(struct workst * );
        void opfinitialize_row( struct orderst *, struct workst * );
        int  opfevaluate_row( struct orderst *, struct workst * );
        void opfnormalize_row( struct orderst *, struct workst * );
        void opfterminate( struct workst *, int );

		void opfinitialize(void);
        void opfforward_sub(void);
        void opfdivide_diagonal(void);
        void opfbackward_sub(void);

        //for lf ca  
		void initialize(void);
        void forward_sub(void);
        void divide_diagonal(void);
        void backward_sub (void);

		int lfinitialize_row(struct maorderst *);
        int lfevaluate_row(struct maorderst  *);
        void lftag_row(struct magmtrxst *);
        int lfnormalize_row(struct maorderst *);

public:
		
	    EmsMatrix();
        ~EmsMatrix();
	    int matriang(void);
		int maatrian(void);
		int maptrian(void);
		int maffbsub(void);
		int mafbsub(void);
		int maafbsub(void);
		int maoptim(void);
		int mareordr(void);
		int maareord(void);
		int masprin(void);
		int mainvert(void);

		bool masolve(void);
		bool maasolve(void); //opf用

};

#endif