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

netgen/include/general/ngbitarray.hpp

@@ -0,0 +1,149 @@
+#ifndef FILE_BitArray
+#define FILE_BitArray
+
+/**************************************************************************/
+/* File:   bitarray.hpp                                                   */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Jun. 95                                                    */
+/**************************************************************************/
+
+#include <limits.h>
+
+namespace netgen
+{
+
+/**
+   data type NgBitArray
+   
+   NgBitArray is a compressed array of Boolean information. By Set and Clear
+   the whole array or one bit can be set or reset, respectively. 
+   Test returns the state of the occurring bit.
+   No range checking is done.
+
+   index ranges from 0 to size-1
+*/
+class NgBitArray
+{
+  INDEX size;
+  unsigned char * data;
+
+public:
+  
+  // [[ deprecated ("use BitArray instead")]]  
+  DLL_HEADER NgBitArray ();
+  ///
+  // [[ deprecated ("use BitArray instead")]]  
+  DLL_HEADER NgBitArray (INDEX asize);
+  ///
+  DLL_HEADER ~NgBitArray ();
+
+  /// 
+  DLL_HEADER void SetSize (INDEX asize);
+  ///
+  INDEX Size () const
+  {
+    return size;
+  }
+
+  ///
+  DLL_HEADER void Set ();
+  ///
+  void Set (INDEX i)
+  {
+    data[Addr(i)] |= Mask(i);
+  }
+  
+  DLL_HEADER void Clear ();
+
+
+  void Clear (INDEX i)
+  {
+    data[Addr(i)] &= ~Mask(i);
+  }
+
+  bool Test (INDEX i) const
+  {
+    return (data[i / CHAR_BIT] & (char(1) << (i % CHAR_BIT) ) ) ? true : false;
+  }
+
+  ///
+  void Invert ();
+  ///
+  void And (const NgBitArray & ba2);
+  ///
+  void Or (const NgBitArray & ba2);
+private:
+  ///
+  inline unsigned char Mask (INDEX i) const
+  {
+    return char(1) << (i % CHAR_BIT);
+  }
+  ///
+  inline INDEX Addr (INDEX i) const
+  {
+  return (i / CHAR_BIT);
+  }
+
+  ///
+  NgBitArray & operator= (NgBitArray &);
+  ///
+  NgBitArray (const NgBitArray &);
+};
+
+
+
+// print bitarray
+inline ostream & operator<< (ostream & s, const NgBitArray & a)
+{
+  for (int i = 1; i <= a.Size(); i++)
+    {
+      s << int (a.Test(i));
+      if (i % 40 == 0) s << "\n";
+    }
+  if (a.Size() % 40 != 0) s << "\n";
+  return s;
+}
+
+
+/*
+inline
+INDEX NgBitArray :: Size () const
+  {
+  return size;
+  }
+
+inline
+unsigned char NgBitArray :: Mask (INDEX i) const
+  {
+  return char(1) << (i % CHAR_BIT);
+  }
+
+inline
+INDEX NgBitArray :: Addr (INDEX i) const
+  {
+  return (i / CHAR_BIT);
+  }
+inline
+void NgBitArray :: Set (INDEX i)
+  {
+  data[Addr(i)] |= Mask(i);
+  }
+
+inline
+void NgBitArray :: Clear (INDEX i)
+  {
+  data[Addr(i)] &= ~Mask(i);
+  }
+
+
+inline
+int NgBitArray :: Test (INDEX i) const
+  {
+  return (data[i / CHAR_BIT] & (char(1) << (i % CHAR_BIT) ) ) ? 1 : 0;
+  }
+
+*/
+
+}
+
+#endif

netgen/include/general/ngpython.hpp

@@ -0,0 +1,74 @@
+#ifdef NG_PYTHON
+
+#include <core/python_ngcore.hpp>
+
+#include <pybind11/operators.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+#include <iostream>
+#include <sstream>
+
+// using namespace ngcore;
+
+template <typename T>
+py::array MoveToNumpy(std::vector<T>& vec)
+{
+  auto newvec = new std::vector<T>();
+  std::swap(*newvec, vec);
+  auto capsule = py::capsule(newvec, [](void *v) { delete reinterpret_cast<std::vector<T>*>(v); });
+  return py::array(newvec->size(), newvec->data(), capsule);
+}
+
+namespace PYBIND11_NAMESPACE {
+template<typename T>
+bool CheckCast( py::handle obj ) {
+  try{
+    obj.cast<T>();
+    return true;
+  }
+  catch (py::cast_error &e) {
+    return false;
+  }
+}
+
+
+template <typename T>
+struct extract
+{
+  py::handle obj;
+  extract( py::handle aobj ) : obj(aobj) {}
+
+  bool check() { return CheckCast<T>(obj); }
+  T operator()() { return obj.cast<T>(); }
+};
+}
+
+struct NGDummyArgument {};
+
+inline void NOOP_Deleter(void *) { ; }
+
+namespace netgen
+{
+
+  //////////////////////////////////////////////////////////////////////
+  // Lambda to function pointer conversion
+  template <typename Function>
+  struct function_traits
+    : public function_traits<decltype(&Function::operator())> {};
+
+  template <typename ClassType, typename ReturnType, typename... Args>
+  struct function_traits<ReturnType(ClassType::*)(Args...) const> {
+    typedef ReturnType (*pointer)(Args...);
+    typedef ReturnType return_type;
+  };
+
+  template <typename Function>
+  typename function_traits<Function>::pointer
+  FunctionPointer (const Function& lambda) {
+    return static_cast<typename function_traits<Function>::pointer>(lambda);
+  }
+
+} // namespace netgen
+
+#endif
+

netgen/include/general/optmem.hpp

@@ -0,0 +1,44 @@
+#ifndef FILE_OPTMEM
+#define FILE_OPTMEM
+
+/**************************************************************************/
+/* File:   optmem.hh                                                      */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   04. Apr. 97                                                    */
+/**************************************************************************/
+
+#include <mydefs.hpp>
+
+#include "ngarray.hpp"
+
+namespace netgen
+{
+
+/** 
+    Optimized Memory allocation classes
+*/
+
+class BlockAllocator
+{
+private:
+  ///
+  unsigned size, blocks;
+  ///
+  void * freelist;
+  ///
+  NgArray<char*> bablocks;
+  mutex block_allocator_mutex;
+public:
+  ///
+  DLL_HEADER BlockAllocator (unsigned asize, unsigned ablocks = 100);
+  ///
+  DLL_HEADER ~BlockAllocator ();
+  ///
+  DLL_HEADER void * Alloc ();
+  ///
+  DLL_HEADER void Free (void * p);
+};
+
+}
+
+#endif

netgen/include/general/parthreads.hpp

@@ -0,0 +1,138 @@
+#ifndef FILE_PARTHREADS
+#define FILE_PARTHREADS
+
+/**************************************************************************/
+/* File:   parthreads.hh                                                  */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   22. Nov. 2000                                                  */
+/**************************************************************************/
+
+/*
+  Parallel thread, Mutex,
+*/
+#include <functional>
+
+namespace netgen
+{
+
+#ifdef NO_PARALLEL_THREADS
+
+class NgMutex { };
+
+class NgLock
+{
+public:
+  NgLock (NgMutex & mut, bool lock = 0) { ; }
+  void Lock () { ; }
+  void UnLock () { ; }
+};
+
+#else
+
+typedef std::mutex NgMutex;
+
+class NgLock
+{
+  NgMutex & mut;
+  bool locked;
+public:
+  NgLock (NgMutex & ngmut, bool lock = false)
+    : mut (ngmut)
+  {
+    if (lock)
+      mut.lock();
+
+    locked = lock;
+  };
+
+  ~NgLock()
+  {
+    if (locked)
+      mut.unlock();
+  }
+
+  void Lock ()
+  {
+    mut.lock();
+    locked = true;
+  }
+  void UnLock ()
+  {
+    mut.unlock();
+    locked = false;
+  }
+  /*
+  int TryLock ()
+  {
+    return mut.try_lock();
+  }
+  */
+};
+
+
+#endif
+
+
+// Simple ParallelFor function to replace OpenMP
+template<typename TFunc>
+void ParallelFor( int first, int next, const TFunc & f )
+{
+  int nthreads = std::thread::hardware_concurrency();
+  std::thread * threads = new std::thread[nthreads];
+  for (int i=0; i<nthreads; i++)
+    {
+      int myfirst = first + (next-first)*i/nthreads;
+      int mynext = first + (next-first)*(i+1)/nthreads;
+      threads[i] = std::thread( [myfirst,mynext,&f] ()
+        {
+          f(myfirst, mynext);
+        });
+    }
+
+  for (int i=0; i<nthreads; i++)
+    threads[i].join();
+  delete [] threads;
+}
+
+
+  
+  typedef void (*NgTaskManager)(std::function<void(int,int)>);
+  typedef void (*NgTracer)(std::string, bool);  // false .. start, true .. stop
+
+  inline void DummyTaskManager (std::function<void(int,int)> func)
+  {
+    func(0,2);
+    func(1,2);
+  }
+
+  inline void DummyTracer (std::string, bool) { ; }
+  
+  template <typename FUNC>
+  inline void ParallelFor (NgTaskManager tm, size_t n, FUNC func)
+  {
+    (*tm) ([n,func] (size_t nr, size_t nums)
+           {
+             size_t begin = nr*n / nums;
+             size_t end = (nr+1)*n / nums;
+
+             for (size_t i = begin; i < end; i++)
+               func(i);
+           });
+  }
+  
+  template <typename FUNC>
+  inline void ParallelForRange (NgTaskManager tm, size_t n, FUNC func)
+  {
+    (*tm) ([n,func] (size_t nr, size_t nums)
+           {
+             size_t begin = nr*n / nums;
+             size_t end = (nr+1)*n / nums;
+             func(begin, end);
+           });
+  }
+                    
+
+  
+}
+
+#endif

netgen/include/general/seti.hpp

@@ -0,0 +1,50 @@
+#ifndef FILE_SETI
+#define FILE_SETI
+
+
+/**************************************************************************/
+/* File:   seti.hh                                                        */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   20. Mar. 98                                                    */
+/**************************************************************************/
+
+namespace netgen
+{
+
+/**
+  Set of Integers
+  */
+class IndexSet
+{
+  NgArray<int> set;
+  NgBitArray flags;
+public:
+  IndexSet (int maxind);
+  
+  ~IndexSet ();
+  /// increase range to maxind
+  void SetMaxIndex (int maxind);
+  int IsIn (int ind) const
+  { 
+    return flags.Test (ind); 
+  }
+
+  void Add (int ind)
+  {
+    if (!flags.Test(ind))
+      {
+	set.Append (ind);
+	flags.Set (ind);
+      }
+  }
+
+  void Del (int ind);
+  void Clear ();
+  
+  const NgArray<int> & GetArray() { return set; }
+};
+
+}
+
+#endif
+

netgen/include/general/sort.hpp

@@ -0,0 +1,47 @@
+#ifndef FILE_SORT
+#define FILE_SORT
+
+/**************************************************************************/
+/* File:   sort.hh                                                        */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   07. Jan. 00                                                    */
+/**************************************************************************/
+
+namespace netgen
+{
+
+// order(i) is sorted index of element i
+extern void Sort (const NgArray<double> & values,
+		  NgArray<int> & order);
+
+extern void QuickSort (const NgArray<double> & values,
+		      NgArray<int> & order);
+
+
+
+
+template <class T>
+inline void BubbleSort (int size, T * data)
+{
+  T hv;
+  for (int i = 0; i < size; i++)
+    for (int j = i+1; j < size; j++)
+      if (data[i] > data[j])
+	{
+	  hv = data[i];
+	  data[i] = data[j];
+	  data[j] = hv;
+	}
+}
+
+template <class T>
+inline void BubbleSort (NgArray<T> & data)
+{
+  if(data.Size() > 0)
+    // BubbleSort (data.Size(), &data[data.Begin()]);
+    BubbleSort (data.Size(), &data[*data.Range().begin()]);
+}
+
+}
+
+#endif

netgen/include/general/spbita2d.hpp

@@ -0,0 +1,59 @@
+#ifndef FILE_SPBITA2D
+#define FILE_SPBITA2D
+
+/**************************************************************************/
+/* File:   spbita2d.hh                                                    */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Jun. 95                                                    */
+/**************************************************************************/
+
+/** 
+   Implementation of sparse 2 dimensional bitarray
+*/
+
+namespace netgen
+{
+
+class SPARSE_BIT_Array_2D
+  {
+  class linestruct { public: INDEX size; INDEX maxsize; INDEX * col; };
+
+  ///
+  linestruct * lines;
+  ///
+  INDEX height, width;
+
+  public:
+
+  ///
+  SPARSE_BIT_Array_2D (INDEX ah = 0, INDEX aw = 0);
+  ///
+  ~SPARSE_BIT_Array_2D ();
+
+  ///
+  void SetSize (INDEX ah, INDEX aw = 0);
+  ///
+  void DeleteElements ();
+
+  ///
+  int Get (INDEX i, INDEX j) const;
+
+  ///
+  INDEX Height () const { return height; }
+  ///
+  INDEX Width () const { return width; }
+
+  ///
+  void Set (INDEX i, INDEX j);
+  ///
+  int Test (INDEX i, INDEX j) const;
+
+  ///
+  INDEX BitsInLine (INDEX i) const { return lines[i-1].size; }
+  ///
+  INDEX GetIndex (INDEX i, INDEX nr) const { return lines[i-1].col[nr-1]; }
+  };
+
+}
+
+#endif

netgen/include/general/stack.hpp

@@ -0,0 +1,114 @@
+#ifndef FILE_STACK
+#define FILE_STACK
+
+/*****************************************************************************/
+/*  File: stack.hh                                                           */
+/*  Author: Wolfram Muehlhuber                                               */
+/*  Date: September 98                                                       */
+/*****************************************************************************/
+
+/*
+  
+  Stack class, based on a resizable array
+
+ */
+
+
+// #include "array.hpp"
+
+namespace netgen
+{
+
+///
+template <class T> class STACK
+{
+public:
+  ///
+  inline STACK (INDEX asize = 0, INDEX ainc = 0);
+  ///
+  inline ~STACK ();
+
+  ///
+  inline void Push (const T & el);
+  ///
+  inline T & Pop ();
+  ///
+  const inline T & Top () const;
+  ///
+  inline int IsEmpty () const;
+  ///
+  inline void MakeEmpty ();
+
+private:
+  ///
+  NgArray<T> elems;
+  ///
+  INDEX size;
+};
+
+
+
+
+/*
+  
+  Stack class, based on a resizable array
+
+ */
+
+template <class T>
+inline STACK<T> :: STACK (INDEX asize, INDEX ainc)
+  : elems(asize, ainc)
+{
+  size = 0;
+}
+
+
+template <class T>
+inline STACK<T> :: ~STACK ()
+{
+  ;
+}
+
+
+template <class T> 
+inline void STACK<T> :: Push (const T & el)
+{
+  if (size < elems.Size())
+    elems.Elem(++size) = el;
+  else
+    {
+      elems.Append(el);
+      size++;
+    }
+}
+
+
+template <class T> 
+inline T & STACK<T> :: Pop ()
+{
+  return elems.Elem(size--);
+}
+
+
+template <class T>
+const inline T & STACK<T> :: Top () const
+{
+  return elems.Get(size);
+}
+
+template <class T>
+inline int STACK<T> :: IsEmpty () const
+{
+  return (size == 0);
+}
+
+
+template <class T>
+inline void STACK<T> :: MakeEmpty ()
+{
+  size = 0;
+}
+
+}
+
+#endif