Skip to content
Snippets Groups Projects
Select Git revision
  • 17ef41c3f7421a3b4d29489006d9ce01270f84a3
  • master default protected
  • hierarchical-basis
  • alphashapes
  • bl
  • relaying
  • new_export_boris
  • oras_vs_osm
  • reassign_partitions
  • distributed_fwi
  • rename-classes
  • fix/fortran-api-example-t4
  • robust_partitions
  • reducing_files
  • fix_overlaps
  • 3115-issue-fix
  • 3023-Fillet2D-Update
  • convert_fdivs
  • tmp_jcjc24
  • fixedMeshIF
  • save_edges
  • gmsh_4_14_0
  • gmsh_4_13_1
  • gmsh_4_13_0
  • gmsh_4_12_2
  • gmsh_4_12_1
  • gmsh_4_12_0
  • gmsh_4_11_1
  • gmsh_4_11_0
  • gmsh_4_10_5
  • gmsh_4_10_4
  • gmsh_4_10_3
  • gmsh_4_10_2
  • gmsh_4_10_1
  • gmsh_4_10_0
  • gmsh_4_9_5
  • gmsh_4_9_4
  • gmsh_4_9_3
  • gmsh_4_9_2
  • gmsh_4_9_1
  • gmsh_4_9_0
41 results

t10.py

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