netgen-mesher 6.2.2506.post35.dev0__cp314-cp314-win_amd64.whl

netgen/include/core/simd_math.hpp

@@ -0,0 +1,178 @@
+#ifndef NETGEN_CORE_SIMD_MATH_HPP
+#define NETGEN_CORE_SIMD_MATH_HPP
+
+#include <tuple>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+
+namespace ngcore
+{
+
+  /*
+    based on:
+    Stephen L. Moshier: Methods and Programs For Mathematical Functions
+    https://www.moshier.net/methprog.pdf
+    
+    CEPHES MATHEMATICAL FUNCTION LIBRARY
+    https://www.netlib.org/cephes/
+  */
+
+  static constexpr double sincof[] = {
+    1.58962301576546568060E-10,
+    -2.50507477628578072866E-8,
+    2.75573136213857245213E-6,
+    -1.98412698295895385996E-4,
+    8.33333333332211858878E-3,
+    -1.66666666666666307295E-1,
+  };
+
+  static constexpr double coscof[6] = {
+    -1.13585365213876817300E-11,
+    2.08757008419747316778E-9,
+    -2.75573141792967388112E-7,
+    2.48015872888517045348E-5,
+    -1.38888888888730564116E-3,
+    4.16666666666665929218E-2,
+  };
+
+
+  // highly accurate on [-pi/4, pi/4]
+  template <int N>
+  auto sincos_reduced (SIMD<double,N> x)
+  {
+    auto x2 = x*x;
+  
+    auto s = ((((( sincof[0]*x2 + sincof[1]) * x2 + sincof[2]) * x2 + sincof[3]) * x2 + sincof[4]) * x2 + sincof[5]);
+    s = x + x*x*x * s;
+
+    auto c = ((((( coscof[0]*x2 + coscof[1]) * x2 + coscof[2]) * x2 + coscof[3]) * x2 + coscof[4]) * x2 + coscof[5]);
+    c = 1.0 - 0.5*x2 + x2*x2*c;
+
+    return std::tuple{ s, c };
+  }
+
+  template <int N>
+  auto sincos (SIMD<double,N> x)
+  {
+    auto y = round((2/M_PI) * x);
+    auto q = lround(y);
+  
+    auto [s1,c1] = sincos_reduced(x - y * (M_PI/2));
+
+    auto s2 = If((q & SIMD<int64_t,N>(1)) == SIMD<int64_t,N>(0), s1,  c1);
+    auto s  = If((q & SIMD<int64_t,N>(2)) == SIMD<int64_t,N>(0), s2, -s2);
+  
+    auto c2 = If((q & SIMD<int64_t,N>(1)) == SIMD<int64_t,N>(0), c1, -s1);
+    auto c  = If((q & SIMD<int64_t,N>(2)) == SIMD<int64_t,N>(0), c2, -c2);
+  
+    return std::tuple{ s, c };
+  }
+
+
+
+
+
+
+  
+  template <int N>
+  SIMD<double,N> exp_reduced (SIMD<double,N> x)
+  {
+    static constexpr double P[] = {
+      1.26177193074810590878E-4,
+      3.02994407707441961300E-2,
+      9.99999999999999999910E-1,
+    };
+  
+    static constexpr double Q[] = {
+      3.00198505138664455042E-6,
+      2.52448340349684104192E-3,
+      2.27265548208155028766E-1,
+      2.00000000000000000009E0,
+    };
+  
+    /*
+    // from:  https://www.netlib.org/cephes/
+    rational approximation for exponential
+    * of the fractional part:
+    * e**x = 1 + 2x P(x**2)/( Q(x**2) - x P(x**2) )
+
+    xx = x * x;
+    px = x * polevl( xx, P, 2 );
+    x =  px/( polevl( xx, Q, 3 ) - px );
+    x = 1.0 + 2.0 * x;
+    */
+
+    auto xx = x*x;
+    auto px = (P[0]*xx + P[1]) * xx + P[2];
+    auto qx = ((Q[0]*xx+Q[1])*xx+Q[2])*xx+Q[3];
+    return 1.0 + 2.0*x * px / (qx- x * px);
+  }  
+
+
+  template <int N>
+  SIMD<double,N> pow2_int64_to_float64(SIMD<int64_t,N> n)
+  {
+    // thx to deepseek
+    
+    // Step 1: Clamp the input to valid exponent range [-1022, 1023]
+    // (We use saturated operations to handle out-of-range values)
+    SIMD<int64_t,N> max_exp(1023);
+    SIMD<int64_t,N> min_exp(-1022);
+    n = If(n > max_exp, max_exp, n);
+    n = If(min_exp > n, min_exp, n);
+
+    // Step 2: Add exponent bias (1023)
+    n = n + SIMD<int64_t,N>(1023);
+
+    // Step 3: Shift to exponent bit position (bit 52)
+    auto shifted_exp = (n << IC<52>());
+  
+    // Step 4: Reinterpret as double
+    return Reinterpret<double> (shifted_exp);
+  }
+
+
+  template <int N>
+  SIMD<double,N> myexp (SIMD<double,N> x)
+  {
+    constexpr double log2 = 0.693147180559945286;  //  log(2.0);
+                     
+    auto r = round(1/log2 * x);
+    auto rI = lround(r);
+    r *= log2;
+  
+    SIMD<double,N> pow2 = pow2_int64_to_float64 (rI);
+    return exp_reduced(x-r) * pow2;
+
+    // maybe better:
+    // x = ldexp( x, n );
+  }
+
+  /*
+  inline auto Test1 (SIMD<double> x)
+  {
+    return myexp(x);
+  }
+
+  inline auto Test2 (SIMD<double> x)
+  {
+    return sincos(x);
+  }
+
+  inline auto Test3 (SIMD<double,4> x)
+  {
+    return myexp(x);
+  }
+
+  inline auto Test4 (SIMD<double,4> x)
+  {
+    return sincos(x);
+  }
+  */
+  
+}
+
+#endif

netgen/include/core/simd_sse.hpp

@@ -0,0 +1,289 @@
+#ifndef NETGEN_CORE_SIMD_SSE_HPP
+#define NETGEN_CORE_SIMD_SSE_HPP
+
+/**************************************************************************/
+/* File:   simd_sse.hpp                                                   */
+/* Author: Joachim Schoeberl, Matthias Hochsteger                         */
+/* Date:   25. Mar. 16                                                    */
+/**************************************************************************/
+
+#include <immintrin.h>
+
+namespace ngcore
+{
+
+  template <>
+  class SIMD<mask64,2>
+  {
+    __m128i mask;
+  public:
+    SIMD (int i)
+      : mask(_mm_cmpgt_epi32(_mm_set1_epi32(i),
+                             _mm_set_epi32(1, 1, 0, 0)))
+    { ; }
+
+    SIMD (bool i0, bool i1) { mask = _mm_set_epi64x(i1?-1:0, i0?-1:0); }
+    
+    SIMD (__m128i _mask) : mask(_mask) { ; }
+    __m128i Data() const { return mask; }
+    static constexpr int Size() { return 2; }
+    static NETGEN_INLINE SIMD<mask64, 2> GetMaskFromBits (unsigned int i);
+  };
+
+  static SIMD<mask64, 2> masks_from_2bits[4] = {
+    _mm_set_epi32 (0,0,0,0), _mm_set_epi32 (0,0,-1,0),
+    _mm_set_epi32 (-1,0,0,0), _mm_set_epi32 (-1,0,-1,0),
+  };
+
+  NETGEN_INLINE SIMD<mask64, 2> SIMD<mask64, 2> :: GetMaskFromBits (unsigned int i)
+  {
+    return masks_from_2bits[i & 3];
+  }
+
+
+  template<>
+  class alignas(16) SIMD<int64_t,2>
+  {
+    __m128i data;
+
+  public:
+    static constexpr int Size() { return 2; }
+    SIMD () {}
+    SIMD (const SIMD &) = default;
+    SIMD (int64_t v0, int64_t v1) { data = _mm_set_epi64x(v1,v0); }
+    SIMD (std::array<int64_t, 2> arr)
+        : data{_mm_set_epi64x(arr[1],arr[0])}
+    {}
+
+    SIMD & operator= (const SIMD &) = default;
+
+    SIMD (int64_t val) { data = _mm_set1_epi64x(val); }
+    SIMD (__m128i _data) { data = _data; }
+
+    template<typename T, typename std::enable_if<std::is_convertible<T, std::function<int64_t(int)>>::value, int>::type = 0>
+    SIMD (const T & func)
+    {
+      data = _mm_set_epi64(func(1), func(0));
+    }
+
+    NETGEN_INLINE auto operator[] (int i) const { return ((int64_t*)(&data))[i]; }
+    NETGEN_INLINE __m128i Data() const { return data; }
+    NETGEN_INLINE __m128i & Data() { return data; }
+    // NETGEN_INLINE int64_t Lo() const { return _mm_extract_epi64(data, 0); }
+    // NETGEN_INLINE int64_t Hi() const { return _mm_extract_epi64(data, 1); }
+    NETGEN_INLINE int64_t Lo() const { return ((int64_t*)(&data))[0]; }
+    NETGEN_INLINE int64_t Hi() const { return ((int64_t*)(&data))[1]; }
+    static SIMD FirstInt(int n0=0) { return { n0, n0+1 }; }
+  };
+
+
+
+NETGEN_INLINE SIMD<int64_t,2> operator-(SIMD<int64_t,2> a) { return _mm_sub_epi64(_mm_setzero_si128(), a.Data()); }
+NETGEN_INLINE SIMD<int64_t,2> operator+ (SIMD<int64_t,2> a, SIMD<int64_t,2> b) { return _mm_add_epi64(a.Data(),b.Data()); }
+NETGEN_INLINE SIMD<int64_t,2> operator- (SIMD<int64_t,2> a, SIMD<int64_t,2> b) { return _mm_sub_epi64(a.Data(),b.Data()); }
+
+
+  template<>
+  class alignas(16) SIMD<double,2>
+  {
+    __m128d data;
+
+  public:
+    static constexpr int Size() { return 2; }
+    SIMD () {}
+    SIMD (const SIMD &) = default;
+    SIMD (double v0, double v1) { data = _mm_set_pd(v1,v0); }
+    SIMD (SIMD<double,1> v0, SIMD<double,1> v1)
+        : data{_mm_set_pd(v0.Data(), v1.Data())}
+    { }
+    SIMD (std::array<double, 2> arr)
+        : data{_mm_set_pd(arr[1], arr[0])}
+    {}
+
+    SIMD & operator= (const SIMD &) = default;
+
+    SIMD (double val) { data = _mm_set1_pd(val); }
+    SIMD (int val)    { data = _mm_set1_pd(val); }
+    SIMD (size_t val) { data = _mm_set1_pd(val); }
+
+    SIMD (double const * p) { data = _mm_loadu_pd(p); }
+    SIMD (double const * p, SIMD<mask64,2> mask)
+      {
+#ifdef __AVX__
+        data = _mm_maskload_pd(p, mask.Data());
+#else
+        // this versions segfaults if p points to the last allowed element
+        // happened on Mac with the new SparseCholesky-factorization
+        // data = _mm_and_pd(_mm_castsi128_pd(mask.Data()), _mm_loadu_pd(p));
+        auto pmask = (int64_t*)&mask;
+        data = _mm_set_pd (pmask[1] ? p[1] : 0.0, pmask[0] ? p[0] : 0.0);
+#endif
+      }
+    SIMD (__m128d _data) { data = _data; }
+
+    void Store (double * p) { _mm_storeu_pd(p, data); }
+    void Store (double * p, SIMD<mask64,2> mask)
+    {
+#ifdef __AVX__
+      _mm_maskstore_pd(p, mask.Data(), data);
+#else
+      /*
+      _mm_storeu_pd (p, _mm_or_pd (_mm_and_pd(_mm_castsi128_pd(mask.Data()), data),
+                                   _mm_andnot_pd(_mm_castsi128_pd(mask.Data()), _mm_loadu_pd(p))));
+      */
+      auto pmask = (int64_t*)&mask;
+      if (pmask[0]) p[0] = (*this)[0];
+      if (pmask[1]) p[1] = (*this)[1];
+#endif
+    }
+
+    template<typename T, typename std::enable_if<std::is_convertible<T, std::function<double(int)>>::value, int>::type = 0>
+    SIMD (const T & func)
+    {
+      data = _mm_set_pd(func(1), func(0));
+    }
+
+    NETGEN_INLINE double operator[] (int i) const { return ((double*)(&data))[i]; }
+    NETGEN_INLINE __m128d Data() const { return data; }
+    NETGEN_INLINE __m128d & Data() { return data; }
+
+    template <int I>
+    double Get() const
+    {
+      static_assert(I>=0 && I<2, "Index out of range");
+      return (*this)[I];
+    }
+
+    double Lo() const { return Get<0>(); } 
+    double Hi() const { return Get<1>(); } 
+    
+    operator std::tuple<double&,double&> ()
+    {
+      auto pdata = (double*)&data;
+      return std::tuple<double&,double&>(pdata[0], pdata[1]);
+    }
+  };
+
+  NETGEN_INLINE SIMD<double,2> operator- (SIMD<double,2> a) { return _mm_xor_pd(a.Data(), _mm_set1_pd(-0.0)); }
+  NETGEN_INLINE SIMD<double,2> operator+ (SIMD<double,2> a, SIMD<double,2> b) { return _mm_add_pd(a.Data(),b.Data()); }
+  NETGEN_INLINE SIMD<double,2> operator- (SIMD<double,2> a, SIMD<double,2> b) { return _mm_sub_pd(a.Data(),b.Data()); }
+  NETGEN_INLINE SIMD<double,2> operator* (SIMD<double,2> a, SIMD<double,2> b) { return _mm_mul_pd(a.Data(),b.Data()); }
+  NETGEN_INLINE SIMD<double,2> operator/ (SIMD<double,2> a, SIMD<double,2> b) { return _mm_div_pd(a.Data(),b.Data()); }
+  NETGEN_INLINE SIMD<double,2> operator* (double a, SIMD<double,2> b) { return _mm_set1_pd(a)*b; }
+  NETGEN_INLINE SIMD<double,2> operator* (SIMD<double,2> b, double a) { return _mm_set1_pd(a)*b; }
+
+  template<>
+  NETGEN_INLINE auto Unpack (SIMD<double,2> a, SIMD<double,2> b)
+  {
+    return std::make_tuple(SIMD<double,2>(_mm_unpacklo_pd(a.Data(),b.Data())),
+                      SIMD<double,2>(_mm_unpackhi_pd(a.Data(),b.Data())));
+  }
+
+  NETGEN_INLINE __m128d my_mm_hadd_pd(__m128d a, __m128d b) {
+#if defined(__SSE3__) || defined(__AVX__)
+    return _mm_hadd_pd(a,b);
+#else
+    return _mm_add_pd( _mm_unpacklo_pd(a,b), _mm_unpackhi_pd(a,b) );
+#endif
+  }
+
+#ifndef __AVX__
+  NETGEN_INLINE __m128i my_mm_cmpgt_epi64(__m128i a, __m128i b) {
+    auto  res_lo = _mm_cvtsi128_si64(a)  > _mm_cvtsi128_si64(b) ? -1:0;
+    auto  res_hi = _mm_cvtsi128_si64(_mm_srli_si128(a,8)) > _mm_cvtsi128_si64(_mm_srli_si128(b,8)) ? -1 : 0;
+    return _mm_set_epi64x(res_hi,res_lo);
+  }
+#else
+  NETGEN_INLINE __m128i my_mm_cmpgt_epi64(__m128i a, __m128i b) {
+    return _mm_cmpgt_epi64(a,b);
+  }
+#endif
+
+
+  NETGEN_INLINE SIMD<double,2> sqrt (SIMD<double,2> a) { return _mm_sqrt_pd(a.Data()); }
+  NETGEN_INLINE SIMD<double,2> fabs (SIMD<double,2> a) { return _mm_max_pd(a.Data(), (-a).Data()); }
+  using std::floor;
+  NETGEN_INLINE SIMD<double,2> floor (SIMD<double,2> a)
+  { return ngcore::SIMD<double,2>([&](int i)->double { return floor(a[i]); } ); }
+  using std::ceil;
+  NETGEN_INLINE SIMD<double,2> ceil (SIMD<double,2> a)
+  { return ngcore::SIMD<double,2>([&](int i)->double { return ceil(a[i]); } ); }
+
+  NETGEN_INLINE SIMD<mask64,2> operator<= (SIMD<double,2> a , SIMD<double,2> b)
+  { return _mm_castpd_si128( _mm_cmple_pd(a.Data(),b.Data())); }
+  NETGEN_INLINE SIMD<mask64,2> operator< (SIMD<double,2> a , SIMD<double,2> b)
+  { return _mm_castpd_si128( _mm_cmplt_pd(a.Data(),b.Data())); }
+  NETGEN_INLINE SIMD<mask64,2> operator>= (SIMD<double,2> a , SIMD<double,2> b)
+  { return _mm_castpd_si128( _mm_cmpge_pd(a.Data(),b.Data())); }
+  NETGEN_INLINE SIMD<mask64,2> operator> (SIMD<double,2> a , SIMD<double,2> b)
+  { return _mm_castpd_si128( _mm_cmpgt_pd(a.Data(),b.Data())); }
+  NETGEN_INLINE SIMD<mask64,2> operator== (SIMD<double,2> a , SIMD<double,2> b)
+  { return _mm_castpd_si128( _mm_cmpeq_pd(a.Data(),b.Data())); }
+  NETGEN_INLINE SIMD<mask64,2> operator!= (SIMD<double,2> a , SIMD<double,2> b)
+  { return _mm_castpd_si128( _mm_cmpneq_pd(a.Data(),b.Data())); }
+
+#ifdef __SSE4_2__  
+  NETGEN_INLINE SIMD<mask64,2> operator<= (SIMD<int64_t,2> a , SIMD<int64_t,2> b)
+  { return  _mm_xor_si128(_mm_cmpgt_epi64(a.Data(),b.Data()),_mm_set1_epi32(-1)); }
+  NETGEN_INLINE SIMD<mask64,2> operator< (SIMD<int64_t,2> a , SIMD<int64_t,2> b)
+  { return  my_mm_cmpgt_epi64(b.Data(),a.Data()); }
+  NETGEN_INLINE SIMD<mask64,2> operator>= (SIMD<int64_t,2> a , SIMD<int64_t,2> b)
+  { return  _mm_xor_si128(_mm_cmpgt_epi64(b.Data(),a.Data()),_mm_set1_epi32(-1)); }
+  NETGEN_INLINE SIMD<mask64,2> operator> (SIMD<int64_t,2> a , SIMD<int64_t,2> b)
+  { return  my_mm_cmpgt_epi64(a.Data(),b.Data()); }
+#endif
+#ifdef __SSE4_1__  
+  NETGEN_INLINE SIMD<mask64,2> operator== (SIMD<int64_t,2> a , SIMD<int64_t,2> b)
+  { return  _mm_cmpeq_epi64(a.Data(),b.Data()); }
+  NETGEN_INLINE SIMD<mask64,2> operator!= (SIMD<int64_t,2> a , SIMD<int64_t,2> b)
+  { return  _mm_xor_si128(_mm_cmpeq_epi64(a.Data(),b.Data()),_mm_set1_epi32(-1)); }
+#endif
+
+
+ NETGEN_INLINE SIMD<mask64,2> operator&& (SIMD<mask64,2> a, SIMD<mask64,2> b)
+  { return _mm_castpd_si128(_mm_and_pd (_mm_castsi128_pd(a.Data()),_mm_castsi128_pd( b.Data()))); }
+  NETGEN_INLINE SIMD<mask64,2> operator|| (SIMD<mask64,2> a, SIMD<mask64,2> b)
+  { return _mm_castpd_si128(_mm_or_pd (_mm_castsi128_pd(a.Data()), _mm_castsi128_pd(b.Data()))); }
+  NETGEN_INLINE SIMD<mask64,2> operator! (SIMD<mask64,2> a)
+  { return _mm_castpd_si128(_mm_xor_pd (_mm_castsi128_pd(a.Data()),_mm_castsi128_pd( _mm_cmpeq_epi64(a.Data(),a.Data())))); }
+#ifdef __SSE4_1__
+  NETGEN_INLINE SIMD<double,2> If (SIMD<mask64,2> a, SIMD<double,2> b, SIMD<double,2> c)
+  { return _mm_blendv_pd(c.Data(), b.Data(), _mm_castsi128_pd(a.Data())); }
+#else
+  NETGEN_INLINE SIMD<double,2> If (SIMD<mask64,2> a, SIMD<double,2> b, SIMD<double,2> c)
+  {
+    return _mm_or_pd(
+                      _mm_andnot_pd(_mm_castsi128_pd(a.Data()),c.Data()),
+                      _mm_and_pd(b.Data(),_mm_castsi128_pd(a.Data()))
+                      );}
+#endif // __SSE4_1__
+
+  NETGEN_INLINE SIMD<double,2> IfPos (SIMD<double,2> a, SIMD<double,2> b, SIMD<double,2> c)
+  { return ngcore::SIMD<double,2>([&](int i)->double { return a[i]>0 ? b[i] : c[i]; }); }
+  NETGEN_INLINE SIMD<double,2> IfZero (SIMD<double,2> a, SIMD<double,2> b, SIMD<double,2> c)
+  { return ngcore::SIMD<double,2>([&](int i)->double { return a[i]==0. ? b[i] : c[i]; }); }
+
+
+  NETGEN_INLINE double HSum (SIMD<double,2> sd)
+  {
+    return _mm_cvtsd_f64 (my_mm_hadd_pd (sd.Data(), sd.Data()));
+  }
+
+  NETGEN_INLINE auto HSum (SIMD<double,2> sd1, SIMD<double,2> sd2)
+  {
+    __m128d hv2 = my_mm_hadd_pd(sd1.Data(), sd2.Data());
+    return SIMD<double,2> (hv2);
+    // return SIMD<double,2>(_mm_cvtsd_f64 (hv2),  _mm_cvtsd_f64(_mm_shuffle_pd (hv2, hv2, 3)));
+  }
+
+  NETGEN_INLINE SIMD<int64_t, 2> If(SIMD<mask64, 2> a, SIMD<int64_t, 2> b,
+                             SIMD<int64_t, 2> c) {
+    return _mm_or_si128(
+                        _mm_andnot_si128(a.Data(),c.Data()),
+                        _mm_and_si128(b.Data(),a.Data())
+                        );
+  }
+
+}
+
+#endif // NETGEN_CORE_SIMD_SSE_HPP

netgen/include/core/statushandler.hpp

@@ -0,0 +1,37 @@
+#ifndef NETGEN_CORE_STATUSHANDLER
+#define NETGEN_CORE_STATUSHANDLER
+
+#include <string>
+#include "utils.hpp"
+
+namespace ngcore
+{
+  
+  class NGCORE_API multithreadt
+  {
+  public:
+    int pause;
+    int testmode;
+    int redraw;
+    int drawing;
+    int terminate;
+    int running;
+    double percent;
+    const char * task;
+    bool demorunning;
+    std::string * tcl_todo = new std::string("");  // tcl commands set from parallel thread
+    multithreadt();
+  };
+
+  NGCORE_API extern volatile multithreadt multithread;
+
+  
+  extern NGCORE_API void SetStatMsg(const std::string& s);
+
+  extern NGCORE_API void PushStatus(const std::string& s);
+  extern NGCORE_API void PushStatusF(const std::string& s);
+  extern NGCORE_API void PopStatus();
+  extern NGCORE_API void SetThreadPercent(double percent);
+  extern NGCORE_API void GetStatus(std::string & s, double & percentage);
+}
+#endif

netgen/include/core/symboltable.hpp

@@ -0,0 +1,153 @@
+#ifndef NETGEN_CORE_SYMBOLTABLE_HPP
+#define NETGEN_CORE_SYMBOLTABLE_HPP
+
+#include <ostream>
+#include <string>
+#include <vector>
+
+#include "exception.hpp"
+#include "ngcore_api.hpp"
+
+namespace ngcore
+{
+  /**
+      A symbol table.
+
+      The symboltable provides a mapping from string identifiers
+      to the generic type T. The strings are copied.
+      Complexity by name access is linear, by index is constant.
+  */
+  template <class T>
+  class SymbolTable
+  {
+    std::vector<std::string> names;
+    std::vector<T> data;
+  public:
+    using value_type = T;
+    using reference = typename std::vector<T>::reference;
+    using const_reference = typename std::vector<T>::const_reference;
+
+    /// Creates a symboltable
+    SymbolTable () = default;
+    SymbolTable (const SymbolTable<T> &) = default;
+    SymbolTable (SymbolTable<T> &&) noexcept = default;
+
+    ~SymbolTable() = default;
+
+    SymbolTable& operator=(const SymbolTable<T>&) = default;
+    SymbolTable& operator=(SymbolTable<T>&&) = default;
+
+    template<typename ARCHIVE>
+    auto DoArchive(ARCHIVE& ar)
+      -> typename std::enable_if_t<ARCHIVE::template is_archivable<T>, void>
+    {
+      ar & names & data;
+    }
+
+    /// INDEX of symbol name, throws exception if unused
+    size_t Index (std::string_view name) const
+    {
+      for (size_t i = 0; i < names.size(); i++)
+        if (names[i] == name) return i;
+      throw RangeException("SymbolTable", name);
+    }
+
+    /// Index of symbol name, returns -1 if unused
+    int CheckIndex (std::string_view name) const
+    {
+      for (int i = 0; i < names.size(); i++)
+        if (names[i] == name) return i;
+      return -1;
+    }
+
+    /// number of identifiers
+    size_t Size() const
+    {
+      return data.size();
+    }
+
+    /// Returns reference to element. exception for unused identifier
+    reference operator[] (std::string_view name)
+    {
+      return data[Index (name)];
+    }
+
+    const_reference operator[] (std::string_view name) const
+    {
+      return data[Index (name)];
+    }
+
+    /// Returns reference to i-th element, range check only in debug build
+    reference operator[] (size_t i)
+    {
+      NETGEN_CHECK_RANGE(i, 0, data.size());
+      return data[i];
+    }
+
+    /// Returns const reference to i-th element, range check only in debug build
+    const_reference operator[] (size_t i) const
+    {
+      NETGEN_CHECK_RANGE(i, 0, data.size());
+      return data[i];
+    }
+
+    /// Returns name of i-th element, range check only in debug build
+    const std::string & GetName (size_t i) const
+    {
+      NETGEN_CHECK_RANGE(i, 0, names.size());
+      return names[i];
+    }
+
+    /// Associates el to the string name, overrides if name is used
+    void Set (std::string_view name, const T & el)
+    {
+      int i = CheckIndex (name);
+      if (i >= 0)
+        data[i] = el;
+      else
+        {
+          data.push_back(el);
+          names.push_back(std::string(name));
+        }
+    }
+
+
+    
+    /*
+    bool Used (const std::string & name) const
+    {
+      return CheckIndex(name) >= 0;
+    }
+    */
+    
+    bool Used (std::string_view name) const
+    {
+      return CheckIndex(name) >= 0;
+    }
+    
+    /// Deletes symboltable
+    inline void DeleteAll ()
+    {
+      names.clear();
+      data.clear();
+    }
+
+    // Adds all elements from other symboltable
+    SymbolTable<T>& Update(const SymbolTable<T>& tbl2)
+    {
+      for (size_t i = 0; i < tbl2.Size(); i++)
+        Set (tbl2.GetName(i), tbl2[i]);
+      return *this;
+    }
+  };
+
+  template <typename T>
+  std::ostream & operator<< (std::ostream & ost, const SymbolTable<T> & st)
+  {
+    for (int i = 0; i < st.Size(); i++)
+      ost << st.GetName(i) << " : " << st[i] << std::endl;
+    return ost;
+  }
+} // namespace ngcore
+
+#endif // NETGEN_CORE_SYMBOLTABLE_HPP