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

netgen/include/general/autodiff.hpp

@@ -0,0 +1,356 @@
+#ifndef FILE_AUTODIFF
+#define FILE_AUTODIFF
+
+/**************************************************************************/
+/* File:   autodiff.hpp                                                   */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   24. Oct. 02                                                    */
+/**************************************************************************/
+
+// Automatic differentiation datatype
+
+namespace netgen
+{
+
+/**
+   Datatype for automatic differentiation.
+   Contains function value and D derivatives. Algebraic
+   operations are overloaded by using product-rule etc. etc. 
+**/
+template <int D, typename SCAL = double>
+class AutoDiff
+{
+  SCAL val;
+  SCAL dval[D];
+public:
+
+  typedef AutoDiff<D,SCAL> TELEM;
+  typedef SCAL TSCAL;
+
+
+  /// elements are undefined
+  AutoDiff  () throw() { }; 
+  // { val = 0; for (int i = 0; i < D; i++) dval[i] = 0; }  // !
+
+  /// copy constructor
+  AutoDiff  (const AutoDiff & ad2) throw()
+  {
+    val = ad2.val;
+    for (int i = 0; i < D; i++)
+      dval[i] = ad2.dval[i];
+  }
+
+  /// initial object with constant value
+  AutoDiff  (SCAL aval) throw()
+  {
+    val = aval;
+    for (int i = 0; i < D; i++)
+      dval[i] = 0;
+  }
+
+  /// init object with (val, e_diffindex)
+  AutoDiff  (SCAL aval, int diffindex)  throw()
+  {
+    val = aval;
+    for (int i = 0; i < D; i++)
+      dval[i] = 0;
+    dval[diffindex] = 1;
+  }
+
+  /// assign constant value
+  AutoDiff & operator= (SCAL aval) throw()
+  {
+    val = aval;
+    for (int i = 0; i < D; i++)
+      dval[i] = 0;
+    return *this;
+  }
+
+  /// returns value
+  SCAL Value() const throw() { return val; }
+
+  /// returns partial derivative
+  SCAL DValue (int i) const throw() { return dval[i]; }
+
+  /// access value
+  SCAL & Value() throw() { return val; }
+
+  /// accesses partial derivative 
+  SCAL & DValue (int i) throw() { return dval[i]; }
+
+  /// 
+  AutoDiff<D,SCAL> & operator+= (const AutoDiff<D,SCAL> & y) throw()
+  {
+    val += y.val;
+    for (int i = 0; i < D; i++)
+      dval[i] += y.dval[i];
+    return *this;
+  }
+
+  ///
+  AutoDiff<D,SCAL> & operator-= (const AutoDiff<D,SCAL> & y) throw()
+  {
+    val -= y.val;
+    for (int i = 0; i < D; i++)
+      dval[i] -= y.dval[i];
+    return *this;
+
+  }
+
+  ///
+  AutoDiff<D,SCAL> & operator*= (const AutoDiff<D,SCAL> & y) throw()
+  {
+    for (int i = 0; i < D; i++)
+      {
+	// dval[i] *= y.val;
+	// dval[i] += val * y.dval[i];
+        dval[i] = dval[i] * y.val + val * y.dval[i];
+      }
+    val *= y.val;
+    return *this;
+  }
+
+  ///
+  AutoDiff<D,SCAL> & operator*= (const SCAL & y) throw()
+  {
+    val *= y;
+    for (int i = 0; i < D; i++)
+      dval[i] *= y;
+    return *this;
+  }
+
+  ///
+  AutoDiff<D,SCAL> & operator/= (const SCAL & y) throw()
+  {
+    SCAL iy = 1.0 / y;
+    val *= iy;
+    for (int i = 0; i < D; i++)
+      dval[i] *= iy;
+    return *this;
+  }
+
+  /// 
+  bool operator== (SCAL val2) throw()
+  {
+    return val == val2;
+  }
+
+  ///
+  bool operator!= (SCAL val2) throw()
+  {
+    return val != val2;
+  }
+
+  ///
+  bool operator< (SCAL val2) throw()
+  {
+    return val < val2;
+  }
+  
+  ///
+  bool operator> (SCAL val2) throw()
+  {
+    return val > val2;
+  }
+};
+
+
+//@{  AutoDiff helper functions.
+
+/// prints AutoDiff
+template<int D, typename SCAL>
+inline ostream & operator<< (ostream & ost, const AutoDiff<D,SCAL> & x)
+{
+  ost << x.Value() << ", D = ";
+  for (int i = 0; i < D; i++)
+    ost << x.DValue(i) << " ";
+  return ost;
+}
+
+/// AutoDiff plus AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator+ (const AutoDiff<D,SCAL> & x, const AutoDiff<D,SCAL> & y) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value () = x.Value()+y.Value();
+  // AutoDiff<D,SCAL> res(x.Value()+y.Value());
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = x.DValue(i) + y.DValue(i);
+  return res;
+}
+
+
+/// AutoDiff minus AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator- (const AutoDiff<D,SCAL> & x, const AutoDiff<D,SCAL> & y) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = x.Value()-y.Value();
+  // AutoDiff<D,SCAL> res (x.Value()-y.Value());
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = x.DValue(i) - y.DValue(i);
+  return res;
+}
+
+/// double plus AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator+ (double x, const AutoDiff<D,SCAL> & y) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = x+y.Value();
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = y.DValue(i);
+  return res;
+}
+
+/// AutoDiff plus double
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator+ (const AutoDiff<D,SCAL> & y, double x) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = x+y.Value();
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = y.DValue(i);
+  return res;
+}
+
+
+/// minus AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator- (const AutoDiff<D,SCAL> & x) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = -x.Value();
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = -x.DValue(i);
+  return res;
+}
+
+/// AutoDiff minus double
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator- (const AutoDiff<D,SCAL> & x, double y) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = x.Value()-y;
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = x.DValue(i);
+  return res;
+}
+
+///
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator- (double x, const AutoDiff<D,SCAL> & y) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = x-y.Value();
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = -y.DValue(i);
+  return res;
+}
+
+
+/// double times AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator* (double x, const AutoDiff<D,SCAL> & y) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = x*y.Value();
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = x*y.DValue(i);
+  return res;
+}
+
+/// AutoDiff times double
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator* (const AutoDiff<D,SCAL> & y, double x) throw()
+{
+  AutoDiff<D,SCAL> res;
+  res.Value() = x*y.Value();
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = x*y.DValue(i);
+  return res;
+}
+
+/// AutoDiff times AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator* (const AutoDiff<D,SCAL> & x, const AutoDiff<D,SCAL> & y) throw()
+{
+  AutoDiff<D,SCAL> res;
+  SCAL hx = x.Value();
+  SCAL hy = y.Value();
+
+  res.Value() = hx*hy;
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = hx*y.DValue(i) + hy*x.DValue(i);
+
+  return res;
+}
+
+
+/// Inverse of AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> Inv (const AutoDiff<D,SCAL> & x)
+{
+  AutoDiff<D,SCAL> res(1.0 / x.Value());
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = -x.DValue(i) / (x.Value() * x.Value());
+  return res;
+}
+
+
+/// AutoDiff div AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator/ (const AutoDiff<D,SCAL> & x, const AutoDiff<D,SCAL> & y)
+{
+  return x * Inv (y);
+}
+
+/// AutoDiff div double
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator/ (const AutoDiff<D,SCAL> & x, double y)
+{
+  return (1/y) * x;
+}
+
+/// double div AutoDiff
+template<int D, typename SCAL>
+inline AutoDiff<D,SCAL> operator/ (double x, const AutoDiff<D,SCAL> & y)
+{
+  return x * Inv(y);
+}
+
+} // namespace netgen
+
+namespace ngcore
+{
+/// AutoDiff times AutoDiff
+template<int D, typename SCAL>
+inline netgen::AutoDiff<D,SCAL> sqr (const netgen::AutoDiff<D,SCAL> & x) throw()
+{
+  netgen::AutoDiff<D,SCAL> res;
+  SCAL hx = x.Value();
+  res.Value() = hx*hx;
+  hx *= 2;
+  for (int i = 0; i < D; i++)
+    res.DValue(i) = hx*x.DValue(i);
+  return res;
+}
+} // namespace ngcore
+
+namespace std
+{
+template<int D, typename SCAL>
+inline netgen::AutoDiff<D,SCAL> fabs (const netgen::AutoDiff<D,SCAL> & x)
+{
+  double abs = fabs (x.Value());
+  netgen::AutoDiff<D,SCAL> res( abs );
+  if (abs != 0.0)
+    for (int i = 0; i < D; i++)
+      res.DValue(i) = x.DValue(i) / abs;
+  else
+    for (int i = 0; i < D; i++)
+      res.DValue(i) = 0.0;
+  return res;
+}
+} // namespace std
+#endif

netgen/include/general/autoptr.hpp

@@ -0,0 +1,39 @@
+braucht man nicht mehr
+
+#ifndef FILE_AUTOPTR
+#define FILE_AUTOPTR
+
+/**************************************************************************/
+/* File:   autoptr.hpp                                                    */
+/* Author: STL, Joachim Schoeberl                                         */
+/* Date:   29. Dec. 02                                                    */
+/**************************************************************************/
+
+namespace netgen
+{
+
+  /*
+template <typename T>
+class AutoPtr
+{
+private:
+  T * ptr;
+public:
+  typedef T* pT;
+  explicit AutoPtr (T * p = 0)  { ptr = p; }
+  ~AutoPtr () { delete ptr; }
+  
+  T & operator*() const { return *ptr; }
+  T* operator->() const { return ptr; }
+  T *& Ptr() { return ptr; }
+  T * Ptr() const { return ptr; }
+  void Reset(T * p = 0) { if (p != ptr) { delete ptr; ptr = p; } }
+  operator bool () { return ptr != 0; }
+private:
+  AutoPtr (AutoPtr &) { ; }
+  AutoPtr & operator= (AutoPtr &) { ; }
+};
+  */
+}
+
+#endif

netgen/include/general/gzstream.h

@@ -0,0 +1,121 @@
+// ============================================================================
+// gzstream, C++ iostream classes wrapping the zlib compression library.
+// Copyright (C) 2001  Deepak Bandyopadhyay, Lutz Kettner
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library 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
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+// ============================================================================
+//
+// File          : gzstream.h
+// Revision      : $Revision: 1.5 $
+// Revision_date : $Date: 2002/04/26 23:30:15 $
+// Author(s)     : Deepak Bandyopadhyay, Lutz Kettner
+// 
+// Standard streambuf implementation following Nicolai Josuttis, "The 
+// Standard C++ Library".
+// ============================================================================
+
+#ifndef GZSTREAM_H
+#define GZSTREAM_H 1
+
+// standard C++ with new header file names and std:: namespace
+#include <iostream>
+#include <fstream>
+#include <zlib.h>
+
+#ifdef GZSTREAM_NAMESPACE
+namespace GZSTREAM_NAMESPACE {
+#endif
+
+// ----------------------------------------------------------------------------
+// Internal classes to implement gzstream. See below for user classes.
+// ----------------------------------------------------------------------------
+
+class gzstreambuf : public std::streambuf {
+private:
+    static const int bufferSize = 47+256;    // size of data buff
+    // totals 512 bytes under g++ for igzstream at the end.
+
+    gzFile           file;               // file handle for compressed file
+    char             buffer[bufferSize]; // data buffer
+    char             opened;             // open/close state of stream
+    int              mode;               // I/O mode
+
+    int flush_buffer();
+public:
+    gzstreambuf() : opened(0) {
+        setp( buffer, buffer + (bufferSize-1));
+        setg( buffer + 4,     // beginning of putback area
+              buffer + 4,     // read position
+              buffer + 4);    // end position      
+        // ASSERT: both input & output capabilities will not be used together
+    }
+    int is_open() { return opened; }
+    gzstreambuf* open( const std::filesystem::path & name, int open_mode);
+    gzstreambuf* close();
+    ~gzstreambuf() { close(); }
+    
+    virtual int     overflow( int c = EOF);
+    virtual int     underflow();
+    virtual int     sync();
+};
+
+class DLL_HEADER gzstreambase : virtual public std::ios {
+protected:
+    gzstreambuf buf;
+public:
+    gzstreambase() { init(&buf); }
+    gzstreambase( const std::filesystem::path & name, int open_mode);
+    ~gzstreambase();
+    void open( const std::filesystem::path & name, int open_mode);
+    void close();
+    gzstreambuf* rdbuf() { return &buf; }
+};
+
+// ----------------------------------------------------------------------------
+// User classes. Use igzstream and ogzstream analogously to ifstream and
+// ofstream respectively. They read and write files based on the gz* 
+// function interface of the zlib. Files are compatible with gzip compression.
+// ----------------------------------------------------------------------------
+
+class DLL_HEADER igzstream : public gzstreambase, public std::istream {
+public:
+    igzstream() : std::istream( &buf) {} 
+    igzstream( const std::filesystem::path & name, int open_mode = std::ios::in)
+        : gzstreambase( name, open_mode), std::istream( &buf) {}  
+    gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); }
+    void open( const std::filesystem::path & name, int open_mode = std::ios::in) {
+        gzstreambase::open( name, open_mode);
+    }
+};
+
+class DLL_HEADER ogzstream : public gzstreambase, public std::ostream {
+public:
+    ogzstream() : std::ostream( &buf) {}
+    ogzstream( const std::filesystem::path & name, int mode = std::ios::out)
+        : gzstreambase( name, mode), std::ostream( &buf) {}  
+    gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); }
+    void open( const std::filesystem::path & name, int open_mode = std::ios::out) {
+        gzstreambase::open( name, open_mode);
+    }
+};
+
+#ifdef GZSTREAM_NAMESPACE
+} // namespace GZSTREAM_NAMESPACE
+#endif
+
+#endif // GZSTREAM_H
+// ============================================================================
+// EOF //
+