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

netgen/include/linalg/densemat.hpp

@@ -0,0 +1,414 @@
+#ifndef FILE_DENSEMAT
+#define FILE_DENSEMAT
+
+/**************************************************************************/
+/* File:   densemat.hpp                                                    */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Oct. 94                                                    */
+/**************************************************************************/
+
+/** 
+    Data type dense matrix
+*/
+
+#include <mydefs.hpp>
+#include "vector.hpp"
+
+namespace netgen
+{
+class DenseMatrix
+{
+protected:
+  int height;
+  int width;
+  double * data;
+
+public:
+  ///
+  DLL_HEADER DenseMatrix ();
+  ///
+  DLL_HEADER DenseMatrix (int h, int w = 0);
+  ///
+  DLL_HEADER DenseMatrix (const DenseMatrix & m2);
+  ///
+  DLL_HEADER ~DenseMatrix ();
+
+  ///
+  DLL_HEADER void SetSize (int h, int w = 0);
+
+  int Height() const { return height; }
+  int Width() const {return width; }
+
+  double & operator() (int i, int j) { return data[i*width+j]; }
+  double operator() (int i, int j) const { return data[i*width+j]; }
+  double & operator() (int i) { return data[i]; }
+  double operator() (int i) const { return data[i]; }
+
+  ///
+  DLL_HEADER DenseMatrix & operator= (const DenseMatrix & m2);
+  ///
+  DLL_HEADER DenseMatrix & operator+= (const DenseMatrix & m2);
+  ///
+  DLL_HEADER DenseMatrix & operator-= (const DenseMatrix & m2);
+
+  ///
+  DLL_HEADER DenseMatrix & operator= (double v);
+  ///
+  DLL_HEADER DenseMatrix & operator*= (double v);
+
+  ///
+  DLL_HEADER void Mult (const FlatVector & v, FlatVector & prod) const
+  {
+    double sum;
+    const double * mp, * sp;
+    double * dp;
+    
+#ifdef DEBUG
+    if (prod.Size() != height)
+      {
+	(*myerr) << "Mult: wrong vector size " << endl;
+      }
+    if (!height) 
+      {
+	cout << "DenseMatrix::Mult height = 0" << endl;
+      }
+    if (!width) 
+      {
+	cout << "DenseMatrix::Mult width = 0" << endl;
+      }
+    
+    if (width != v.Size())
+      {
+	(*myerr) << "\nMatrix and Vector don't fit" << endl;
+      }
+    else if (Height() != prod.Size())
+      {
+	(*myerr) << "Base_Matrix::operator*(Vector): prod vector not ok" << endl;
+      }
+    else
+#endif
+      {      
+	mp = data;
+	dp = &prod(0);
+        for (int i = 0; i < height; i++)
+	  {
+	    sum = 0;
+	    sp = &v(0);
+	    
+	    for (int j = 0; j < width; j++)
+	      {
+		//        sum += Get(i,j) * v.Get(j);
+		sum += *mp * *sp;
+		mp++;
+		sp++;
+	      }
+	    
+	    *dp = sum;
+	    dp++;
+	  }
+      }
+  }
+
+  ///
+  DLL_HEADER void MultTrans (const Vector & v, Vector & prod) const;
+  ///
+  DLL_HEADER void Residuum (const Vector & x, const Vector & b, Vector & res) const;
+  ///
+  DLL_HEADER double Det () const;
+
+  ///
+  friend DenseMatrix operator* (const DenseMatrix & m1, const DenseMatrix & m2);
+  ///
+  friend DenseMatrix operator+ (const DenseMatrix & m1, const DenseMatrix & m2);
+
+  /// 
+  friend void Transpose (const DenseMatrix & m1, DenseMatrix & m2);
+  ///
+  friend void Mult (const DenseMatrix & m1, const DenseMatrix & m2, DenseMatrix & m3);
+  ///
+//  friend void CalcInverse (const DenseMatrix & m1, DenseMatrix & m2);
+  ///
+  friend void CalcAAt (const DenseMatrix & a, DenseMatrix & m2);
+  ///
+//  friend void CalcAtA (const DenseMatrix & a, DenseMatrix & m2);
+  ///
+  friend void CalcABt (const DenseMatrix & a, const DenseMatrix & b, DenseMatrix & m2);
+  ///
+  friend void CalcAtB (const DenseMatrix & a, const DenseMatrix & b, DenseMatrix & m2);
+  ///
+  DLL_HEADER void Solve (const Vector & b, Vector & x) const;
+  ///
+  void SolveDestroy (const Vector & b, Vector & x);
+  ///
+  const double & Get(int i, int j) const { return data[(i-1)*width+j-1]; }
+  ///
+  const double & Get(int i) const { return data[i-1]; }
+  ///
+  void Set(int i, int j, double v) { data[(i-1)*width+j-1] = v; }
+  ///
+  double & Elem(int i, int j) { return data[(i-1)*width+j-1]; }
+  ///
+  const double & ConstElem(int i, int j) const { return data[(i-1)*width+j-1]; }
+};
+
+
+extern ostream & operator<< (ostream & ost, const DenseMatrix & m);
+
+
+
+template <int WIDTH, typename T = double>
+class MatrixFixWidth
+{
+protected:
+  int height;
+  T * __restrict data;
+  bool ownmem;
+public:
+  ///
+  MatrixFixWidth () 
+  { height = 0; data = 0; ownmem = false; }
+  ///
+  MatrixFixWidth (int h)
+  { height = h; data = new T[WIDTH*height]; ownmem = true; }
+  /// 
+  MatrixFixWidth (int h, T * adata)
+  { height = h; data = adata; ownmem = false; }
+  ///
+  MatrixFixWidth (const MatrixFixWidth & m2)
+    : height(m2.height), ownmem(true)
+  {
+    data = new T[height*WIDTH];
+    for (int i = 0; i < WIDTH*height; i++)
+      data[i] = m2.data[i];
+  }
+  // : height(m2.height), data(m2.data), ownmem(false)
+  //{ ; } 
+  ///
+  ~MatrixFixWidth ()
+  { if (ownmem) delete [] data; }
+
+  void SetSize (int h)
+  {
+    if (h != height)
+      {
+	if (ownmem) delete data;
+	height = h;
+	data = new T[WIDTH*height]; 
+	ownmem = true;
+      }
+  }
+
+  ///
+  int Height() const { return height; }
+
+  ///
+  int Width() const { return WIDTH; }
+  MatrixFixWidth & operator= (const MatrixFixWidth & m2)
+  {
+    for (int i = 0; i < height*WIDTH; i++)
+      data[i] = m2.data[i];
+  }
+  ///
+  MatrixFixWidth & operator= (T v)
+  {
+    for (int i = 0; i < height*WIDTH; i++)
+      data[i] = v; 
+    return *this;
+  }
+
+  /*  
+  ///
+  void Mult (const FlatVector & v, FlatVector & prod) const
+  {
+    T sum;
+    const T * mp, * sp;
+    T * dp;
+
+    mp = data;
+    dp = &prod[0];
+    for (int i = 0; i < height; i++)
+      {
+	sum = 0;
+	sp = &v[0];
+	
+	for (int j = 0; j < WIDTH; j++)
+	  {
+	    sum += *mp * *sp;
+	    mp++;
+	    sp++;
+	  }
+	    
+	*dp = sum;
+	dp++;
+      }
+  }
+  */
+
+  T & operator() (int i, int j)
+  { return data[i*WIDTH+j]; }
+
+  const T & operator() (int i, int j) const
+  { return data[i*WIDTH+j]; }
+
+
+  MatrixFixWidth & operator*= (T v)
+  {
+    if (data)
+      for (int i = 0; i < height*WIDTH; i++)
+        data[i] *= v;
+    return *this;
+  }
+
+
+
+  const T & Get(int i, int j) const { return data[(i-1)*WIDTH+j-1]; }
+  ///
+  const T & Get(int i) const { return data[i-1]; }
+  ///
+  void Set(int i, int j, T v) { data[(i-1)*WIDTH+j-1] = v; }
+  ///
+  T & Elem(int i, int j) { return data[(i-1)*WIDTH+j-1]; }
+  ///
+  const T & ConstElem(int i, int j) const { return data[(i-1)*WIDTH+j-1]; }
+};
+
+
+template <int WIDTH>
+class MatrixFixWidth<WIDTH,double>
+{
+protected:
+  int height;
+  double * data;
+  bool ownmem;
+public:
+  ///
+  MatrixFixWidth () 
+  { height = 0; data = 0; ownmem = false; }
+  ///
+  MatrixFixWidth (int h)
+  { height = h; data = new double[WIDTH*height]; ownmem = true; }
+  
+  MatrixFixWidth (const MatrixFixWidth & m2)
+    : height(m2.height), ownmem(true)
+  {
+    data = new double[height*WIDTH];
+    for (int i = 0; i < WIDTH*height; i++)
+      data[i] = m2.data[i];
+  }
+
+  /// 
+  MatrixFixWidth (int h, double * adata)
+  { height = h; data = adata; ownmem = false; }
+  ///
+  ~MatrixFixWidth ()
+  { if (ownmem) delete [] data; }
+
+  void SetSize (int h)
+  {
+    if (h != height)
+      {
+	if (ownmem) delete data;
+	height = h;
+	data = new double[WIDTH*height]; 
+	ownmem = true;
+      }
+  }
+
+  ///
+  int Height() const { return height; }
+
+  ///
+  int Width() const { return WIDTH; }
+
+  ///
+  MatrixFixWidth & operator= (double v)
+  {
+    for (int i = 0; i < height*WIDTH; i++)
+      data[i] = v; 
+    return *this;
+  }
+
+  ///
+  void Mult (const FlatVector & v, FlatVector & prod) const
+  {
+    double sum;
+    const double * mp, * sp;
+    double * dp;
+
+    /*    
+    if (prod.Size() != height)
+      {
+	cerr << "MatrixFixWidth::Mult: wrong vector size " << endl;
+	assert (1);
+      }
+    */    
+
+    mp = data;
+    dp = &prod[0];
+    for (int i = 0; i < height; i++)
+      {
+	sum = 0;
+	sp = &v[0];
+	
+	for (int j = 0; j < WIDTH; j++)
+	  {
+	    sum += *mp * *sp;
+	    mp++;
+	    sp++;
+	  }
+	    
+	*dp = sum;
+	dp++;
+      }
+  }
+
+  double & operator() (int i, int j)
+  { return data[i*WIDTH+j]; }
+
+  const double & operator() (int i, int j) const
+  { return data[i*WIDTH+j]; }
+
+
+  MatrixFixWidth & operator*= (double v)
+  {
+    if (data)
+      for (int i = 0; i < height*WIDTH; i++)
+        data[i] *= v;
+    return *this;
+  }
+
+
+
+  const double & Get(int i, int j) const { return data[(i-1)*WIDTH+j-1]; }
+  ///
+  const double & Get(int i) const { return data[i-1]; }
+  ///
+  void Set(int i, int j, double v) { data[(i-1)*WIDTH+j-1] = v; }
+  ///
+  double & Elem(int i, int j) { return data[(i-1)*WIDTH+j-1]; }
+  ///
+  const double & ConstElem(int i, int j) const { return data[(i-1)*WIDTH+j-1]; }
+};
+
+
+
+
+
+template <int WIDTH>
+extern ostream & operator<< (ostream & ost, const MatrixFixWidth<WIDTH> & m)
+{
+  for (int i = 0; i < m.Height(); i++)
+    {
+      for (int j = 0; j < m.Width(); j++)
+	ost << m.Get(i+1,j+1) << " ";
+      ost << endl;
+    }
+  return ost;
+};
+
+
+extern DLL_HEADER void CalcAtA (const DenseMatrix & a, DenseMatrix & m2);
+extern DLL_HEADER void CalcInverse (const DenseMatrix & m1, DenseMatrix & m2);
+
+} // namespace netgen
+#endif

netgen/include/linalg/linalg.hpp

@@ -0,0 +1,29 @@
+#ifndef FILE_LINALG
+#define FILE_LINALG
+
+/* *************************************************************************/
+/* File:   linalg.hpp                                                      */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Oct. 94                                                    */
+/* *************************************************************************/
+
+/* 
+
+   Data types for basic linear algebra
+   
+   The basic concepts include the data types 
+   
+    Vector
+    SparseMatrix
+    DenseMatrix
+
+*/
+
+
+#include "../include/myadt.hpp"
+#include "vector.hpp"
+#include "densemat.hpp"
+#include "polynomial.hpp"
+#endif
+
+

netgen/include/linalg/opti.hpp

@@ -0,0 +1,142 @@
+#ifndef FILE_OPTI
+#define FILE_OPTI
+
+/**************************************************************************/
+/* File:   opti.hpp                                                       */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   01. Jun. 95                                                    */
+/**************************************************************************/
+
+
+
+namespace netgen
+{
+
+  /** 
+      Function to be minimized.
+  */
+  class MinFunction 
+  {
+  public:
+    ///
+    virtual double Func (const Vector & x) const;
+    ///
+    virtual void Grad (const Vector & x, Vector & g) const;
+    /// function and gradient
+    virtual double FuncGrad (const Vector & x, Vector & g) const;
+    /// directional derivative
+    virtual double FuncDeriv (const Vector & x, const Vector & dir, double & deriv) const;
+    /// if |g| < gradaccuray, then stop bfgs
+    virtual double GradStopping (const Vector & /* x */) const { return 0; } 
+
+    ///
+    virtual void ApproximateHesse (const Vector & /* x */,
+				   DenseMatrix & /* hesse */) const;
+  };
+
+
+  class OptiParameters
+  {
+  public:
+    int maxit_linsearch;
+    int maxit_bfgs;
+    double typf;
+    double typx;
+
+    OptiParameters ()
+    {
+      maxit_linsearch = 100;
+      maxit_bfgs = 100;
+      typf = 1;
+      typx = 1;
+    }
+  };
+  
+  
+  /** Implementation of BFGS method.
+      Efficient method for non-linear minimiztion problems.
+      @param x initial value and solution 
+      @param fun function to be minimized
+  */
+  extern double BFGS (Vector & x, const MinFunction & fun, 
+		      const OptiParameters & par,
+		      double eps = 1e-8);
+
+  /** Steepest descent method.
+      Simple method for non-linear minimization problems.
+      @param x initial value and solution 
+      @param fun function to be minimized
+  */
+  void SteepestDescent (Vector & x, const MinFunction & fun,
+			const OptiParameters &  par);
+
+
+  extern void lines (
+		     Vector & x,         // i: Ausgangspunkt der Liniensuche
+		     Vector & xneu,      // o: Loesung der Liniensuche bei Erfolg
+		     Vector & p,         // i: Suchrichtung
+		     double & f,         // i: Funktionswert an der Stelle x
+		     // o: Funktionswert an der Stelle xneu, falls ifail = 0
+		     Vector & g,         // i: Gradient an der Stelle x
+		     // o: Gradient an der Stelle xneu, falls ifail = 0
+
+		     const MinFunction & fun,  // function to minmize
+		     const OptiParameters & par, // parameters
+		     double & alphahat,  // i: Startwert f�r alpha_hat
+		     // o: Loesung falls ifail = 0
+		     double fmin,        // i: untere Schranke f�r f
+		     double mu1,         // i: Parameter mu_1 aus Alg.2.1
+		     double sigma,       // i: Parameter sigma aus Alg.2.1
+		     double xi1,         // i: Parameter xi_1 aus Alg.2.1
+		     double xi2,         // i: Parameter xi_1 aus Alg.2.1
+		     double tau,         // i: Parameter tau aus Alg.2.1
+		     double tau1,        // i: Parameter tau_1 aus Alg.2.1
+		     double tau2,        // i: Parameter tau_2 aus Alg.2.1
+		     int & ifail);        // o:  0 bei erfolgreicher Liniensuche
+  //    -1 bei Abbruch wegen Unterschreiten von fmin
+  //    1 bei Abbruch, aus sonstigen Gr�nden
+
+
+
+
+  /**  
+       Solver for linear programming problem.
+
+       \begin{verbatim}
+       min      c^t x
+       A x <= b    
+       \end{verbatim}
+  */
+  extern void LinearOptimize (const DenseMatrix & a, const Vector & b, 
+			      const Vector & c, Vector & x);
+
+
+#ifdef NONE
+
+  /**
+     Simple projection iteration.
+  
+     find $u = argmin_{v >= 0}  0.5 u A u - f u$
+  */
+  extern void ApproxProject (const BaseMatrix & a, Vector & u, 
+			     const Vector & f,
+			     double tau, int its);
+ 
+
+  /**
+     CG Algorithm for quadratic programming problem.
+     See: Dostal ...
+
+     d ... diag(A) ^{-1}
+  */
+  extern void ApproxProjectCG (const BaseMatrix & a, Vector & x, 
+			       const Vector & b, const class DiagMatrix & d,
+			       double gamma, int & steps, int & changes);
+
+#endif
+
+
+}
+
+#endif
+

netgen/include/linalg/polynomial.hpp

@@ -0,0 +1,47 @@
+#ifndef FILE_POLYNOMIAL
+#define FILE_POLYNOMIAL
+
+/* *************************************************************************/
+/* File:   polynomial.hh                                                   */
+/* Author: Joachim Schoeberl                                               */
+/* Date:   25. Nov. 99                                                     */
+/* *************************************************************************/
+
+namespace netgen
+{
+
+class QuadraticPolynomial1V 
+{
+  double c, cx, cxx;
+public:
+  QuadraticPolynomial1V (double ac, double acx, double acxx);
+  double Value (double x);
+  double MaxUnitInterval ();
+};
+
+class LinearPolynomial2V
+{
+  double c, cx, cy;
+public:
+  LinearPolynomial2V (double ac, double acx, double acy);
+  friend class QuadraticPolynomial2V;
+};
+
+
+class QuadraticPolynomial2V
+{
+  double c, cx, cy, cxx, cxy, cyy;
+public:
+  QuadraticPolynomial2V ();
+  QuadraticPolynomial2V (double ac, double acx, double acy,
+			 double acxx, double acxy, double acyy);
+  void Square (const LinearPolynomial2V & lp);
+  void Add (double lam, const QuadraticPolynomial2V & qp);
+
+  double Value (double x, double y);
+  //  double MinUnitSquare ();
+  double MaxUnitSquare ();
+  double MaxUnitTriangle ();
+};
+} // namespace netgen
+#endif