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

netgen/include/core/type_traits.hpp

@@ -0,0 +1,65 @@
+#ifndef NETGEN_CORE_TYPE_TRAITS_HPP
+#define NETGEN_CORE_TYPE_TRAITS_HPP
+
+#include <memory>
+#include <type_traits>
+
+namespace ngcore
+{
+  namespace detail
+  {
+    template<bool... b> struct _BoolArray{};
+
+    template<bool ... vals>
+    constexpr bool all_of_tmpl = std::is_same<_BoolArray<vals...>, _BoolArray<(vals || true)...>>::value; // NOLINT
+
+    template<typename T>
+    struct is_any_pointer_impl : std::false_type {};
+
+    // check if second template argument is tuple of base classes to first
+    // template argument, return constexpr bool
+    template<typename T, typename Tuple>
+    constexpr bool is_base_of_tuple = false;
+
+    template<typename T, typename... Ts>
+    constexpr bool is_base_of_tuple<T, std::tuple<Ts...>> =
+      all_of_tmpl<std::is_base_of<Ts, T>::value...>;
+
+    template<typename T>
+    struct is_any_pointer_impl<T*> : std::true_type {};
+
+    template<typename T>
+    struct is_any_pointer_impl<std::shared_ptr<T>> : std::true_type {};
+
+    template<typename T>
+    struct is_any_pointer_impl<std::unique_ptr<T>> : std::true_type {};
+
+    template<typename T>
+    constexpr bool is_any_pointer = is_any_pointer_impl<T>::value;
+  } // namespace detail
+
+  
+  // Type trait to check if a class implements a 'range_type Range()' function
+  namespace detail
+  {
+    template<typename T>
+    struct has_Range
+    {
+    private:
+      template<typename T2>
+      static constexpr auto check(T2*) ->
+        std::enable_if_t<!std::is_same_v<decltype(std::declval<T2>().Range()), void>, std::true_type>
+      { std::true_type(); }
+      template<typename>
+      static constexpr std::false_type check(...);
+      using type = decltype(check<T>(nullptr)); // NOLINT
+    public:
+      NGCORE_API static constexpr bool value = type::value;
+    };
+  }
+  template<typename T>
+  constexpr bool has_range = detail::has_Range<T>::value;
+
+} // namespace ngcore
+
+#endif // NETGEN_CORE_TYPE_TRAITS_HPP

netgen/include/core/utils.hpp

@@ -0,0 +1,385 @@
+#ifndef NETGEN_CORE_UTILS_HPP
+#define NETGEN_CORE_UTILS_HPP
+
+#include <atomic>
+#include <chrono>
+#include <filesystem>
+#include <map>
+#include <ostream>
+#include <optional>
+#include <sstream>
+#include <string>
+
+#include "ngcore_api.hpp"       // for NGCORE_API and CPU arch macros
+
+#if defined(__APPLE__) && defined(NETGEN_ARCH_ARM64)
+#include <mach/mach_time.h>
+#endif
+
+#ifdef NETGEN_ARCH_AMD64
+#ifdef WIN32
+#include <intrin.h>   // for __rdtsc()  CPU time step counter
+#else
+#include <x86intrin.h>   // for __rdtsc()  CPU time step counter
+#endif // WIN32
+#endif // NETGEN_ARCH_AMD64
+
+namespace ngcore
+{
+  // MPI rank, nranks TODO: Rename
+  // [[deprecated("don't use global id/ntasks")]]       
+  extern NGCORE_API int id;
+  // [[deprecated("don't use global id/ntasks")]]         
+  extern NGCORE_API int ntasks;
+  
+  NGCORE_API std::string Demangle(const char* typeinfo);
+
+  template<typename T>
+  std::string GetName(const T& obj)
+  { return Demangle(typeid(obj).name()); }
+
+#if defined(__GNUC__)
+  inline bool likely (bool x) { return bool(__builtin_expect(long(x), 1L)); }
+  inline bool unlikely (bool x) { return bool(__builtin_expect(long(x), 0L)); }
+#else
+  inline bool likely (bool x) { return x; }
+  inline bool unlikely (bool x) { return x; }
+#endif
+
+  using TClock = std::chrono::system_clock;
+  extern NGCORE_API const std::chrono::time_point<TClock> wall_time_start;
+
+  // Time in seconds since program start
+  inline double WallTime () noexcept
+  {
+      std::chrono::time_point<TClock> now = TClock::now();
+      std::chrono::duration<double> elapsed_seconds = now-wall_time_start;
+      return elapsed_seconds.count();
+  }
+
+  // High precision clock counter register
+  using TTimePoint = size_t;
+  extern NGCORE_API double seconds_per_tick;
+
+  inline TTimePoint GetTimeCounter() noexcept
+  {
+#if defined(NETGEN_ARCH_AMD64)
+    return __rdtsc();
+#elif defined(NETGEN_ARCH_ARM64)
+    unsigned long long tics;
+    __asm __volatile("mrs %0, CNTVCT_EL0" : "=&r" (tics));
+    return tics;
+#elif defined(__EMSCRIPTEN__) || (defined(_MSC_VER) && defined(_M_ARM64))
+    return std::chrono::high_resolution_clock::now().time_since_epoch().count();
+#else
+#warning "Unsupported CPU architecture"
+    return 0;
+#endif
+  }
+
+  template <class T>
+  inline std::string ToString (const T& t)
+  {
+      std::stringstream ss;
+      ss << t;
+      return ss.str();
+  }
+
+  inline std::string ToLower( const std::string & s )
+  {
+    std::string res;
+    res.reserve(s.size());
+
+    for(auto & c : s)
+        res.push_back(tolower(c));
+
+    return res;
+  }
+
+  inline std::string ToLower( const std::filesystem::path & p )
+  {
+    return ToLower(p.string());
+  }
+
+
+
+  template <class T>
+  void SaveBin (std::ostream & ost, const T & val)
+  {
+    const char * cp = reinterpret_cast<const char*> (&val);
+    for (unsigned j = 0; j < sizeof(T); j++)
+      ost.put(cp[j]);
+  }
+  
+  
+  template <class T>
+  void LoadBin (std::istream & ist, T & val)
+  {
+    char * cp = reinterpret_cast<char*> (&val);
+    for (unsigned j = 0; j < sizeof(T); j++)
+      ist.get(cp[j]);
+  }
+  
+  
+  template<typename T1, typename T2>
+  std::ostream& operator << (std::ostream& ost, const std::map<T1,T2>& map)
+  {
+    for(auto& val : map)
+      ost << "\n" << val.first << ": " << val.second;
+    return ost;
+  }
+
+  template <class T>
+  NETGEN_INLINE void Swap (T & a, T & b)
+  {
+      T temp = std::move(a);
+      a = std::move(b);
+      b = std::move(temp);
+  }
+
+  
+  /// min of 2 values
+  template <class T>
+  NETGEN_INLINE T min2 (T a, T b)
+  {
+    return (a < b) ? a : b;
+  }
+  
+  /// max of 2 values
+  template <class T>
+  NETGEN_INLINE T max2 (T a, T b)
+  {
+    return (a > b) ? a : b;
+}
+  
+  /// min of 3 values
+  template <class T>
+  NETGEN_INLINE T min3 (T a, T b, T c)
+  {
+  return (a < b) ? (a < c) ? a : c
+    : (b < c) ? b : c;
+  }
+  
+  /// max of 3 values
+  template <class T>
+  NETGEN_INLINE T max3 (T a, T b, T c)
+  {
+    ///
+    return (a > b) ? ((a > c) ? a : c)
+      : ((b > c) ? b : c);
+  }
+  
+  
+  /// sign of value (+1, 0, -1)
+  template <class T>
+  NETGEN_INLINE int sgn (T a)
+  {
+    return (a > 0) ? 1 : ( ( a < 0) ? -1 : 0 );
+  }
+  
+  /// square element 
+  template <class T>
+  NETGEN_INLINE constexpr T sqr (const T a)
+  {
+    return a * a; 
+  }
+  
+  /// element to the third power
+  template <class T>
+  NETGEN_INLINE T pow3 (const T a)
+  {
+    return a * a * a; 
+  }
+  
+  
+
+  NETGEN_INLINE double IfPos (double a, double b, double c) { return a>0 ? b : c; }
+  NETGEN_INLINE double IfZero (double a, double b, double c) { return a==0. ? b : c; }
+
+  // checks if string starts with sequence
+  inline bool StartsWith(const std::string& str, const std::string& start)
+  {
+    if(start.size() > str.size())
+      return false;
+    return std::equal(start.begin(), start.end(), str.begin());
+  }
+
+  // checks if string ends with sequence
+  inline bool EndsWith(const std::string& str, const std::string& end)
+  {
+    if(end.size() > str.size())
+      return false;
+    return std::equal(end.rbegin(), end.rend(), str.rbegin());
+  }
+
+  template<typename T>
+  NETGEN_INLINE std::atomic<T> & AsAtomic (T & d)
+  {
+    return reinterpret_cast<std::atomic<T>&> (d);
+  }
+
+  NETGEN_INLINE double AtomicAdd( double & sum, double val )
+  {
+      std::atomic<double> & asum = AsAtomic(sum);
+      double current = asum.load();
+      while (!asum.compare_exchange_weak(current, current + val))
+          ;
+      return current;
+  }
+
+  template<typename T>
+  NETGEN_INLINE T AtomicMin( T & minval, T val )
+  {
+      std::atomic<T> & aminval = AsAtomic(minval);
+      T current = aminval.load();
+      while (!aminval.compare_exchange_weak(current, std::min(current, val)))
+          ;
+      return current;
+  }
+
+  template<typename T>
+  NETGEN_INLINE T AtomicMax( T & maxval, T val )
+  {
+      std::atomic<T> & amaxval = AsAtomic(maxval);
+      T current = amaxval.load();
+      while (!amaxval.compare_exchange_weak(current, std::max(current, val)))
+          ;
+      return current;
+  }
+
+  
+
+  
+  template <int N> using IC = std::integral_constant<int,N>;  // needed for Iterate
+
+  
+  namespace detail {
+    template <typename T, typename Enable = int>
+    struct IsIC_trait {
+      static constexpr auto check() { return false; }
+    };
+    
+    template <typename T>
+    struct IsIC_trait<T, std::enable_if_t<std::is_same_v<T, IC<T::value>> == true, int> > {
+      static constexpr auto check() { return true; }  
+    };
+  }
+  
+  template <typename T>
+  constexpr bool is_IC() {
+    return detail::IsIC_trait<T>::check();
+  }
+  
+  
+
+  
+  template <int NUM, typename FUNC>
+  NETGEN_INLINE void Iterate (FUNC f)
+  {
+    if constexpr (NUM > 1) Iterate<NUM-1> (f);
+  if constexpr (NUM >= 1) f(IC<NUM-1>());
+  }
+  
+  
+  template <int NUM, typename FUNC>
+  NETGEN_INLINE void Switch (size_t nr, FUNC f)
+  {
+    if (NUM-1 == nr) f(IC<NUM-1>());
+    if constexpr (NUM > 1) Switch<NUM-1> (nr, f);
+  }
+  
+  
+  
+  namespace detail
+  {
+    template<typename T>
+    struct IndexTypeHelper
+    {
+    private:
+      template<typename T2>
+      static constexpr auto check(T2* t) -> typename T2::index_type { return *t; }
+      static constexpr size_t check(...);
+
+    public:
+      using type = decltype(check((T*) nullptr)); // NOLINT
+    };
+  
+  } // namespace detail
+
+  // Get index type of object. If object has a typedef index_type it is this type, else size_t
+  template<typename T>
+  using index_type = typename detail::IndexTypeHelper<T>::type;
+
+  class MyMutex
+  {
+    std::atomic<bool> m;
+  public:
+    MyMutex() { m.store(false, std::memory_order_relaxed); }
+    void lock()
+    {
+      bool should = false;
+      while (!m.compare_exchange_weak(should, true))
+        {
+          should = false;
+#ifdef NETGEN_ARCH_AMD64
+          _mm_pause();
+#endif // NETGEN_ARCH_AMD64
+        }
+    }
+    void unlock()
+    {
+      m = false;
+    }
+  };
+
+  class MyLock
+  {
+    MyMutex & mutex;
+  public:
+    MyLock (MyMutex & amutex) : mutex(amutex) { mutex.lock(); }
+    ~MyLock () { mutex.unlock(); }
+  };
+
+  NGCORE_API int GetCompiledSIMDSize();
+  NGCORE_API bool IsRangeCheckEnabled();
+
+  NGCORE_API std::filesystem::path GetTempFilename();
+
+  NGCORE_API void* GetRawSymbol( std::string func_name );
+
+  template <typename TFunc>
+  TFunc GetSymbol( std::string func_name )
+  {
+    return reinterpret_cast<TFunc>(GetRawSymbol(func_name));
+  }
+
+  // Class to handle/load shared libraries
+  class NGCORE_API SharedLibrary
+  {
+    std::filesystem::path lib_name;
+    std::optional<std::filesystem::path> directory_to_delete = std::nullopt;
+    void *lib = nullptr;
+
+  public:
+    SharedLibrary() = default;
+    SharedLibrary(const std::filesystem::path & lib_name_, std::optional<std::filesystem::path> directory_to_delete_ = std::nullopt, bool global = false );
+
+    SharedLibrary(const SharedLibrary &) = delete;
+    SharedLibrary & operator =(const SharedLibrary &) = delete;
+
+    ~SharedLibrary();
+
+    template <typename TFunc>
+    TFunc GetSymbol( std::string func_name )
+    {
+      return reinterpret_cast<TFunc>(GetRawSymbol(func_name));
+    }
+
+    void Load( const std::filesystem::path & lib_name_, bool global = true);
+    void Unload();
+    void* GetRawSymbol( std::string func_name );
+  };
+
+} // namespace ngcore
+
+#endif // NETGEN_CORE_UTILS_HPP

netgen/include/core/version.hpp

@@ -0,0 +1,102 @@
+#ifndef NETGEN_CORE_VERSION_HPP
+#define NETGEN_CORE_VERSION_HPP
+
+#include <ostream>
+#include <string>
+#include <tuple>
+
+#include "ngcore_api.hpp"
+
+namespace ngcore
+{
+  class VersionInfo
+  {
+  private:
+    size_t mayor_{}, minor_{}, release{}, patch{};
+    std::string git_hash{};
+  public:
+    VersionInfo() = default;
+    VersionInfo(std::string vstring)
+    {
+      minor_ = release = patch = 0;
+      git_hash = "";
+      if(vstring.substr(0,1) == "v")
+        vstring = vstring.substr(1,vstring.size()-1);
+      auto dot = vstring.find('.');
+      mayor_ = std::stoi(vstring.substr(0,dot));
+      if(dot == size_t(-1)) vstring = "";
+      else vstring = vstring.substr(dot+1, vstring.size()-dot-1);
+      if(!vstring.empty())
+        {
+          dot = vstring.find('.');
+          minor_ = std::stoi(vstring.substr(0,dot));
+          if (dot == size_t(-1)) vstring = "";
+          else vstring = vstring.substr(dot+1, vstring.size()-dot-1);
+          if(!vstring.empty())
+            {
+              dot = vstring.find('-');
+              release = std::stoi(vstring.substr(0,dot));
+              if(dot == size_t(-1)) vstring = "";
+              else vstring = vstring.substr(dot+1,vstring.size()-dot-1);
+              if(!vstring.empty())
+                {
+                  dot = vstring.find('-');
+                  patch = std::stoi(vstring.substr(0,dot));
+                  if(dot == size_t(-1)) vstring = "";
+                  else vstring = vstring.substr(dot+1, vstring.size()-dot-1);
+                  if(!vstring.empty())
+                    git_hash = vstring;
+                }
+            }
+        }
+    }
+    VersionInfo(const char* cstr) : VersionInfo(std::string(cstr)) { }
+
+    std::string to_string() const
+    { std::string vstring = "v" + std::to_string(mayor_);
+      if(minor_ || release || patch || !git_hash.empty())
+        {
+          vstring += "." + std::to_string(minor_);
+          if(release || patch || !git_hash.empty())
+            {
+              vstring += "." + std::to_string(release);
+              if(patch || !git_hash.empty())
+                {
+                  vstring += "-" + std::to_string(patch);
+                  if(!git_hash.empty())
+                    vstring += "-" + git_hash;
+                }
+            }
+        }
+      return vstring;
+    }
+    bool operator <(const VersionInfo& other) const
+    {
+      return std::tie(mayor_, minor_, release, patch) <
+        std::tie(other.mayor_, other.minor_, other.release, other.patch);
+    }
+    bool operator ==(const VersionInfo& other) const
+    {
+      return mayor_ == other.mayor_ && minor_ == other.minor_ && release == other.release
+        && patch == other.patch;
+    }
+    bool operator !=(const VersionInfo& other) const
+    {
+      return !(*this==other);
+    }
+    bool operator >(const VersionInfo& other) const { return other < (*this); }
+    bool operator <=(const VersionInfo& other) const { return !((*this) > other); }
+    bool operator >=(const VersionInfo& other) const { return !((*this) < other); }
+  };
+
+  inline std::ostream& operator << (std::ostream& ost, const VersionInfo& version)
+  {
+    return ost << version.to_string();
+  }
+
+  NGCORE_API const VersionInfo& GetLibraryVersion(const std::string& library);
+  NGCORE_API const std::map<std::string, VersionInfo>& GetLibraryVersions();
+  NGCORE_API void SetLibraryVersion(const std::string& library, const VersionInfo& version);
+} // namespace ngcore
+
+#endif // NETGEN_CORE_VERSION_HPP

netgen/include/core/xbool.hpp

@@ -0,0 +1,47 @@
+#ifndef NETGEN_CORE_XBOOL_HPP
+#define NETGEN_CORE_XBOOL_HPP
+
+/**************************************************************************/
+/* File:   xbool.hpp                                                      */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   14. Nov. 07                                                    */
+/**************************************************************************/
+
+
+namespace ngcore
+{
+  // an extended bool with values false/maybe/true
+
+  enum TMAYBE { maybe };
+  
+  class xbool
+  {
+    uint8_t state;
+
+  public:
+    xbool (bool b) : state(b ? 2 : 0) { ; }
+    xbool (TMAYBE /* x */) : state(1) { ; }
+    xbool () = default;
+    xbool (const xbool &) = default;
+    
+    xbool & operator= (bool b) { state = b ? 2 : 0; return *this; }
+    xbool & operator= (TMAYBE /* x */) { state = 1; return *this; }
+    
+    bool IsTrue () const { return state == 2; }
+    bool IsMaybe () const { return state == 1; }
+    bool IsFalse () const { return state == 0; }
+    bool IsMaybeTrue() const { return state >= 1; } 
+    bool IsMaybeFalse() const { return state <= 1; } 
+    friend ostream & operator<< (ostream & ost, xbool xb);
+  };
+
+
+  static char output[] = "0?1";
+  inline ostream & operator<< (ostream & ost, xbool xb)
+  {
+    return ost << output[xb.state];
+  }
+  
+} // namespace ngcore
+
+#endif // NETGEN_CORE_XBOOL_HPP