SMG2S/c-smg2s_8h_source.html

/*

MIT License

Copyright (c) 2019 Xinzhe WU @ Maison de la Simulation, France

Copyright (c) 2019-2022, Xinzhe Wu @ Simulation and Data Laboratory Quantum

                                     Materials,  Forschungszentrum Juelich GmbH.


Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

*/


#ifndef __C_SMG2S_H__

#define __C_SMG2S_H__


#include <mpi.h>

#include <stdint.h>


#ifdef __cplusplus

extern "C"{

#endif


struct dcomplex{

    double real;

    double imag;

};


typedef struct dcomplex dcomplex_t;


//interface of classes and structs

/*Nilpotency Matrix C Wrapper*/

// int

struct nilp;

typedef struct nilp nilp_t;


nilp_t *newNilp_1(int nbOne, int size);

nilp_t *newNilp_2(int nbOne, int diag, int size);

nilp_t *newNilp_3(int *nilpvec, int size);

nilp_t *newNilp_4(int *nilpvec, int diag, int size);

void nilp_destory(nilp_t *nilp);

int nilp_getDegree(nilp_t *nilp);

int* nilp_getIndOfZeros(nilp_t *nilp);

void nilp_show(nilp_t *nilp);


// long int

struct nilpL;

typedef struct nilpL nilpL_t;

nilpL_t *newNilpL_1(long nbOne, long size);

nilpL_t *newNilpL_2(long nbOne, long diag, long size);

nilpL_t *newNilpL_3(long *nilpvec, long size);

nilpL_t *newNilpL_4(long *nilpvec, long diag, long size);

void nilpL_destory(nilpL_t *nilp);

long nilpL_getDegree(nilpL_t *nilp);

long* nilpL_getIndOfZeros(nilpL_t *nilp);

void nilpL_show(nilpL_t *nilp);


/*init matrix struct*/

//int

struct initMatrix;

typedef struct initMatrix initMatrix_t;

initMatrix_t *newInitMatrix_1();

initMatrix_t *newInitMatrix_2(int diagl, int diagu);

initMatrix_t *newInitMatrix_3(int diagl, int diagu, double Sparsity);

initMatrix_t *newInitMatrix_4(int diagl, int diagu, double Scale, double Sparsity);

void initMatrix_show(initMatrix_t *init);

void initMatrix_destory(initMatrix_t *init);


//long

struct initMatrixL;

typedef struct initMatrixL initMatrixL_t;

initMatrixL_t *newInitMatrixL_1();

initMatrixL_t *newInitMatrixL_2(long diagl, long diagu);

initMatrixL_t *newInitMatrixL_3(long diagl, long diagu, double Sparsity);

initMatrixL_t *newInitMatrixL_4(long diagl, long diagu, double Scale, double Sparsity);

void initMatrixL_show(initMatrixL_t *init);

void initMatrixL_destory(initMatrixL_t *init);


/*parVectorMap*/

struct parVecMap;

typedef struct parVecMap parVecMap_t;

parVecMap_t *newParVecMap_empty();

parVecMap_t *newParVecMap(MPI_Comm ncomm, int lbound, int ubound);

MPI_Comm parVecMapGetComm(parVecMap_t *pv);

int parVecMapL2G(parVecMap_t *pv, int local_index);

int parVecMapG2L(parVecMap_t *pv, int global_index);

int parVecMapGetLocSize(parVecMap_t *pv);

int parVecMapGetGlobSize(parVecMap_t *pv);

void parVecMap_destory(parVecMap_t *pv);


struct parVecMapL;

typedef struct parVecMapL parVecMapL_t;

parVecMapL_t *newParVecMapL_empty();

parVecMapL_t *newParVecMapL(MPI_Comm ncomm, long lbound, long ubound);

MPI_Comm parVecMapLGetComm(parVecMapL_t *pv);

long parVecMapLL2G(parVecMapL_t *pv, long local_index);

long parVecMapLG2L(parVecMapL_t *pv, long global_index);

long parVecMapLGetLocSize(parVecMapL_t *pv);

long parVecMapLGetGlobSize(parVecMapL_t *pv);

void parVecMapL_destory(parVecMapL_t *pv);


/*parVector*/

//double int

struct ds_parVec;

typedef struct ds_parVec ds_parVec_t;

ds_parVec_t *new_ds_ParVec_1(MPI_Comm ncomm, int lbound, int ubound);

ds_parVec_t *new_ds_ParVec_2(parVecMap_t *map);

void ds_parVec_destory(ds_parVec_t *pv);

int ds_parVecGetLowerBound(ds_parVec_t *pv);

int ds_parVecGetUpperBound(ds_parVec_t *pv);

int ds_parVecGetLocSize(ds_parVec_t *pv);

int ds_parVecGetGlobSize(ds_parVec_t *pv);

double ds_parVecGetVal(ds_parVec_t *pv, int index);

double ds_parVecGetValLoc(ds_parVec_t *pv, int lindex);

double *ds_parVecGetArray(ds_parVec_t *pv);

parVecMap_t *ds_parVecGetMap(ds_parVec_t *pv);

MPI_Comm ds_parVecGetComm(ds_parVec_t *pv);

int ds_parVecL2G(ds_parVec_t *pv, int local_index);

int ds_parVecG2L(ds_parVec_t *pv, int global_index);

void ds_parVecSetToVal(ds_parVec_t *pv, double val);

void ds_parVecView(ds_parVec_t *pv);

void ds_parVecSetVal(ds_parVec_t *pv, int index, double val);

void ds_parVecSetValLoc(ds_parVec_t *pv, int lindex, double val);

void ds_parVecAdd(ds_parVec_t *pv, ds_parVec_t *pv2);

void ds_parVecScale(ds_parVec_t *pv, double scale);

double ds_parVecDot(ds_parVec_t *pv, ds_parVec_t *pv2);

void ds_parVecReadExtVec(ds_parVec_t *pv, char* spectrum);

void ds_writeToTxt(ds_parVec_t *pv, char* spectrum);


//double long

struct dl_parVec;

typedef struct dl_parVec dl_parVec_t;

dl_parVec_t *new_dl_ParVec_1(MPI_Comm ncomm, long lbound, long ubound);

dl_parVec_t *new_dl_ParVec_2(parVecMapL_t *map);

void dl_parVec_destory(dl_parVec_t *pv);

long dl_parVecGetLowerBound(dl_parVec_t *pv);

long dl_parVecGetUpperBound(dl_parVec_t *pv) ;

long dl_parVecGetLocSize(dl_parVec_t *pv);

long dl_parVecGetGlobSize(dl_parVec_t *pv);

double dl_parVecGetVal(dl_parVec_t *pv, long index);

double dl_parVecGetValLoc(dl_parVec_t *pv, long lindex);

double *dl_parVecGetArray(dl_parVec_t *pv);

parVecMapL_t *dl_parVecGetMap(dl_parVec_t *pv);

MPI_Comm dl_parVecGetComm(dl_parVec_t *pv);

long dl_parVecL2G(dl_parVec_t *pv, long local_index);

long dl_parVecG2L(dl_parVec_t *pv, long global_index);

void dl_parVecSetToVal(dl_parVec_t *pv, double val);

void dl_parVecView(dl_parVec_t *pv);

void dl_parVecSetVal(dl_parVec_t *pv, long index, double val);

void dl_parVecSetValLoc(dl_parVec_t *pv, long lindex, double val);

void dl_parVecAdd(dl_parVec_t *pv, dl_parVec_t *pv2);

void dl_parVecScale(dl_parVec_t *pv, double scale);

double dl_parVecDot(dl_parVec_t *pv, dl_parVec_t *pv2);

void dl_parVecReadExtVec(dl_parVec_t *pv, char* spectrum);

void dl_writeToTxt(dl_parVec_t *pv, char* spectrum);


//double complex int

struct zs_parVec;

typedef struct zs_parVec zs_parVec_t;

zs_parVec_t *new_zs_ParVec_1(MPI_Comm ncomm, int lbound, int ubound);

zs_parVec_t *new_zs_ParVec_2(parVecMap_t *map);

void zs_parVec_destory(zs_parVec_t *pv);

int zs_parVecGetLowerBound(zs_parVec_t *pv);

int zs_parVecGetUpperBound(zs_parVec_t *pv);

int zs_parVecGetLocSize(zs_parVec_t *pv);

int zs_parVecGetGlobSize(zs_parVec_t *pv);

dcomplex_t zs_parVecGetVal(zs_parVec_t *pv, int index);

dcomplex_t zs_parVecGetValLoc(zs_parVec_t *pv, int lindex);

dcomplex_t *zs_parVecGetArray(zs_parVec_t *pv);

parVecMap_t *zs_parVecGetMap(zs_parVec_t *pv);

MPI_Comm zs_parVecGetComm(zs_parVec_t *pv);

int zs_parVecL2G(zs_parVec_t *pv, int local_index);

int zs_parVecG2L(zs_parVec_t *pv, int global_index);

void zs_parVecSetToVal(zs_parVec_t *pv, dcomplex_t val);

void zs_parVecView(zs_parVec_t *pv);

void zs_parVecSetVal(zs_parVec_t *pv, int index, dcomplex_t val);

void zs_parVecSetValLoc(zs_parVec_t *pv, int lindex, dcomplex_t val);

void zs_parVecAdd(zs_parVec_t *pv, zs_parVec_t *pv2);

void zs_parVecScale(zs_parVec_t *pv, dcomplex_t scale);

dcomplex_t zs_parVecDot(zs_parVec_t *pv, zs_parVec_t *pv2);

void zs_parVecReadExtVec(zs_parVec_t *pv, char* spectrum);

void zs_writeToTxtCmplx(zs_parVec_t *pv, char* spectrum);


//double complex long

struct zl_parVec;

typedef struct zl_parVec zl_parVec_t;

zl_parVec_t *new_zl_ParVec_1(MPI_Comm ncomm, long lbound, long ubound);

zl_parVec_t *new_zl_ParVec_2(parVecMapL_t *map);

void zl_parVec_destory(zl_parVec_t *pv);

long zl_parVecGetLowerBound(zl_parVec_t *pv);

long zl_parVecGetUpperBound(zl_parVec_t *pv) ;

long zl_parVecGetLocSize(zl_parVec_t *pv);

long zl_parVecGetGlobSize(zl_parVec_t *pv);

dcomplex_t zl_parVecGetVal(zl_parVec_t *pv, long index);

dcomplex_t zl_parVecGetValLoc(zl_parVec_t *pv, long lindex);

dcomplex_t *zl_parVecGetArray(zl_parVec_t *pv);

parVecMapL_t *zl_parVecGetMap(zl_parVec_t *pv);

MPI_Comm zl_parVecGetComm(zl_parVec_t *pv);

long zl_parVecL2G(zl_parVec_t *pv, long local_index);

long zl_parVecG2L(zl_parVec_t *pv, long global_index);

void zl_parVecSetToVal(zl_parVec_t *pv, dcomplex_t val);

void zl_parVecView(zl_parVec_t *pv);

void zl_parVecSetVal(zl_parVec_t *pv, long index, dcomplex_t val);

void zl_parVecSetValLoc(zl_parVec_t *pv, long lindex, dcomplex_t val);

void zl_parVecAdd(zl_parVec_t *pv, zl_parVec_t *pv2);

void zl_parVecScale(zl_parVec_t *pv, dcomplex_t scale);


dcomplex_t zl_parVecDot(zl_parVec_t *pv, zl_parVec_t *pv2);

void zl_parVecReadExtVec(zl_parVec_t *pv, char* spectrum);

void zl_writeToTxtCmplx(zl_parVec_t *pv, char* spectrum);


/*parMatrixSparse*/


//double int

struct ds_parMatSparse;

typedef struct ds_parMatSparse ds_parMatSparse_t;

ds_parMatSparse_t *new_ds_ParMatSparse_1(ds_parVec_t *pv);

ds_parMatSparse_t *new_ds_ParMatSparse_2(parVecMap_t *map);

void ds_parMatSparse_destory(ds_parMatSparse_t *pm);

int ds_parMatSparse_GetNRows(ds_parMatSparse_t *pm);

int ds_parMatSparse_GetNCols(ds_parMatSparse_t *pm);

int ds_parMatSparse_GetNNzLoc(ds_parMatSparse_t *pm);

int ds_parMatSparse_GetLowerBound(ds_parMatSparse_t *pm);

int ds_parMatSparse_GetUpperBound(ds_parMatSparse_t *pm);

MPI_Comm ds_parMatSparse_GetComm(ds_parMatSparse_t *pm);

void ds_parMatSparse_SetValLocal(ds_parMatSparse_t *pm, int row, int col, double val);

void ds_parMatSparse_SetVal(ds_parMatSparse_t *pm, int row, int col, double val);

void ds_parMatSparse_AddValLocal(ds_parMatSparse_t *pm, int row, int col, double val);

void ds_parMatSparse_AddVal(ds_parMatSparse_t *pm, int row, int col, double val);

double ds_parMatSparse_GetValLocal(ds_parMatSparse_t *pm, int row, int col);

double ds_parMatSparse_GetVal(ds_parMatSparse_t *pm, int row, int col);


void ds_parMatSparse_toCSRArray(ds_parMatSparse_t *pm, int *nrows, int *nnz, int **roffs, int **cols, double **val);

void ds_parMatSparse_Show(ds_parMatSparse_t *pm);

void ds_parMatSparse_View(ds_parMatSparse_t *pm);

void ds_parMatSparse_Wrt2MM(ds_parMatSparse_t *pm, char *file_name);

void ds_parMatSparse_initMat(ds_parMatSparse_t *pm, int diagl, int diagu, double Scale, double Sparsity);


//double long

struct dl_parMatSparse;

typedef struct dl_parMatSparse dl_parMatSparse_t;

dl_parMatSparse_t *new_dl_ParMatSparse_1(dl_parVec_t *pv);

dl_parMatSparse_t *new_dl_ParMatSparse_2(parVecMapL_t *map);

void dl_parMatSparse_destory(dl_parMatSparse_t *pm);

long dl_parMatSparse_GetNRows(dl_parMatSparse_t *pm);

long dl_parMatSparse_GetNCols(dl_parMatSparse_t *pm);

long dl_parMatSparse_GetNNzLoc(dl_parMatSparse_t *pm);

long dl_parMatSparse_GetLowerBound(dl_parMatSparse_t *pm);

long dl_parMatSparse_GetUpperBound(dl_parMatSparse_t *pm);

MPI_Comm dl_parMatSparse_GetComm(dl_parMatSparse_t *pm);

void dl_parMatSparse_SetValLocal(dl_parMatSparse_t *pm, long row, long col, double val);

void dl_parMatSparse_SetVal(dl_parMatSparse_t *pm, long row, long col, double val);

void dl_parMatSparse_AddValLocal(dl_parMatSparse_t *pm, long row, long col, double val);

void dl_parMatSparse_AddVal(dl_parMatSparse_t *pm, long row, long col, double val);

double dl_parMatSparse_GetValLocal(dl_parMatSparse_t *pm, long row, long col);

double dl_parMatSparse_GetVal(dl_parMatSparse_t *pm, long row, long col);


void dl_parMatSparse_toCSRArray(dl_parMatSparse_t *pm, long *nrows, long *nnz, long **roffs, long **cols, double **val);

void dl_parMatSparse_Show(dl_parMatSparse_t *pm);

void dl_parMatSparse_View(dl_parMatSparse_t *pm);

void dl_parMatSparse_Wrt2MM(dl_parMatSparse_t *pm, char *file_name);

void dl_parMatSparse_initMat(dl_parMatSparse_t *pm, long diagl, long diagu, double Scale, double Sparsity);


//dcomplex_t int

struct zs_parMatSparse;

typedef struct zs_parMatSparse zs_parMatSparse_t;

zs_parMatSparse_t *new_zs_ParMatSparse_1(zs_parVec_t *pv);

zs_parMatSparse_t *new_zs_ParMatSparse_2(parVecMapL_t *map);

void zs_parMatSparse_destory(zs_parMatSparse_t *pm);

int zs_parMatSparse_GetNRows(zs_parMatSparse_t *pm);

int zs_parMatSparse_GetNCols(zs_parMatSparse_t *pm);

int zs_parMatSparse_GetNNzLoc(zs_parMatSparse_t *pm);

int zs_parMatSparse_GetLowerBound(zs_parMatSparse_t *pm);

int zs_parMatSparse_GetUpperBound(zs_parMatSparse_t *pm);

MPI_Comm zs_parMatSparse_GetComm(zs_parMatSparse_t *pm);

void zs_parMatSparse_SetValLocal(zs_parMatSparse_t *pm, int row, int col, dcomplex_t val);

void zs_parMatSparse_SetVal(zs_parMatSparse_t *pm, int row, int col, dcomplex_t val);

void zs_parMatSparse_AddValLocal(zs_parMatSparse_t *pm, int row, int col, dcomplex_t val);

void zs_parMatSparse_AddVal(zs_parMatSparse_t *pm, int row, int col, dcomplex_t val);

dcomplex_t zs_parMatSparse_GetValLocal(zs_parMatSparse_t *pm, int row, int col);

dcomplex_t zs_parMatSparse_GetVal(zs_parMatSparse_t *pm, int row, int col);


void zs_parMatSparse_toCSRArray(zs_parMatSparse_t *pm, int *nrows, int *nnz, int **roffs, int **cols, dcomplex_t **val);

void zs_parMatSparse_Show(zs_parMatSparse_t *pm);

void zs_parMatSparse_View(zs_parMatSparse_t *pm);

void zs_parMatSparse_Wrt2MMCmplx(zs_parMatSparse_t *pm, char *file_name);

void zs_parMatSparse_initMat(zs_parMatSparse_t *pm, int diagl, int diagu, double Scale, double Sparsity);


//dcomplex_t long

struct zl_parMatSparse;

typedef struct zl_parMatSparse zl_parMatSparse_t;

zl_parMatSparse_t *new_zl_ParMatSparse_1(zl_parVec_t *pv);

zl_parMatSparse_t *new_zl_ParMatSparse_2(parVecMap_t *map);

void zl_parMatSparse_destory(zl_parMatSparse_t *pm);

long zl_parMatSparse_GetNRows(zl_parMatSparse_t *pm);

long zl_parMatSparse_GetNCols(zl_parMatSparse_t *pm);

long zl_parMatSparse_GetNNzLoc(zl_parMatSparse_t *pm);

long zl_parMatSparse_GetLowerBound(zl_parMatSparse_t *pm);

long zl_parMatSparse_GetUpperBound(zl_parMatSparse_t *pm);

MPI_Comm zl_parMatSparse_GetComm(zl_parMatSparse_t *pm);

void zl_parMatSparse_SetValLocal(zl_parMatSparse_t *pm, long row, long col, dcomplex_t val);

void zl_parMatSparse_SetVal(zl_parMatSparse_t *pm, long row, long col, dcomplex_t val);

void zl_parMatSparse_AddValLocal(zl_parMatSparse_t *pm, long row, long col, dcomplex_t val);

void zl_parMatSparse_AddVal(zl_parMatSparse_t *pm, long row, long col, dcomplex_t val);

dcomplex_t zl_parMatSparse_GetValLocal(zl_parMatSparse_t *pm, long row, long col);

dcomplex_t zl_parMatSparse_GetVal(zl_parMatSparse_t *pm, long row, long col);


void zl_parMatSparse_toCSRArray(zl_parMatSparse_t *pm, long *nrows, long *nnz, long **roffs, long **cols, dcomplex_t **val);

void zl_parMatSparse_Show(zl_parMatSparse_t *pm);

void zl_parMatSparse_View(zl_parMatSparse_t *pm);

void zl_parMatSparse_Wrt2MMCmplx(zl_parMatSparse_t *pm, char *file_name);

void zl_parMatSparse_initMat(zl_parMatSparse_t *pm, long diagl, long diagu, double Scale, double Sparsity);


//interface of selected functions

zs_parVec_t *zs_specNonHermLoad(parVecMap_t *map, char *spectrum);

zl_parVec_t *zl_specNonHermLoad(parVecMapL_t *map, char *spectrum);

zs_parVec_t *zs_specNonSymmLoad(parVecMap_t *map, char *spectrum);

zl_parVec_t *zl_specNonSymmLoad(parVecMapL_t *map, char *spectrum);

ds_parVec_t *ds_specNonSymmLoad(parVecMap_t *map, char *spectrum);

dl_parVec_t *dl_specNonSymmLoad(parVecMapL_t *map, char *spectrum);


zs_parMatSparse_t *zs_nonherm(int probSize, nilp_t *nilp, initMatrix_t *init,  char *spectrum, MPI_Comm comm);

zl_parMatSparse_t *zl_nonherm(long probSize, nilpL_t *nilp, initMatrixL_t *init, char *spectrum, MPI_Comm comm);


zs_parMatSparse_t *zs_nonherm_2(int probSize, nilp_t *nilp, initMatrix_t *init, zs_parVec_t *spec);

zl_parMatSparse_t *zl_nonherm_2(long probSize, nilpL_t *nilp, initMatrixL_t *init, zl_parVec_t *spec);


void zs_nonherm_3(int probSize, nilp_t *nilp, zs_parMatSparse_t *Am, zs_parVec_t *spec);

void zl_nonherm_3(long probSize, nilpL_t *nilp, zl_parMatSparse_t *Am, zl_parVec_t *spec);


//

ds_parMatSparse_t *ds_nonsymm(int probSize, nilp_t *nilp, initMatrix_t *init,  char *spectrum, MPI_Comm comm);

dl_parMatSparse_t *dl_nonsymm(long probSize, nilpL_t *nilp, initMatrixL_t *init, char *spectrum, MPI_Comm comm);


//

ds_parMatSparse_t *ds_nonsymm_2(int probSize, nilp_t *nilp, initMatrix_t *init, ds_parVec_t *spec);

dl_parMatSparse_t *dl_nonsymm_2(long probSize, nilpL_t *nilp, initMatrixL_t *init, dl_parVec_t *spec);


void ds_nonsymm_3(int probSize, nilp_t *nilp, ds_parMatSparse_t *Am, ds_parVec_t *spec);

void dl_nonsymm_3(long probSize, nilpL_t *nilp, dl_parMatSparse_t *Am, dl_parVec_t *spec);

//

ds_parMatSparse_t *ds_nonsymmconj(int probSize, nilp_t *nilp, initMatrix_t *init,  char *spectrum, MPI_Comm comm);

dl_parMatSparse_t *dl_nonsymmconj(long probSize, nilpL_t *nilp, initMatrixL_t *init, char *spectrum, MPI_Comm comm);


//

ds_parMatSparse_t *ds_nonsymmconj_2(int probSize, nilp_t *nilp, initMatrix_t *init, zs_parVec_t *spec);

dl_parMatSparse_t *dl_nonsymmconj_2(long probSize, nilpL_t *nilp, initMatrixL_t *init, zl_parVec_t *spec);

void ds_nonsymmconj_3(int probSize, nilp_t *nilp, ds_parMatSparse_t *Am, zs_parVec_t *spec);

void dl_nonsymmconj_3(long probSize, nilpL_t *nilp, dl_parMatSparse_t *Am, zl_parVec_t *spec);

 // end of group5


#ifdef __cplusplus

}

#endif


#endif