Skip to content
Snippets Groups Projects
Select Git revision
  • fcecb101c342200368734ba25499b15bffcf4b34
  • master default protected
  • dof-renumbering
  • gdemesy-master-patch-30528
  • eval-space-time
  • oscillating_multiharm
  • MH_movement
  • axisqu
  • write_vtu_and_ensight_formats
  • movingband
  • CP_1972_add_vtu_file_writing
  • mortar
  • fast_freq_sweep_Resolution
  • applyresolvent_again
  • marteaua-master-patch-54323
  • patch-1
  • binde-master-patch-08072
  • binde-master-patch-52461
  • BCGSL
  • resolvent
  • TreeElementsOf
  • getdp_3_5_0
  • getdp_3_4_0
  • getdp_3_3_0
  • getdp_3_2_0
  • getdp_3_1_0
  • getdp_3_0_4
  • getdp_3_0_3
  • getdp_3_0_2
  • getdp_3_0_1
  • getdp_3_0_0
  • onelab_mobile_2.1.0
  • getdp_2_11_3 protected
  • getdp_2_11_2 protected
  • getdp_2_11_1 protected
  • getdp_2_11_0 protected
  • getdp_2_10_0 protected
  • getdp_2_9_2 protected
  • getdp_2_9_1 protected
  • getdp_2_9_0 protected
  • getdp_2_8_0 protected
41 results

LinAlg.cpp

Blame
  • LinAlg.cpp 6.46 KiB
    // GetDP - Copyright (C) 1997-2018 P. Dular and C. Geuzaine, University of Liege
    //
    // See the LICENSE.txt file for license information. Please report all
    // bugs and problems to the public mailing list <getdp@onelab.info>.
    
    #include "GetDPConfig.h"
    #include "LinAlg.h"
    #include "Message.h"
    
    // default dummy solver interface
    
    #if !defined(HAVE_PETSC) && !defined(HAVE_SPARSKIT)
    
    #define err Message::Error("No solver is compiled in this version of GetDP")
    
    void LinAlg_InitializeSolver(int* argc, char*** argv){}
    void LinAlg_FinalizeSolver(){}
    void LinAlg_SetCommSelf(){}
    void LinAlg_SetCommWorld(){}
    void LinAlg_CreateSolver(gSolver *Solver, const char * SolverDataFileName){ err; }
    void LinAlg_SetGlobalSolverOptions(const std::string &opt){ err; }
    void LinAlg_CreateVector(gVector *V, gSolver *Solver, int n){ err; }
    void LinAlg_CreateMatrix(gMatrix *M, gSolver *Solver, int n, int m){ err; }
    void LinAlg_DestroySolver(gSolver *Solver){ err; }
    void LinAlg_DestroyVector(gVector *V){ err; }
    void LinAlg_DestroyMatrix(gMatrix *M){ err; }
    void LinAlg_CopyScalar(gScalar *S1, gScalar *S2){ err; }
    void LinAlg_CopyVector(gVector *V1, gVector *V2){ err; }
    void LinAlg_SwapVector(gVector *V1, gVector *V2){ err; }
    void LinAlg_CopyMatrix(gMatrix *M1, gMatrix *M2){ err; }
    void LinAlg_ZeroScalar(gScalar *S){ err; }
    void LinAlg_ZeroVector(gVector *V){ err; }
    void LinAlg_ZeroMatrix(gMatrix *M){ err; }
    void LinAlg_ScanScalar(FILE *file, gScalar *S){ err; }
    void LinAlg_ScanVector(FILE *file, gVector *V){ err; }
    void LinAlg_ScanMatrix(FILE *file, gMatrix *M){ err; }
    void LinAlg_ReadScalar(FILE *file, gScalar *S){ err; }
    void LinAlg_ReadVector(FILE *file, gVector *V){ err; }
    void LinAlg_ReadMatrix(FILE *file, gMatrix *M){ err; }
    void LinAlg_PrintScalar(FILE *file, gScalar *S){ err; }
    void LinAlg_PrintVector(FILE *file, gVector *V, bool matlab,
                            const char* fileName, const char* varName){ err; }
    void LinAlg_PrintMatrix(FILE *file, gMatrix *M, bool matlab,
                            const char* fileName, const char*varName){ err; }
    void LinAlg_WriteScalar(FILE *file, gScalar *S){ err; }
    void LinAlg_WriteVector(FILE *file, gVector *V){ err; }
    void LinAlg_WriteMatrix(FILE *file, gMatrix *M){ err; }
    void LinAlg_GetVectorSize(gVector *V, int *i){ err; }
    void LinAlg_GetLocalVectorRange(gVector *V, int *low, int *high){ err; }
    void LinAlg_GetMatrixSize(gMatrix *M, int *i, int *j){ err; }
    void LinAlg_GetLocalMatrixRange(gMatrix *M, int *low, int *high){ err; }
    void LinAlg_GetDoubleInScalar(double *d, gScalar *S){ err; }
    void LinAlg_GetComplexInScalar(double *d1, double *d2, gScalar *S){ err; }
    void LinAlg_GetScalarInVector(gScalar *S, gVector *V, int i){ err; }
    void LinAlg_GetDoubleInVector(double *d, gVector *V, int i){ err; }
    void LinAlg_GetAbsDoubleInVector(double *d, gVector *V, int i){ err; }
    void LinAlg_GetComplexInVector(double *d1, double *d2, gVector *V, int i, int j){ err; }
    void LinAlg_GetScalarInMatrix(gScalar *S, gMatrix *M, int i, int j){ err; }
    void LinAlg_GetDoubleInMatrix(double *d, gMatrix *M, int i, int j){ err; }
    void LinAlg_GetComplexInMatrix(double *d1, double *d2, gMatrix *M, int i, int j, int k, int l){ err; }
    void LinAlg_GetColumnInMatrix(gMatrix *M, int col, gVector *V1){ err; }
    void LinAlg_GetMatrixContext(gMatrix *A, void **myCtx){ err; }
    void LinAlg_SetScalar(gScalar *S, double *d){ err; }
    void LinAlg_SetVector(gVector *V, double *v){ err; }
    void LinAlg_SetScalarInVector(gScalar *S, gVector *V, int i){ err; }
    void LinAlg_SetDoubleInVector(double d, gVector *V, int i){ err; }
    void LinAlg_SetComplexInVector(double d1, double d2, gVector *V, int i, int j){ err; }
    void LinAlg_SetScalarInMatrix(gScalar *S, gMatrix *M, int i, int j){ err; }
    void LinAlg_SetDoubleInMatrix(double d, gMatrix *M, int i, int j){ err; }
    void LinAlg_SetComplexInMatrix(double d1, double d2, gMatrix *M, int i, int j, int k, int l){ err; }
    void LinAlg_AddScalarScalar(gScalar *S1, gScalar *S2, gScalar *S3){ err; }
    void LinAlg_DummyVector(gVector *V){ err; }
    void LinAlg_AddScalarInVector(gScalar *S, gVector *V, int i){ err; }
    void LinAlg_AddDoubleInVector(double d, gVector *V, int i){ err; }
    void LinAlg_AddComplexInVector(double d1, double d2, gVector *V, int i, int j){ err; }
    void LinAlg_AddScalarInMatrix(gScalar *S, gMatrix *M, int i, int j){ err; }
    void LinAlg_AddDoubleInMatrix(double d, gMatrix *M, int i, int j){ err; }
    void LinAlg_AddComplexInMatrix(double d1, double d2, gMatrix *M, int i, int j, int k, int l){ err; }
    void LinAlg_AddVectorVector(gVector *V1, gVector *V2, gVector *V3){ err; }
    void LinAlg_AddVectorProdVectorDouble(gVector *V1, gVector *V2, double d, gVector *V3){ err; }
    void LinAlg_AddMatrixMatrix(gMatrix *M1, gMatrix *M2, gMatrix *M3){ err; }
    void LinAlg_AddMatrixProdMatrixDouble(gMatrix *M1, gMatrix *M2, double d, gMatrix *M3){ err; }
    void LinAlg_SubScalarScalar(gScalar *S1, gScalar *S2, gScalar *S3){ err; }
    void LinAlg_SubVectorVector(gVector *V1, gVector *V2, gVector *V3){ err; }
    void LinAlg_SubMatrixMatrix(gMatrix *M1, gMatrix *M2, gMatrix *M3){ err; }
    void LinAlg_ProdScalarScalar(gScalar *S1, gScalar *S2, gScalar *S3){ err; }
    void LinAlg_ProdScalarDouble(gScalar *S1, double d, gScalar *S2){ err; }
    void LinAlg_ProdScalarComplex(gScalar *S, double d1, double d2, double *d3, double *d4){ err; }
    void LinAlg_ProdVectorScalar(gVector *V1, gScalar *S, gVector *V2){ err; }
    void LinAlg_ProdVectorDouble(gVector *V1, double d, gVector *V2){ err; }
    void LinAlg_ProdVectorComplex(gVector *V1, double d1, double d2, gVector *V2){ err; }
    void LinAlg_ProdVectorVector(gVector *V1, gVector *V2, double *d){ err; }
    void LinAlg_ProdMatrixVector(gMatrix *M, gVector *V1, gVector *V2){ err; }
    void LinAlg_ProdMatrixScalar(gMatrix *M1, gScalar *S, gMatrix *M2){ err; }
    void LinAlg_ProdMatrixDouble(gMatrix *M1, double d, gMatrix *M2){ err; }
    void LinAlg_ProdMatrixComplex(gMatrix *M1, double d1, double d2, gMatrix *M2){ err; }
    void LinAlg_DivScalarScalar(gScalar *S1, gScalar *S2, gScalar *S3){ err; }
    void LinAlg_DivScalarDouble(gScalar *S1, double d, gScalar *S2){ err; }
    void LinAlg_VectorNorm2(gVector *V1, double *norm){ err; }
    void LinAlg_VectorNormInf(gVector *V1, double *norm){ err; }
    void LinAlg_AssembleMatrix(gMatrix *M){ err; }
    void LinAlg_AssembleVector(gVector *V){ err; }
    void LinAlg_Solve(gMatrix *A, gVector *B, gSolver *Solver, gVector *X, int solverIndex){ err; }
    void LinAlg_SolveAgain(gMatrix *A, gVector *B, gSolver *Solver, gVector *X, int solverIndex){ err; }
    void LinAlg_SolveNL(gMatrix *A, gVector *B, gMatrix *J, gVector *R, gSolver *Solver,
                        gVector *X, int solverIndex){ err; }
    
    #endif