netgen-mesher 6.2.2504.post11.dev0__cp313-cp313-win_amd64.whl → 6.2.2506.post48.dev0__cp313-cp313-win_amd64.whl

netgen/include/core/simd_generic.hpp

@@ -48,6 +48,13 @@ namespace ngcore
       return k;
   }
 
+  constexpr size_t LargestPowerOfTwo (size_t x)
+  {
+    size_t y = 1;
+    while (2*y <= x) y *= 2;
+    return y;
+  }
+  
 
   template <typename T, int N=GetDefaultSIMDSize()> class SIMD;
 
@@ -89,7 +96,8 @@ namespace ngcore
   template <int N>
   class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<mask64,N>
   {
-    static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);
     static constexpr int N2 = N-N1;
 
     SIMD<mask64,N1> lo;
@@ -111,6 +119,113 @@ namespace ngcore
     }
 
 
+  ////////////////////////////////////////////////////////////////////////////
+  // int32
+
+  template<>
+  class SIMD<int32_t,1>
+  {
+    int32_t data;
+
+  public:
+    static constexpr int Size() { return 1; }
+    SIMD () {}
+    SIMD (const SIMD &) = default;
+    SIMD & operator= (const SIMD &) = default;
+    // SIMD (int val) : data{val} {}
+    SIMD (int32_t val) : data{val} {}
+    SIMD (size_t val) : data(val) {}
+    explicit SIMD (std::array<int32_t, 1> arr) : data{arr[0]} {}
+    
+
+    
+    int32_t operator[] (int i) const { return ((int32_t*)(&data))[i]; }
+    auto Data() const { return data; }
+    static SIMD FirstInt(int32_t n0=0) { return {n0}; }
+    template <int I>
+    int32_t Get()
+    {
+      static_assert(I==0);
+      return data;
+    }
+  };
+
+  template<int N>
+  class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<int32_t,N>
+  {
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);        
+    static constexpr int N2 = N-N1;
+
+    SIMD<int32_t,N1> lo;
+    SIMD<int32_t,N2> high;
+
+  public:
+    static constexpr int Size() { return N; }
+
+    SIMD () {}
+    SIMD (const SIMD &) = default;
+    SIMD & operator= (const SIMD &) = default;
+
+    // SIMD (int val) : lo{val}, high{val} { ; }
+    SIMD (int32_t val) : lo{val}, high{val} { ; }
+    SIMD (size_t val) : lo{val}, high{val} { ; }
+    SIMD (int32_t * p) : lo{p}, high{p+N1} { ; }
+    
+    SIMD (SIMD<int32_t,N1> lo_, SIMD<int32_t,N2> high_) : lo(lo_), high(high_) { ; }
+
+    explicit SIMD( std::array<int32_t, N> arr )
+        : lo(detail::array_range<N1>(arr, 0)),
+          high(detail::array_range<N2>(arr, N1))
+      {}
+
+
+    template<typename ...T>
+    explicit SIMD(const T... vals)
+      : lo(detail::array_range<N1>(std::array<int32_t, N>{vals...}, 0)),
+        high(detail::array_range<N2>(std::array<int32_t, N>{vals...}, N1))
+      {
+        static_assert(sizeof...(vals)==N, "wrong number of arguments");
+      }
+
+
+    template<typename T, typename std::enable_if<std::is_convertible<T, std::function<int32_t(int)>>::value, int>::type = 0>
+      SIMD (const T & func)
+    {
+      for(auto i : IntRange(N1))
+          lo[i] = func(i);
+      for(auto i : IntRange(N2))
+          high[i] = func(N1+i);
+    }
+    
+    auto Lo() const { return lo; }
+    auto Hi() const { return high; }
+
+    int32_t operator[] (int i) const { return ((int32_t*)(&lo))[i]; }
+
+    void Store (int32_t * p) { lo.Store(p); high.Store(p+N1); }
+
+    
+    /*
+    operator tuple<int32_t&,int32_t&,int32_t&,int32_t&> ()
+    { return tuple<int32_t&,int32_t&,int32_t&,int32_t&>((*this)[0], (*this)[1], (*this)[2], (*this)[3]); }
+    */
+
+    /*
+    static SIMD FirstInt() { return { 0, 1, 2, 3 }; }
+    */
+    static SIMD FirstInt(int32_t n0=0) { return {SIMD<int32_t,N1>::FirstInt(n0), SIMD<int32_t,N2>::FirstInt(n0+N1)}; }
+    template <int I>
+    int32_t Get()
+    {
+      static_assert(I>=0 && I<N, "Index out of range");
+      if constexpr(I<N1) return lo.template Get<I>();
+      else               return high.template Get<I-N1>();
+    }
+  };
+
+
+
   ////////////////////////////////////////////////////////////////////////////
   // int64
 
@@ -145,7 +260,8 @@ namespace ngcore
   template<int N>
   class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<int64_t,N>
   {
-    static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);        
     static constexpr int N2 = N-N1;
 
     SIMD<int64_t,N1> lo;
@@ -209,6 +325,7 @@ namespace ngcore
     }
   };
 
+  
 
   ////////////////////////////////////////////////////////////////////////////
   // double
@@ -262,7 +379,8 @@ namespace ngcore
   template<int N>
   class alignas(GetLargestNativeSIMDPart(N)*sizeof(double)) SIMD<double, N>
   {
-    static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    // static constexpr int N1 = GetLargestNativeSIMDPart(N);
+    static constexpr size_t N1 = LargestPowerOfTwo(N-1);    
     static constexpr int N2 = N-N1;
 
     SIMD<double, N1> lo;
@@ -314,7 +432,7 @@ namespace ngcore
 
     template<typename ...T>
     explicit SIMD(const T... vals)
-    : lo(detail::array_range<N1>(std::array<double, N>{vals...}, 0)),
+      : lo(detail::array_range<N1>(std::array<double, N>{vals...}, 0)),
       high(detail::array_range<N2>(std::array<double, N>{vals...}, N1))
       {
         static_assert(sizeof...(vals)==N, "wrong number of arguments");
@@ -327,8 +445,8 @@ namespace ngcore
       high.Store(p+N1, mask.Hi());
     }
 
-    auto Lo() const { return lo; }
-    auto Hi() const { return high; }
+    NETGEN_INLINE auto Lo() const { return lo; }
+    NETGEN_INLINE auto Hi() const { return high; }
 
     double operator[] (int i) const { return ((double*)(&lo))[i]; }
 
@@ -426,6 +544,20 @@ namespace ngcore
       else               return { a.Lo()!=b.Lo(), a.Hi()!=b.Hi() };
     }
 
+  template <int N>
+  NETGEN_INLINE SIMD<int64_t,N> operator& (SIMD<int64_t,N> a, SIMD<int64_t,N> b)
+    {
+      if constexpr(N==1) return a.Data() & b.Data();
+      else               return { (a.Lo()&b.Lo()), (a.Hi()&b.Hi()) };
+    }
+  template <int N>
+  NETGEN_INLINE SIMD<int64_t,N> operator| (SIMD<int64_t,N> a, SIMD<int64_t,N> b)
+    {
+      if constexpr(N==1) return a.Data() & b.Data();
+      else               return { (a.Lo()|b.Lo()), (a.Hi()|b.Hi()) };
+    }
+
+  
   // int64_t operators with scalar operand (implement overloads to allow implicit casts for second operand)
   template <int N>
   NETGEN_INLINE SIMD<int64_t,N> operator+ (SIMD<int64_t,N> a, int64_t b) { return a+SIMD<int64_t,N>(b); }
@@ -458,6 +590,7 @@ namespace ngcore
   template <int N>
   NETGEN_INLINE SIMD<int64_t,N> & operator/= (SIMD<int64_t,N> & a, SIMD<int64_t,N> b) { a = a/b; return a; }
 
+
   // double operators with scalar operand (implement overloads to allow implicit casts for second operand)
   template <int N>
   NETGEN_INLINE SIMD<double,N> operator+ (SIMD<double,N> a, double b) { return a+SIMD<double,N>(b); }
@@ -490,6 +623,10 @@ namespace ngcore
   template <int N>
   NETGEN_INLINE SIMD<double,N> & operator/= (SIMD<double,N> & a, SIMD<double,N> b) { a = a/b; return a; }
 
+  template <int N>
+  NETGEN_INLINE auto operator> (SIMD<double,N> & a, double b) { return a > SIMD<double,N>(b); }
+
+  
   // double functions
 
   template <int N>
@@ -580,6 +717,96 @@ namespace ngcore
   }
 
 
+  template<typename T2, typename T1>
+  T2 BitCast(T1 a)
+  {
+    T2 result;
+    static_assert(sizeof(T1) == sizeof(T2), "BitCast requires same size");
+    memcpy(&result, &a, sizeof(T1));
+    return result;
+  }
+
+  template <typename T, typename T1, int N>
+  SIMD<T, N> Reinterpret (SIMD<T1,N> a)
+  {
+    if constexpr (N == 1)
+      return SIMD<T,N> ( * (T*)(void*) & a.Data());
+    else if constexpr (N == 2)
+      return SIMD<T,N> { BitCast<T> (a.Lo()),
+                         BitCast<T> (a.Hi()) };
+    else
+      return SIMD<T,N> (Reinterpret<T> (a.Lo()), Reinterpret<T> (a.Hi()));
+  }
+
+  
+  using std::round;  
+  template <int N>
+  SIMD<double,N> round (SIMD<double,N> x)
+  {
+    if constexpr (N == 1) return round(x);
+    else                  return { round(x.Lo()), round(x.Hi()) };
+  }
+
+  // NETGEN_INLINE int64_t RoundI (double x) { return lround(x); }
+  using std::lround;
+  template <int N>  
+  SIMD<int64_t,N> lround (SIMD<double,N> x)
+  {
+    if constexpr (N == 1) return SIMD<int64_t,1> (lround(x));
+    else                  return { lround(x.Lo()), lround(x.Hi()) };
+  }
+
+  /*
+    reciprocal square root 
+    Quake III algorithm, or intrinsics 
+   */
+  //
+#ifndef __CUDACC__
+  NETGEN_INLINE double rsqrt (double x) { return 1.0/sqrt(x); }
+#endif
+  
+  template <int N>  
+  SIMD<double,N> rsqrt (SIMD<double,N> x)
+  {
+    if constexpr (N == 1) return 1.0/sqrt(x.Data()); 
+    else                  return { rsqrt(x.Lo()), rsqrt(x.Hi()) };
+  }
+
+  template <int N>  
+  int64_t operator<< (int64_t a, IC<N> n) { return a << n.value; }
+  
+  template <int S, int N>
+  SIMD<int64_t,S> operator<< (SIMD<int64_t,S> a, IC<N> n)
+  {
+    if constexpr (S == 1) return SIMD<int64_t,1> (a.Data() << n);
+    else                  return SIMD<int64_t,S> (a.Lo() << n, a.Hi() << n);
+  }
+
+
+
+  
+  template <typename T, int N>
+  auto Min (SIMD<T,N> a, SIMD<T,N> b)
+  {
+    if constexpr (N==1)
+      return SIMD<T,1> (std::min(a[0], b[0]));
+    else
+      return SIMD<T,N> (Min(a.Lo(), b.Lo()), Min(a.Hi(), b.Hi()));
+  }
+  
+  template <typename T, int N>
+  auto Max (SIMD<T,N> a, SIMD<T,N> b)
+  {
+    if constexpr (N==1)
+      return SIMD<T,1> (std::max(a[0], b[0]));
+    else
+      return SIMD<T,N> (Max(a.Lo(), b.Lo()), Max(a.Hi(), b.Hi()));
+  }
+  
+
+
+  
+  
   template <typename T, int N>
   ostream & operator<< (ostream & ost, SIMD<T,N> simd)
   {
@@ -597,8 +824,11 @@ namespace ngcore
 
   using std::sqrt;
   template <int N>
-  NETGEN_INLINE ngcore::SIMD<double,N> sqrt (ngcore::SIMD<double,N> a) {
-    return ngcore::SIMD<double,N>([a](int i)->double { return sqrt(a[i]); } );
+  NETGEN_INLINE ngcore::SIMD<double,N> sqrt (ngcore::SIMD<double,N> a)
+  {
+    if constexpr (N == 1) return sqrt(a.Data());
+    else return { sqrt(a.Lo()), sqrt(a.Hi()) }; 
+    // return ngcore::SIMD<double,N>([a](int i)->double { return sqrt(a[i]); } );
   }
 
   using std::fabs;
@@ -777,6 +1007,42 @@ namespace ngcore
                              FMAddSub(a.Hi(), b.Hi(), c.Hi()));
     }
   }
+
+
+
+
+  template <int BASE, typename Tuple, std::size_t ... Is>
+  auto subtuple (const Tuple& tup, std::index_sequence<Is...>)
+  {
+    return std::make_tuple(std::get<BASE+Is>(tup)...);
+  }
+  
+  template <typename ...Args, typename T, int M>
+  auto Concat (std::tuple<SIMD<T,M>, Args...> tup)
+  {
+    constexpr size_t N = std::tuple_size<std::tuple<SIMD<T,M>, Args...>>();
+    
+    if constexpr (N == 1)
+      return get<0>(tup);
+    else
+      {
+        static constexpr size_t N1 = LargestPowerOfTwo(N-1);
+        static constexpr int N2 = N-N1;
+        
+        auto SEQ1 = std::make_index_sequence<N1>();
+        auto sub1 = subtuple<0>(tup, SEQ1);
+        
+        auto SEQ2 = std::make_index_sequence<N2>();
+        auto sub2 = subtuple<N1>(tup, SEQ2);
+      
+        auto S1 = Concat(sub1);
+        auto S2 = Concat(sub2);
+        return SIMD<T,S1.Size()+S2.Size()>(S1, S2);
+      }
+  }
+  
+
+  
 }
 
 

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

@@ -21,6 +21,9 @@ namespace ngcore
       : 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; }
@@ -66,6 +69,10 @@ namespace ngcore
     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 }; }
   };
 
@@ -215,6 +222,7 @@ NETGEN_INLINE SIMD<int64_t,2> operator- (SIMD<int64_t,2> a, SIMD<int64_t,2> b) {
   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)
@@ -223,11 +231,13 @@ NETGEN_INLINE SIMD<int64_t,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)

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/table.hpp

@@ -262,14 +262,14 @@ namespace ngcore
     const MemoryTracer& GetMemoryTracer() const { return mt; }
 
   private:
-    size_t GetMemUsage() const { return size == 0 ? 0 : sizeof(T)*index[size] + sizeof(IndexType) * size+1; }
+    NETGEN_INLINE size_t GetMemUsage() const { return size == 0 ? 0 : sizeof(T)*index[size] + sizeof(IndexType) * size+1; }
     MemoryTracer mt;
   };
 
 
   /// Print table
   template <class T, typename IndexType>
-  inline ostream & operator<< (ostream & s, const Table<T,IndexType> & table)
+  inline ostream & operator<< (ostream & s, FlatTable<T,IndexType> table)
   {
     for (auto i : table.Range())
       {
@@ -462,6 +462,7 @@ namespace ngcore
       : TableCreator<int>(), takedofs(atakedofs) { };
     FilteredTableCreator(int acnt, const BitArray* atakedofs)
       : TableCreator<int>(acnt),takedofs(atakedofs) { };
+    void SetFilter (const BitArray * atakedofs) { takedofs = atakedofs; } 
     void Add (size_t blocknr, int data);
     void Add (size_t blocknr, IntRange range);
     void Add (size_t blocknr, FlatArray<int> dofs);