/*
XLiFE++ is an extended library of finite elements written in C++
    Copyright (C) 2014  Lunéville, Eric; Kielbasiewicz, Nicolas; Lafranche, Yvon; Nguyen, Manh-Ha; Chambeyron, Colin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/*!
  \file config.hpp
  \authors D. Martin, E. Lunéville, M.-H. Nguyen, N. Kielbasiewicz
  \since 10 jun 2011
  \date 17 oct 2014

  \brief config "compile configuration" header file (pre-compiler macros)
 */

#ifndef CONFIG_HPP
#define CONFIG_HPP

// Include most commonly used C++ definition files
#include <cfloat>
#include <climits>
#include <complex>
#include <cstdlib>
#include <cmath>
#include <iomanip>
#include <iosfwd>
#include <string>
#include <set>
#include <vector>
#include <map>
#include <utility>
#include <algorithm>
#include <limits>
#include <iostream>
#include <list>
#include <iterator>

// setup : define OS, precision type, default language, debug parameter, ...
#include "setup.hpp"

//! main namespace of XLiFE++ library
namespace xlifepp
{

//------------------------------------------------------------------------------
// Definition of scalars
//------------------------------------------------------------------------------
#if defined(STD_TYPES)
//! typedef for real
typedef float real_t;
//! typedef for complex
typedef std::complex<float> complex_t;
#elif defined(LONG_TYPES)
//! typedef for real
typedef double real_t;
//! typedef for complex
typedef std::complex<double> complex_t;
#elif defined(LONGLONG_TYPES)
//! typedef for real
typedef long double real_t;
//! typedef for complex
typedef std::complex<long double> complex_t;
#endif

#if defined(COMPILER_IS_32_BITS)
//! typedef for integer
typedef long int int_t;
#else
//! typedef for integer
typedef long long int_t;
typedef unsigned long long uint_t;
#endif
//------------------------------------------------------------------------------
// String choice
//------------------------------------------------------------------------------
#if defined(STD_STRING)
//! typedef for string
typedef std::string string_t;
#elif defined(WIDE_STRING)
//! typedef for string
typedef std::wstring string_t;
#endif

//------------------------------------------------------------------------------
// Shortcuts (type aliases)
//------------------------------------------------------------------------------
//! typedef for short unsigned int
typedef short unsigned int dimen_t;
//! typedef for size_t
typedef size_t number_t;

typedef std::pair<dimen_t, dimen_t> dimPair; //!< useful alias


//------------------------------------------------------------------------------
// Output format parameters and extremal values
//------------------------------------------------------------------------------
extern const number_t entriesPerRow;
// unused: extern const number_t addrPerRow;
// unused: extern const number_t numberPerRow;
extern const number_t entryWidth;
extern const number_t entryPrec;
extern const number_t addrWidth;
extern const number_t numberWidth;
extern const number_t fullPrec; // for numerical data that could be reused
extern const number_t testPrec; // for test programs output

extern const number_t theNumberMax;
extern const size_t theSizeMax;
extern const dimen_t theDimMax;
extern const int_t theIntMax;
extern const real_t theRealMax;
extern const real_t theEpsilon;
extern const real_t theTolerance;
extern const real_t theZeroThreshold;
extern const number_t theLanguage;
extern number_t theGlobalVerboseLevel;
extern number_t theVerboseLevel;
extern bool trackingObjects;
extern real_t theDefaultCharacteristicLength;

extern number_t defaultMaxIterations;
extern real_t theRatioOfIterations2Rows;
extern real_t theBreakdownThreshold;
extern real_t theDefaultConvergenceThreshold;
extern number_t defaultKrylovDimension;

extern std::string eol;

//------------------------------------------------------------------------------
// Some math constants
//------------------------------------------------------------------------------
// 1/3, 1/6, pi, 1/pi, 1/2pi, 1/4pi, sqrt(2), sqrt(3), log(2)
extern const real_t over3_;
extern const real_t over6_;
extern const real_t pi_;
extern const complex_t i_;
extern const real_t overpi_;
extern const real_t over2pi_;
extern const real_t over4pi_;
extern const real_t sqrtOf2_;
extern const real_t sqrtOf3_;
extern const real_t logOf2_;
// Euler-Mascheroni gamma constant = .577215664901532860606512090082402431042...;
// gamma = - \Int_0^\infty exp(-x) log(x) dx
extern const real_t theEulerConst;

//------------------------------------------------------------------------------
// Declaration of default global objects
//------------------------------------------------------------------------------
class Parameters;
extern Parameters defaultParameters;
extern Parameters* defaultParameters_p;

class Messages;
extern Messages* theMessages_p;

class Trace;
extern Trace* trace_p;

class MsgData;
extern MsgData theMessageData;
extern std::string theWhereData;

class Environment;
extern Environment* theEnvironment_p;

class Parameter;

extern Parameter _lang, _verbose, _trackingMode, _isLogged;
extern Parameter _varnames;
extern Parameter _vertices, _faces;
extern Parameter _center, _center1, _center2, _apogee, _origin, _apex, _v1, _v2, _v3, _v4, _v5, _v6, _v7, _v8;
extern Parameter _xmin, _xmax, _ymin, _ymax, _zmin, _zmax;
extern Parameter _length, _xlength, _ylength, _zlength, _radius, _radius1, _radius2;
extern Parameter _basis, _scale, _direction;
extern Parameter _end_shape, _end1_shape, _end2_shape, _end_distance, _end1_distance, _end2_distance;
extern Parameter _nnodes, _hsteps;
extern Parameter _domain_name, _side_names, _nbsubdomains;
extern Parameter _nboctants, _angle1, _angle2, _type;
extern Parameter _maxIt, _krylovDim, _solver, _tolerance, _residue, _nbIterations;
extern Parameter _convToStd, _forceNonSym, _ncv, _nev, _mode, _sigma, _sort, _which;
extern Parameter _omega, _name;

class ArpackProb;
extern ArpackProb _ARprob;

class SymbolicFunction;
extern SymbolicFunction x_1, x_2, x_3, x_4;

class ThreadData;
extern ThreadData theThreadData;

//------------------------------------------------------------------------------
// Unique output file stream
//------------------------------------------------------------------------------
//extern std::ofstream thePrintStream;
class PrintStream;
class CoutStream;
extern PrintStream thePrintStream;
extern CoutStream theCout;
extern std::string thePrintFile;

//------------------------------------------------------------------------------
// enum's used as types or as consts in user's main or functions
// by default items of enum begin by _ except for end user's enum
// enum are listed by library alphabetically
//------------------------------------------------------------------------------

enum KeepStatus{_keep, _nokeep};

// --------- arpackSupport ---------

// --------- eigenSolvers ----------

// ----- essentialConditions -------

//! type of essential condition
enum EcType { _undefEcType,_DirichletEc, _transmissionEc, _crackEc, _periodicEc, _meanEc, _lfEc };

//! reduction method to deal with essential conditions
enum ReductionMethodType
{
  _noReduction = 0,
  _pseudoReduction,
  _realReduction,
  _penalizationReduction,
  _dualReduction
};

// ----------- finalize ------------

// -------- finiteElements ---------

//@{
/*! name nomenclature of edge/face element
                            2D  (triangle)                     3D (tetrahedron)
    FE face type (Hdiv)  Raviart-Thomas(RT)            Nedelec Face first family (NF1)
                         Brezzi-Douglas-Marini(BDM)    Nedelec Face second family(NF2)
    FE edge type (Hrot)  Nedelec first family (N1)     Nedelec Edge first family (NE1)
                         Nedelec second family(N2)     Nedelec Edge second family(NE2)

    \note according to the previous table, there is an equivalence between 2D and 3D shortname :
          for instance NF_1 in 2D is understood as RT_1 and RT_1 in 3D is understood as NF_1
*/
enum FeEdgeType
{
  _N1_1 = 1, N1_1 = _N1_1, _NE1_1 = _N1_1, NE1_1 = _N1_1,
  _N1_2 ,    N1_2 = _N1_2, _NE1_2 = _N1_2, NE1_2 = _N1_2,
  _N1_3 ,    N1_3 = _N1_3, _NE1_3 = _N1_3, NE1_3 = _N1_3,
  _N1_4 ,    N1_4 = _N1_4, _NE1_4 = _N1_4, NE1_4 = _N1_4,
  _N1_5 ,    N1_5 = _N1_5, _NE1_5 = _N1_5, NE1_5 = _N1_5,
  _N2_1 ,    N2_1 = _N2_1, _NE2_1 = _N2_1, NE2_1 = _N2_1,
  _N2_2 ,    N2_2 = _N2_2, _NE2_2 = _N2_2, NE2_2 = _N2_2,
  _N2_3 ,    N2_3 = _N2_3, _NE2_3 = _N2_3, NE2_3 = _N2_3,
  _N2_4 ,    N2_4 = _N2_4, _NE2_4 = _N2_4, NE2_4 = _N2_4,
  _N2_5 ,    N2_5 = _N2_5, _NE2_5 = _N2_5, NE2_5 = _N2_5
};

enum FeFaceType
{
  _RT_1 = 1, RT_1 = _RT_1, _NF1_1 = _RT_1, NF1_1 = _RT_1,
  _RT_2 ,    RT_2 = _RT_2, _NF1_2 = _RT_2, NF1_2 = _RT_2,
  _RT_3 ,    RT_3 = _RT_3, _NF1_3 = _RT_3, NF1_3 = _RT_3,
  _RT_4 ,    RT_4 = _RT_4, _NF1_4 = _RT_4, NF1_4 = _RT_4,
  _RT_5 ,    RT_5 = _RT_5, _NF1_5 = _RT_5, NF1_5 = _RT_5,
  _BDM_1 ,    BDM_1 = _BDM_1, _NF2_1 = _BDM_1, NF2_1 = _BDM_1,
  _BDM_2 ,    BDM_2 = _BDM_2, _NF2_2 = _BDM_2, NF2_2 = _BDM_2,
  _BDM_3 ,    BDM_3 = _BDM_3, _NF2_3 = _BDM_3, NF2_3 = _BDM_3,
  _BDM_4 ,    BDM_4 = _BDM_4, _NF2_4 = _BDM_4, NF2_4 = _BDM_4,
  _BDM_5 ,    BDM_5 = _BDM_5, _NF2_5 = _BDM_5, NF2_5 = _BDM_5
};
//@}

//! finite element subfamily
enum FESubType
{
  _standard = 0, standard = _standard,
  _GaussLobatto, GaussLobatto = _GaussLobatto,
  _firstFamily, firstFamily = _firstFamily,
  _secondFamily, secondFamily = _secondFamily
};

//! finite element family
enum FEType
{
  _Lagrange, Lagrange = _Lagrange,
  _Hermite, Hermite = _Hermite,
  _CrouzeixRaviart, CrouzeixRaviart = _CrouzeixRaviart,
  _Nedelec, Nedelec = _Nedelec,
  _RaviartThomas, RaviartThomas = _RaviartThomas,
  _Nedelec_Face, NedelecFace = _Nedelec_Face,
  _Nedelec_Edge, NedelecEdge = _Nedelec_Edge,
  _BuffaChristiansen, BuffaChristiansen=_BuffaChristiansen
};

//! integration methods
enum IntegrationMethodType
{
  _undefIM, _quadratureIM, _polynomialIM, _productIM,
  _LenoirSalles2dIM, Lenoir_Salles_2d =_LenoirSalles2dIM, _LenoirSalles3dIM, Lenoir_Salles_3d= _LenoirSalles3dIM, _LenoirSalles2dIR, _LenoirSalles3dIR,
  _SauterSchwabIM, Sauter_Schwab=_SauterSchwabIM, _DuffyIM, Duffy = _DuffyIM, _HMatrixIM, H_Matrix= _HMatrixIM
};

//! interpolation degree
enum PolynomType
{
  _P0 = 0, P0 = _P0,
  _P1, P1 = _P1,
  _P2, P2 = _P2,
  _P3, P3 = _P3,
  _P4, P4 = _P4,
  _P5, P5 = _P5,
  _P6, P6 = _P6,
  _P7, P7 = _P7,
  _P8, P8 = _P8,
  _P9, P9 = _P9,
  _P10, P10 = _P10,
  _P1BubbleP3 = 1001, P1BubbleP3 = _P1BubbleP3  //WARNING : do not go up to degree 1000 for PK
};

//! interpolation degree
enum QolynomType
{
  _Q0 = 0, Q0 = _Q0,
  _Q1, Q1 = _Q1,
  _Q2, Q2 = _Q2,
  _Q3, Q3 = _Q3,
  _Q4, Q4 = _Q4,
  _Q5, Q5 = _Q5,
  _Q6, Q6 = _Q6,
  _Q7, Q7 = _Q7,
  _Q8, Q8 = _Q8,
  _Q9, Q9 = _Q9,
  _Q10, Q10 = _Q10
};

//! quadrature rules
enum QuadRule
{
  _defaultRule = 0, defaultQuadrature = _defaultRule,
  _GaussLegendreRule, Gauss_Legendre = _GaussLegendreRule,
  _symmetricalGaussRule, symmetrical_Gauss = _symmetricalGaussRule,
  _GaussLobattoRule, Gauss_Lobatto = _GaussLobattoRule,
  _nodalRule, nodalQuadrature = _nodalRule,
  _miscRule, miscQuadrature = _miscRule,
  _GrundmannMollerRule, Grundmann_Moller = _GrundmannMollerRule,
  _doubleQuadrature
};

//! Sobolev space
enum SobolevType
{
  _L2 = 0, L2 = _L2,
  _H1, H1 = _H1,
  _Hdiv, Hdiv = _Hdiv,
  _Hcurl, Hcurl = _Hcurl, _Hrot = _Hcurl, Hrot = _Hrot,
  _H2, H2 = _H2,
  _Hinf, Hinf = _Hinf, Linf=_Hinf
};

// ------------- form --------------

//! type of linear form
enum LinearFormType
{
  _undefLf = 0,
  _intg,
  _doubleIntg,
  _bilinearAsLinear,
  _linearCombination,
  _composedLf,
  _explicitLf
};

//! type of computation
enum ComputationType
{
  _undefComputation=0,
  _FEComputation,
  _IEComputation,
  _SPComputation,
  _FESPComputation,
  _IESPComputation,
  _FEextComputation,
  _IEextComputation,
  _IEHmatrixComputation
};

// ----------- geometry ------------

//! geometrical transformations
enum TransformType
{ _noTransform, _translation, _rotation2d, _rotation3d, _homothety, _ptReflection, _reflection2d, _reflection3d, _composition };

//! type of crack
enum CrackType
{
  _noCrack,
  _openCrack,
  _closedCrack
};

//! used for RevTrunk class in lib geometry
enum GeometricEndShape
{
  _gesNone, gesNone=_gesNone,
  _gesFlat, gesFlat=_gesFlat,
  _gesCone, gesCone=_gesCone,
  _gesEllipsoid, gesEllipsoid=_gesEllipsoid,
  _gesSphere, gesSphere=_gesSphere
};

//! enum to describe the relative position of 2 geometries
enum GeometryRelationType
{
  _inside=0,
  _contains,
  _intersects,
  _outside
};

//! I/O mesh format
enum IOFormat
{
  _undefFormat=0,
  _vtk, vtk=_vtk,
  _vtu, vtu=_vtu,
  _msh, msh=_msh,
  _geo, geo=_geo,
  _mel, mel=_mel,
  _ply, ply=_ply,
  _medit, medit=_medit,
  _matlab, matlab=_matlab,
  _raw, raw=_raw,
  _xyzv, xyzv=_xyzv
};

//! enum to select the mesh generator/algorithm
enum MeshGenerator
{
  _defaultGenerator=0,
  _structured, structured=_structured,
  _subdiv, subdiv=_subdiv,
  _gmsh, gmsh=_gmsh
};

//! enum to select the mesh generator/algorithm
enum MeshOption
{
  _defaultMeshOption=0,
  _unstructuredMesh, unstructuredMesh=_unstructuredMesh,
  _structuredMesh, structuredMesh=_structuredMesh
};

//! orientation type for a spacedim-1 domain
enum OrientationType
{
  _undefOrientationType,
  _towardsInfinite,towardsInfinite=_towardsInfinite,
  _outwardsInfinite, outwardsInfinite=_outwardsInfinite,
  _towardsDomain, towardsDomain=_towardsDomain,
  _outwardsDomain, outwardsDomain=_outwardsDomain
};

//! geometrical shapes
enum ShapeType
{
  _noShape=0,
  _fromFile,
  _point,
  _segment, segment=_segment,
  _triangle, triangle=_triangle,
  _quadrangle, quadrangle=_quadrangle,
  _tetrahedron, tetrahedron=_tetrahedron,
  _hexahedron, hexahedron=_hexahedron,
  _prism, prism=_prism,
  _pyramid, pyramid=_pyramid,
  _ellArc, _circArc,
  _polygon, _parallelogram, _rectangle, _square, _ellipse, _disk, _ellipsoidPart, _spherePart,
  _setofpoints, _setofelems, _trunkPart, _cylinderPart, _conePart,
  _polyhedron, _parallelepiped, _cuboid, _cube, _ellipsoid, _ball, _trunk,
  _revTrunk, _cylinder, _revCylinder, _cone, _revCone,
  _composite, _loop, _extrusion
};

//! geometrical shapes
enum ShapesType
{
  _noShapes=0,
  _fromFiles,
  _points,
  _segments, segments=_segments,
  _triangles, triangles=_triangles,
  _quadrangles, quadrangles=_quadrangles,
  _tetrahedra, tetrahedra=_tetrahedra,
  _hexahedra, hexahedra,
  _prisms, prisms=_prisms,
  _pyramids, pyramids=_pyramids,
  _ellArcs, _circArcs,
  _polygons, _parallelograms, _rectangles, _squares, _ellipses, _disks, _ellipsoidParts, _sphereParts,
  _setsofpoints, _setsofelems, _trunkParts, _cylinderParts, _coneParts,
  _polyhedra, _parallelepipeds, _cuboids, _cubes, _ellipsoids, _balls, _trunks,
  _revTrunks, _cylinders, _revCylinders, _cones, _revCones,
  _composites, _loops, _extrusions
};

// ------------- init --------------

enum DataAccess { _copy = 0 , _view };

/*!
  Enumerated list of matrix properties regarding invertibility
*/
enum MatrixConditioning
{
  _well_conditioned_matrix =0,
  _bad_conditioned_matrix ,
  _non_invertible_matrix
};

// ---------- largeMatrix ----------

//! access type of storage
enum AccessType
{
  _noAccess = 0,
  _sym,
  _row,
  _col,
  _dual
};

//! factorization of matrices
enum FactorizationType {_noFactorization, _lu, _ldlt, _ldlstar, _llt, _llstar, _qr,
                                         _ilu, _ildlt, _illt, _ildlstar, _illstar, _umfpack};

//! part of matrices
enum MatrixPart
{
  _all = 0,
  _lower,
  _upper
};

//! storage of matrices
enum StorageType
{
  _noStorage = 0,
  _dense,
  _cs,
  _skyline,
  _coo,
  _hmatrix
};

//! structure of matrices and vectors
enum StrucType  {_scalar, _vector, _matrix, _vectorofvector, _vectorofmatrix, _matrixofmatrix, _undefStrucType};

//! symmetry of matrices
enum SymType    {_noSymmetry = 0, _symmetric, _skewSymmetric, _selfAdjoint, _skewAdjoint, _diagonal, _undefSymmetry};

// -------- mathsResources ---------

// ----------- operator ------------

//! type fo differential operator
enum DiffOpType
{
  _id, _d0, _dt = _d0, _d1, _dx = _d1, _d2, _dy = _d2, _d3, _dz = _d3,
  _grad, _nabla = _grad, _div, _curl, _rot = _curl,
  _gradS, _nablaS = _gradS, _divS, _curlS, _rotS = _curlS,
  _ntimes, _timesn, _ndot, _ncross, _ncrossncross, _ndotgrad, _ndiv,
  _ncrosscurl, _ncrossgrad, _ncrossntimes, _timesncrossn, _ntimesndot,
  _divG, _gradG, _nablaG = _gradG, _curlG, _rotG = _curlG, _epsilon, _epsilonG, _epsilonR, _voigtToM,
  _jump, _mean,
  _grad_x, _nabla_x = _grad_x,
  _grad_y, _nabla_y = _grad_y,
  _grad_xy, _nabla_xy =_grad_xy,
  _div_x, _div_y, _div_xy,
  _curl_x, _rot_x = _curl_x,
  _curl_y, _rot_y = _curl_y,
  _curl_xy, _rot_xy = _curl_xy,
  _ntimes_x, _timesn_x, _ndot_x, _ncross_x, _ncrossncross_x, _ncrossntimes_x, _timesncrossn_x, _ndotgrad_x, _ndiv_x, _ncrosscurl_x,
  _ntimes_y, _timesn_y, _ndot_y, _ncross_y, _ncrossncross_y, _ncrossntimes_y, _timesncrossn_y, _ndotgrad_y, _ndiv_y, _ncrosscurl_y,
  _ndotgrad_xy,
  _nxdotny_times, _nxcrossny_dot, _nycrossnx_dot, _nxcrossny_cross, _nycrossnx_cross, _nxcrossny_times, _nycrossnx_times
};

//! type of unitary vector
enum UnitaryVector { _n, _nx, _ny, _nxdotny, _nxcrossny, _nycrossnx, _ncrossn };

//! variable symbolic name
enum VariableName {_varUndef=0,_x,_x1=_x,_y,_x2=_y, _z, _x3=_z, _t, _x4=_t,_xy, _yx, _xx, _yy};

//! symbolic operations
enum SymbolicOperation {_idop=0, _plus, _minus, _multiply, _divide, _power,                                 //binary op
                       _equal, _different, _less, _lessequal, _greater, _greaterequal, _and, _or,           //binary op
                       _abs, _realPart, _imagPart, _sqrt, _squared, _sin, _cos, _tan, _asin, _acos, _atan,  //unary op
                       _sinh, _cosh, _tanh, _asinh, _acosh, _atanh, _exp, _log, _log10, _pow, _not,
                       _conj, _adj, _tran, _inv};

// ----------- solvers -------------

//! preconditioner
enum PreconditionerType {_noPrec, _luPrec, _ldltPrec, _ldlstarPrec, _ssorPrec, _diagPrec, _productPrec, _iluPrec, _illtPrec, _ildltPrec, _ildlstarPrec, _userPrec};

// ------------ space --------------

//! DoF type
enum DofType     {_feDof, _spDof, _otherDof};

//! space type
enum SpaceType   {_feSpace, _spSpace, _subSpace, _prodSpace};

//! DoF support type
enum SupportType {_undefSupport = 0, _pointSupport, _faceSupport, _edgeSupport, _elementSupport};

//! type of unknown
enum UnknownType {_feUnknown, _spUnknown, _mixedUnknown};

// ------------ term ---------------

//! Enum for reporting the status of a computation
enum ComputationInfo
{
  //! Computation was successful.
  _success = 0,
  //! The provided data did not satisfy the prerequisites.
  _numericalIssue = 1,
  //! Iterative procedure did not converge.
  _noConvergence = 2,
  /*! The inputs are invalid, or the algorithm has been improperly called.
    * When assertions are enabled, such errors trigger an assert. */
  _invalidInput = 3
};

//! computational mode for eigen solvers
enum EigenComputationalMode { _davidson, _krylovSchur,                    // for intern solver
                              _buckling, _cayley, _cshiftRe, _cshiftIm }; // for Arpack

//! Eigen solvers
enum EigenSolverType { _intern, _arpack};

//! Possible choices to sort the eigenvalues
enum EigenSortKind { _decr_module, _decr_realpart, _decr_imagpart, _incr_module, _incr_realpart, _incr_imagpart};

//! Iterative solvers
enum IterativeSolverType {_cg, _cgs, _qmr, _bicg, _bicgstab, _gmres, _sor, _ssor};

//! SOR solver type
enum SorSolverType { _diagSorS, _upperSorS, _lowerSorS, _matrixVectorSorS };

//! main options of Term construction (TermMatrix or TermVector)
enum TermOption
{
    //general
    _compute,                 //default
    _notCompute,
    _assembled,               //default
    _unassembled,             //not yet available
    //only for TermMatrix
    _nonSymmetricMatrix,      //to force symmetry property (not yet managed)
    _symmetricMatrix,
    _selfAdjointMatrix,
    _skewSymmetricMatrix,
    _skewAdjointMatrix,
    _csRowStorage,            //to force storage
    _csColStorage,
    _csDualStorage,
    _csSymStorage,
    _denseRowStorage,
    _denseColStorage,
    _denseDualStorage,
    _skylineSymStorage,
    _skylineDualStorage,
    _pseudoReductionMethod,
    _realReductionMethod,
    _penalizationReductionMethod
};

//! Enumerated list of available HMatrix approximation method
enum HMApproximationMethod {_noHMApproximation, _svdCompression, _rsvdCompression, _r3svdCompression, _acaFull, _acaPartial, _acaPlus};

// -------- umfpackSupport ---------

// ------------ utils --------------

//! space or mesh dimension
enum dimensionType {_undefDim=0, _1D, _2D, _3D, _nD};

//! type of function (C++ function or TermVector)
enum FuncFormType {_analytical, _interpolated};

//! type of functions (one Point variable, or two)
enum FunctType  {_function, _kernel};

//! multilingual messages
enum Language
{
  _en, en = _en, english = _en,
  _fr, fr = _fr, francais = _fr,
  _de, de = _de, deutsch = _de,
  _es, es = _es, espanol = _es
};

//! used for GeomParameter class in lib geometry
enum ParameterKey
{
  _pk_none,
  _pk_lang, _pk_verbose, _pk_trackingMode, _pk_isLogged,
  _pk_varnames,
  _pk_vertices, _pk_faces,
  _pk_center, _pk_center1, _pk_center2, _pk_apogee, _pk_origin, _pk_apex,
  _pk_v1, _pk_v2, _pk_v3, _pk_v4, _pk_v5, _pk_v6, _pk_v7, _pk_v8,
  _pk_xmin, _pk_xmax, _pk_ymin, _pk_ymax, _pk_zmin, _pk_zmax,
  _pk_length, _pk_xlength, _pk_ylength, _pk_zlength, _pk_radius, _pk_radius1, _pk_radius2,
  _pk_basis, _pk_scale, _pk_dir,
  _pk_end_shape, _pk_end1_shape, _pk_end2_shape, _pk_end_distance, _pk_end1_distance, _pk_end2_distance,
  _pk_nnodes, _pk_hsteps,
  _pk_domain_name, _pk_side_names, _pk_nbsubdomains,
  _pk_nboctants, _pk_angle1, _pk_angle2, _pk_type,
  _pk_maxIt, _pk_krylovDim, _pk_solver, _pk_tolerance,
  _pk_convToStd, _pk_forceNonSym, _pk_ncv, _pk_nev, _pk_mode, _pk_sigma, _pk_sort, _pk_which,
  _pk_omega, _pk_name
};

//! types of values of matrices and vectors
enum ValueType
{
  _none, _integer, _bool, _real, _complex, _string, _pt, _pointer,
  _integerVector, _realVector, _complexVector, _stringVector, _ptVector,
  _integerMatrix, _realMatrix, _complexMatrix, _stringMatrix, _ptMatrix
};

//------------------------------------------------------------------------------
// macro definition for decorated Fortran routines name called in C/C++
//------------------------------------------------------------------------------
#ifdef NO_TRAILING_UNDERSCORE
// IBM xlf compiler version under AIX / Mac OS X(Darwin)
#define FTNAME(x) x
#else
// Almost all other compilers append an underscore to Fortran routine name
#define FTNAME(x) x ## _
#endif /* NO_TRAILING_UNDERSCORE */

} //end of namespace xlifepp

#endif /* CONFIG_HPP */