KNMatrixOperation.h

Go to the documentation of this file.

#pragma once

#include "KNComplex.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <boost/align/aligned_allocator.hpp>
#include <iostream>
#include <vector>

class CKNMatrixOperation
{
public:

    class CKNDMatrix;

    typedef std::vector<double, boost::alignment::aligned_allocator<double, 64>>            double_vector_t;
    typedef std::vector<unsigned int, boost::alignment::aligned_allocator<unsigned int, 64>>    uint_vector_t;

    typedef struct{
        int             nRow;
        int             nColumn;
        double          fReal;
        double          fImaginary;
    } CSR_ELEMENT_DATA, *LPCSR_ELEMENT_DATA;

    typedef struct{
        int                             nColumnIndex;
        CKNMatrixOperation::CKNDMatrix  *pMatrix;
    } FILL_MATRIX_DATA, *LPFILL_MATRIX_DATA;

    class CKNVector{
    public:
        CKNVector(); 
        ~CKNVector(); 

        typedef struct{
            double      fReal;
            double      fImaginary;
        } VECTOR_ELEMENT, *LPVECTOR_ELEMENT;
        
        void                        SetSize(unsigned int nSize); 
        unsigned int                GetSize(){ return m_nValueCount; } 
        void                        SetAt(unsigned int nIndex, CKNComplex value); 
        void                        SetAtEx(unsigned int nIndex, CKNComplex *pValue); 
        void                        SetAt(unsigned int nIndex, double fReal, double fImaginary); 
        CKNComplex                  GetAt(unsigned int nIndex); 
        CKNComplex*                 GetAtPt(unsigned int nIndex); 
        void                        ResetValue(); 

        void                        ScalarMultiple(CKNComplex Scalar); 
        void                        ScalarMultiple(double fScalar); 
        void                        ScalarDivision(CKNComplex Scalar); 
        void                        ScalarDivision(double fScalar); 
        void                        BuildRandomVector(); 
        void                        Normalize(bool bMPI = false); 
        double                      GetNorm(bool bMPI = false); 
        void                        MinusVector(CKNVector *vector); 
        void                        PlusVector(CKNVector *vector); 
        void                        ScalarMultiThanMinusVector(double fScalar, CKNVector *vector); 
        void                        ReorthogonalizationVector(CKNVector *pVector, CKNComplex complex); 
        void                        Finalize(); 
        bool                        InsertVector(unsigned int nStartIndex, CKNMatrixOperation::CKNVector *pVector);
        bool                        Serialize(double *pBuffer, bool bStore); 

        CKNComplex                  operator*(CKNVector & vector); 
        CKNComplex                  operator*(CKNVector * vector); 
        CKNVector                   operator-(CKNVector & vector); 
        CKNVector                   operator-(CKNVector * vector); 
        CKNVector                   operator+(CKNVector & vector); 
        CKNVector                   operator+(CKNVector * vector); 
        void                        operator=(CKNVector &vector); 
        void                        operator=(CKNVector *vector); 
        
    private:
        double_vector_t                 m_vectValueRealBuffer; 
        double_vector_t                 m_vectValueImaginaryBuffer; 
        unsigned int                    m_nValueCount; 
        CKNComplex                      m_rtnTemp; 

        friend class CKNLanczosMethod;
        friend class CKNMatrixOperation;
        friend class CKNMPIManager;
    };

    class CKNDMatrix{
    public:
        CKNDMatrix(); 
        ~CKNDMatrix(); 
        
        enum APPEND_DRIECTION { ROW_DIRECTION, COLUMN_DIRECTION };

        bool                        BuildMatrixFirst(unsigned int nRow, unsigned int nColumn); 
        bool                        SetElement(unsigned int nRow, unsigned int nColumn, CKNComplex element); 
        bool                        SetElement(unsigned int nRow, unsigned int nColumn, double fRealNumber, double fImageNumber); 
        void                        AppendMatrix(APPEND_DRIECTION direction, unsigned int nCount); 
        unsigned int                GetRowCount(){ return m_nRowCount; } 
        unsigned int                GetColumnCount(){ return m_nColumnCount; } 
        bool                        SetDiagonal(CKNVector vector); 
        CKNComplex                  GetElement(unsigned int nRowIndex, unsigned int nColumnIndex); 
        bool                        SetColumnElement(CKNVector vector, unsigned int nColumnIndex); 
        bool                        SetRowElement(CKNVector vector, unsigned int nRowIndex); 
        bool                        SetElement(unsigned int nRowStart, unsigned int nColumnStart, unsigned int nSrcRowStart, unsigned int nSrcColumnStart, unsigned int nSrcRowCount, unsigned int nSrcColumnCount, CKNDMatrix matrix); 
        void                        ScalarMultiple(CKNComplex Scalar); 
        void                        ScalarMultiple(double fScalar); 
        bool                        GetRowByVector(unsigned int nRowIndex, CKNMatrixOperation::CKNVector *pVector); 
        bool                        GetColumnByVector(unsigned int nColumnIndex, CKNMatrixOperation::CKNVector *pVector); 
        bool                        GetSmallMatrix(unsigned int nRowStartIndex, unsigned int nColumnStartIndex, unsigned int nRowCount, unsigned int nColumnCount, CKNMatrixOperation::CKNDMatrix *pMatrix); 
        void                        ScalarDivision(double fScalar); 
        bool                        TrnasPos(); 

        void                        operator=(CKNDMatrix &matrix); 
        void                        operator=(CKNDMatrix *matrix); 
        void                        operator+=(CKNDMatrix &matrix); 
        void                        operator+=(CKNDMatrix *matrix); 

    private:
        std::vector<CKNComplex>     m_vectValueBuffer; 
        unsigned int                m_nRowCount; 
        unsigned int                m_nColumnCount; 
    };

    class CKNCSR{
    public:
        CKNCSR(); 
        ~CKNCSR(); 

        enum OPERATION_TYPE         { PLUS, MINUS, MULTIPLE, DIVISION };

        unsigned int                GetNoneZeroCount(){ return m_nValueCount; } 
        unsigned int                GetRowCount(){ return m_nRowCount; }; 
        unsigned int                GetColumnCount(){ return m_nColumnCount; }; 
        unsigned int                GetRowIndexNo(unsigned int nIndex); 
        unsigned int                GetColIndexNo(unsigned int nIndex); 
        CKNComplex*                 GetValue(unsigned int nIndex); 
        CKNComplex                  GetElement(unsigned int nRow, unsigned int nColumn, bool &bResult); 
        void                        Finalize(); 
        void                        ExpandMatrix(unsigned int nMulti, bool bRow, bool bColumn); 
        bool                        SetAt(CKNComplex number, unsigned int nRow, unsigned int nColumn); 
        bool                        InsertRowBefore(unsigned int nRow); 
        bool                        InsertRowAtEnd(); 
        bool                        InsertColumnBefore(unsigned int nColumn); 
        bool                        InsertColumnAtEnd(); 
        CKNCSR*                     SplitCSR(int nStart, int nEnd); 
        void                        BuildDataBuffer(); 
        void                        SetRowCount(unsigned int nRow){ m_nRowCount = nRow; } 
        void                        SetColumnCount(unsigned int nColumn){ m_nColumnCount = nColumn; } 
        bool                        InsertMatrix(unsigned int nRow, unsigned int nColumn, unsigned int nRowStart, unsigned int nColumnStart, unsigned int nRowCount, unsigned int nColumnCount, CKNMatrixOperation::CKNDMatrix *pMatrix, bool bCopyZero); 
        bool                        PushMatrix(unsigned int nRow, unsigned int nColumn, unsigned int nRowStart, unsigned int nColumnStart, unsigned int nRowCount, unsigned int nColumnCount, CKNMatrixOperation::CKNDMatrix *pMatrix, bool bCopyZero); 
        bool                        PushMatrixConcurrent(unsigned int nRow, CKNMatrixOperation::LPFILL_MATRIX_DATA lpData, bool bCopyZeroOnSite); 
        bool                        ElementScalarMultiple(unsigned int nRow, unsigned int nColumn, CKNComplex Scalar); 
        bool                        ElementScalarMultiple(unsigned int nRow, unsigned int nColumn, double fScalar); 
        bool                        AreaScalarMultiple(unsigned int nRowStart, unsigned int nRowCount, unsigned int nColumnStart, unsigned int nColumnCount, CKNComplex Scalar); 
        bool                        DiagonalOperation(CKNVector *pOperand, OPERATION_TYPE type, bool bUseSplitVector); 
        void                        SetFirstRowIndex(double fFirstIndex){ m_fFirstRowIndex = fFirstIndex; }; 
        double                      GetFirstRowIndex(){ return m_fFirstRowIndex; } 
        void                        PushNoneZeroValue(double fRealValue, double fImaginaryValue, unsigned int nRow, unsigned int nCol); 
        void                        FinishPush(); 
        bool                        ConvertDoubleArray(unsigned int *pRowPtr, unsigned int *pColIndex, double *pNNZValueReal, double *pNNZValueImaginary, unsigned int nNNZSize, unsigned int nRowSize, unsigned int nColSize, unsigned int nFirstIndex, bool bZerobase); 
        CKNVector                   operator*(CKNVector & vector); 
        CKNVector                   operator*(CKNVector * vector); 

        static unsigned int         MAX_INDEX; 
        unsigned int                nComponentsFirstUnitCell; 
        unsigned int                nComponentsLastUnitCell; 

    private:
        void                        DumpCSR(const char *pstrFileName); 
        void                        IncreaseNoneZeroCount(); 
        bool                        IsNonzeroElement(unsigned int nRow, unsigned int nColumn, unsigned int &nIndex); 
        unsigned int                GetNextNonzeroValueIndex(unsigned int nRow, unsigned int nColumn); 
        bool                        GetNextRowIndexValue(unsigned int nRowFrom, unsigned int &nValueIndex); 
        void                        IncreaseRowIndex(unsigned int nRowFrom); 

        unsigned int                m_nValueCount; 
        unsigned int                m_nValueStackCount; 
        double_vector_t             m_vectValueRealBuffer; 
        double_vector_t             m_vectValueImaginaryBuffer; 
        unsigned int                m_nRowCount; 
        unsigned int                m_nColumnCount; 
        uint_vector_t               m_vectRow; 
        uint_vector_t               m_vectColumn; 
        double                      m_fFirstRowIndex; 
        CKNComplex                  m_rtnTemp; 

        friend class CKNMatrixOperation;
        friend class CKNIPCCUtility;
        friend class CKNTBMS_Solver;
        friend class CKNMatrixOperation;
        friend class CKNLanczosLaunching;
    };

public:
    CKNMatrixOperation(); 
    ~CKNMatrixOperation(); 
    
    static CKNMatrixOperation::CKNCSR * BuildCSRFromOneDimArray(double *pReal, double *pImaginary, unsigned int nRowOrder, unsigned int nColumnOrder); 
    static CKNMatrixOperation::CKNCSR * BuildCSRFromFileTemp(FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount); 
    static CKNMatrixOperation::CKNCSR * BuildCSRFromFile_(FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount); 
    static CKNMatrixOperation::CKNCSR * BuildCSRFromFileUnsortdata(FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount); 
    static void FreeCSR(CKNMatrixOperation::CKNCSR *pCSR); 
    static void DumpCSR(CKNMatrixOperation::CKNCSR *pCSR, const char *pstrFileName){ pCSR->DumpCSR(pstrFileName); } 

    static void AllocateLocalCSR(CKNMatrixOperation::CKNCSR **mine, CKNMatrixOperation::CKNCSR **left, CKNMatrixOperation::CKNCSR **right);
    static void FreeLocalCSR(CKNMatrixOperation::CKNCSR *mine, CKNMatrixOperation::CKNCSR *left, CKNMatrixOperation::CKNCSR *right);
    static void BuildLocalCSR(CKNMatrixOperation::CKNCSR *source, CKNMatrixOperation::CKNCSR *mine, CKNMatrixOperation::CKNCSR *left, CKNMatrixOperation::CKNCSR *right);
    static void UpdateLocalCSR(CKNMatrixOperation::CKNCSR *source, CKNMatrixOperation::CKNCSR *mine, CKNMatrixOperation::CKNCSR *left, CKNMatrixOperation::CKNCSR *right);
    
    
    static int Compare(const void *pA, const void *pB); 
    static void MVMulEx_AsyncCommWithLocalBlocks(CKNMatrixOperation::CKNCSR *mylocalblock, CKNMatrixOperation::CKNCSR *leftlocalblock, CKNMatrixOperation::CKNCSR *rightlocalblock,
                                                 CKNVector *pVector, CKNVector *pResult,
                                                 double *X, double *Xrt, double *Xlt); 
    static void MVMulOptimal(CKNCSR *pAMatrix, CKNVector *pVector, CKNVector *pResult); 
    static void MVMulEx_Optimal(CKNCSR *pAMatrix, CKNVector *pVector, CKNVector *pResult, unsigned int, unsigned int, CKNVector*, int); 
    static void MVMul(CKNCSR *pAMatrix, CKNVector *pVector, CKNVector *pResult); 
    static bool VVDot(CKNVector *pVector1, CKNVector *pVector2, CKNComplex *pResult); 
    static void MVMul(CKNDMatrix *pMatrix, CKNVector *pVector, CKNVector *pResult); 
    static void MMMul(CKNDMatrix *pMatrix, CKNDMatrix *pMatrixOperand, CKNDMatrix *pResult); 
    static bool IsSame(double operand1, double operand2, double tol); 
    static bool IsSameA(double operand1, double operand2, double tol); 
    static bool IsSame(CKNComplex operand1, CKNComplex operand2, double tol); 
    static bool IsSame(CKNVector *pVector1, CKNVector *pVector2); 
    static int Gram_schmidt(CKNVector *pVect1, CKNVector *pVect2); 
    static CKNComplex   *pValueBuffer; 

    static unsigned int *pRow; 
    static unsigned int *pColumn; 
};

CKNMatrixOperation::CKNVector operator*(const double fScalar, CKNMatrixOperation::CKNVector & vector); 
CKNMatrixOperation::CKNVector operator/(CKNMatrixOperation::CKNVector & vector, const double fScalar);