ngsolve 6.2.2506.post74.dev0__cp314-cp314-macosx_10_15_universal2.whl

netgen/include/bla.hpp

@@ -0,0 +1,29 @@
+#ifndef FILE_NGBLA
+#define FILE_NGBLA
+
+
+#include <ngstd.hpp>
+
+
+#include "complex_wrapper.hpp"
+
+#include "expr.hpp"
+#include "vector.hpp"
+#include "matrix.hpp"
+#include "ngblas.hpp"
+#include "cholesky.hpp"
+#include "symmetricmatrix.hpp"
+#include "bandmatrix.hpp"
+#include "triangular.hpp"
+#include "householder.hpp"
+#include "tensor.hpp"
+#include "eigensystem.hpp"
+
+// so far we can move stuff to ngcore
+
+#include "calcinverse.hpp"
+#include "simd_complex.hpp"
+
+#include "ng_lapack.hpp"
+
+#endif

netgen/include/blockalloc.hpp

@@ -0,0 +1,95 @@
+#ifndef FILE_BLOCKALLOC
+#define FILE_BLOCKALLOC
+
+/**************************************************************************/
+/* File:   blockalloc.hpp                                                 */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   19. Apr. 2000                                                  */
+/**************************************************************************/
+
+#include <ngstd.hpp>
+
+namespace ngstd
+{
+
+/**
+   Optimized memory handler.
+   Memory handler allocates many objects at once.
+   Maintains free list of deleted objects
+ */
+class BlockAllocator
+{
+  /// size of data
+  unsigned int size;
+  /// number of blocks allocated at once
+  unsigned int blocks;
+  /// single linked list of free elements
+  void * freelist;
+  /// pointers to blocks
+  Array<char*> bablocks;
+  ///
+  int nels;
+public:
+  /// Create BlockAllocator for elements of size asize
+  NGS_DLL_HEADER BlockAllocator (unsigned int asize, unsigned int ablocks = 100);
+  /// Delete all memeory
+  NGS_DLL_HEADER ~BlockAllocator ();
+
+  /// Return pointer to new element
+  NGS_DLL_HEADER void * Alloc ();
+  /*
+  {
+    nels++;
+    if (!freelist)
+      Alloc2 ();
+
+    void * p = freelist;
+    freelist = *(void**)freelist;
+    return p;
+  }
+  */
+
+
+  /// Send memory to free-list
+  NGS_DLL_HEADER void Free (void * p);
+  /*
+  {
+    nels--;
+    *(void**)p = freelist;
+    freelist = p;
+  }
+  */
+
+  /// number of allocated elements
+  int NumElements () { return nels; }
+
+  NGS_DLL_HEADER void Print (ostream * ost) const;
+
+  const MemoryTracer& GetMemoryTracer() const { return mt; }
+
+  void StartMemoryTracing() const
+  {
+    mt.Alloc(bablocks.Size() * size * blocks);
+  }
+
+private:
+  NGS_DLL_HEADER void * Alloc2 ();
+  MemoryTracer mt;
+};
+
+
+}
+
+INLINE void * operator new (size_t /* size */, ngstd::BlockAllocator & ball)  
+{
+  return ball.Alloc();
+}
+
+INLINE void operator delete (void * p, ngstd::BlockAllocator & ball)  
+{
+  ball.Free (p);
+}
+
+
+
+#endif

netgen/include/blockjacobi.hpp

@@ -0,0 +1,328 @@
+#ifndef FILE_BLOCK_JACOBI
+#define FILE_BLOCK_JACOBI
+
+/* *************************************************************************/
+/* File:   blockjacobi.hpp                                                  */
+/* Author: Joachim Schoeberl                                               */
+/* Date:   06. Oct. 96                                                     */
+/* *************************************************************************/
+
+
+#include "sparsematrix.hpp"
+#include "jacobi.hpp"
+
+namespace ngla
+{
+
+  /**
+     Base class for Block - Jacobi and Block Gauss Seidel smoother.
+  */
+  class NGS_DLL_HEADER BaseBlockJacobiPrecond : public BaseMSMPrecond
+  {
+  protected:
+    /// the table defining the blocks
+    shared_ptr<Table<int>> blocktable;
+    /// maximal block size
+    int maxbs;
+
+    /// block coloring 
+    Table<int> block_coloring;
+
+    /// balancing for each color
+    Array<Partitioning> color_balance;
+
+    size_t nze;
+  public:
+    /// the blocktable define the blocks. ATTENTION: entries will be reordered !
+    BaseBlockJacobiPrecond (shared_ptr<Table<int>> ablocktable);
+
+    /// deletes the table
+    virtual ~BaseBlockJacobiPrecond ();
+
+    virtual void Smooth (BaseVector & x, const BaseVector & b, int steps = 1) const override
+    {
+      GSSmooth (x, b, steps);
+    }
+    virtual void SmoothBack (BaseVector & x, const BaseVector & b, int steps = 1) const override
+    {
+      GSSmoothBack (x, b, steps);
+    }
+
+
+    
+    /// performs steps Gauss-Seidel steps for the equation A x = b
+    virtual void GSSmooth (BaseVector & x, const BaseVector & b,
+			   int steps = 1) const = 0;
+
+    /// performs steps Gauss-Seidel steps for the equation A x = b with partial residual y
+    virtual void GSSmoothPartial (BaseVector & x, const BaseVector & b, BaseVector & y) const 
+    {
+      GSSmooth (x, b, 1);
+    }
+
+
+    /// does smoothing. The vector res contains the residuum (b-Ax) before and after the smoothing
+    virtual void GSSmoothResiduum (BaseVector & x, const BaseVector & b,
+				   BaseVector & res, int steps = 1) const = 0;
+
+    /// does smoothing in reversed order
+    virtual void GSSmoothBack (BaseVector & x, const BaseVector & b,
+			       int steps = 1) const = 0;
+
+    virtual void GSSmoothBackPartial (BaseVector & x, const BaseVector & b, BaseVector & y) const 
+    {
+      GSSmoothBack (x, b, 1);
+    }
+
+
+    /// reorders block entries for band-width minimization
+    int Reorder (FlatArray<int> block, const MatrixGraph & graph,
+		 FlatArray<int> usedflags,        // in and out: array of -1, size = graph.size
+		 LocalHeap & lh);
+
+    auto GetBlockTable() const { return blocktable; } 
+  };
+
+
+  class SymmetricBlockGaussSeidelPrecond : virtual public BaseMatrix
+  {
+    shared_ptr<BaseBlockJacobiPrecond> jac;
+  public:
+    SymmetricBlockGaussSeidelPrecond (shared_ptr<const BaseSparseMatrix> mat, shared_ptr<Table<int>> blocktable)
+      : jac(mat->CreateBlockJacobiPrecond(blocktable)) { }
+
+    int VHeight() const override { return jac->VHeight(); }
+    int VWidth() const override { return jac->VHeight(); }
+
+    void Mult (const BaseVector & x, BaseVector & y) const override
+    {
+      y = 0;
+      jac->GSSmooth (y, x);
+      jac->GSSmoothBack (y, x);
+    }
+    
+    AutoVector CreateRowVector() const override { return jac->CreateRowVector(); }
+    AutoVector CreateColVector() const override { return jac->CreateColVector(); }
+  };
+
+  
+
+
+  /**
+     A block-Jacobi preconditioner.
+     The blocks are specified by a table container
+  */
+  template <class TM, class TV_ROW, class TV_COL>
+  class  NGS_DLL_HEADER BlockJacobiPrecond : public BaseBlockJacobiPrecond,
+                                             public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
+  {
+  protected:
+    /// a reference to the matrix
+    // const SparseMatrix<TM,TV_ROW,TV_COL> & mat;
+    shared_ptr<const SparseMatrix<TM,TV_ROW,TV_COL>> mat;
+    /// inverses of the small blocks
+    Array<FlatMatrix<TM>> invdiag;
+    /// the data for the inverses
+    Array<TM> bigmem;
+
+  public:
+    // typedef typename mat_traits<TM>::TV_ROW TVX;
+    typedef TV_ROW TVX;
+    typedef typename mat_traits<TM>::TSCAL TSCAL;
+
+    ///
+    BlockJacobiPrecond (shared_ptr<const SparseMatrix<TM,TV_ROW,TV_COL>> amat, 
+			shared_ptr<Table<int>> ablocktable, bool cumulate_block_diags = false);
+    ///
+    virtual ~BlockJacobiPrecond ();
+
+    size_t Height() const { return mat->Height(); }
+    int VHeight() const override { return mat->Height(); }
+    size_t Width() const { return mat->Width(); }
+    int VWidth() const override { return mat->Width(); }
+
+    AutoVector CreateRowVector() const override { return mat->CreateColVector(); }
+    AutoVector CreateColVector() const override { return mat->CreateRowVector(); }
+
+    BaseMatrix::OperatorInfo GetOperatorInfo () const override
+    { return { string("BlockJacobi-")+typeid(TM).name(), this->Height(), this->Width() }; }
+    
+    ///
+    void MultAdd (TSCAL s, const BaseVector & x, BaseVector & y) const override;
+
+    ///
+    void MultTransAdd (TSCAL s, const BaseVector & x, BaseVector & y) const override;
+
+
+    ///
+    void GSSmooth (BaseVector & x, const BaseVector & b,
+                   int steps = 1) const override;
+
+    void GSSmoothBack (BaseVector & x, const BaseVector & b,
+                       int steps = 1) const override;
+  
+    void GSSmoothResiduum (BaseVector & x, const BaseVector & b,
+                           BaseVector & res, int steps = 1) const  override
+    {
+      GSSmooth (x, b, steps);
+      res = b - (*mat) * x;
+    }
+
+    ///
+    virtual void GSSmoothNumbering (BaseVector & x, const BaseVector & b,
+				    const Array<int> & numbering, 
+				    int forward = 1) const
+    {
+      ;
+    }
+
+    Array<MemoryUsage> GetMemoryUsage () const override
+    {
+      int nels = 0;
+      for (size_t i = 0; i < blocktable->Size(); i++)
+	{
+	  int bs = (*blocktable)[i].Size();
+	  nels += bs*bs;
+	}
+      return { MemoryUsage ("BlockJac", nels*sizeof(TM), blocktable->Size()) };
+    }
+
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;
+    const Array<FlatMatrix<TM>> & GetInverses() const { return invdiag; }
+    const Array<TM> & MatrixData() const { return bigmem; } 
+  };
+
+
+
+
+
+  /* **************** SYMMETRIC ****************** */
+
+
+  ///
+  template <class TM, class TV>
+  class BlockJacobiPrecondSymmetric : 
+    public BaseBlockJacobiPrecond,
+    public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
+  {
+  protected:
+    shared_ptr<const SparseMatrixSymmetric<TM,TV>> mat;
+
+    // 
+    enum { NBLOCKS = 20 };
+    // DynamicMem<int> blockstart, blocksize, blockbw;
+    // DynamicMem<TM> data[NBLOCKS];
+
+    Array<int> blockstart, blocksize, blockbw;
+    Array<TM> data[NBLOCKS];
+
+
+    bool lowmem;
+  public:
+  
+    typedef TV TVX;
+    typedef typename mat_traits<TM>::TSCAL TSCAL;
+  
+    ///
+    NGS_DLL_HEADER BlockJacobiPrecondSymmetric (shared_ptr<const SparseMatrixSymmetric<TM,TV>> amat, 
+                                                shared_ptr<Table<int>> ablocktable);
+    
+    /*
+    BlockJacobiPrecondSymmetric (const SparseMatrixSymmetric<TM,TV> & amat, 
+				 const FlatVector<TVX> & constraint,
+				 Table<int> & ablocktable);
+    */
+    ///
+    virtual ~BlockJacobiPrecondSymmetric ();
+  
+    FlatBandCholeskyFactors<TM> InvDiag (int i) const
+    {
+      return FlatBandCholeskyFactors<TM> (blocksize[i], 
+					  blockbw[i], 
+					  const_cast<TM*>(&data[i%NBLOCKS][blockstart[i]]));
+    }
+
+    void ComputeBlockFactor (FlatArray<int> block, int bw, FlatBandCholeskyFactors<TM> & inv) const;
+  
+    ///
+    void MultAdd (TSCAL s, const BaseVector & x, BaseVector & y) const override;
+
+    ///
+    void MultTransAdd (TSCAL s, const BaseVector & x, BaseVector & y) const override;
+
+    ///
+    AutoVector CreateRowVector () const override { return mat->CreateColVector(); }
+    AutoVector CreateColVector () const override { return mat->CreateRowVector(); }
+
+
+    int Height() const { return mat->Height(); }
+    int VHeight() const override { return mat->Height(); }
+    int Width() const { return mat->Width(); }
+    int VWidth() const override { return mat->Width(); }
+
+
+    ///
+    void GSSmooth (BaseVector & x, const BaseVector & b,
+                   int steps = 1) const override;
+  
+    void GSSmoothPartial (BaseVector & x, const BaseVector & b,
+                          BaseVector & y) const override;
+  
+
+
+    ///
+    void GSSmoothResiduum (BaseVector & x, const BaseVector & b,
+                           BaseVector & res, int steps = 1) const override;
+
+  
+    ///
+    void GSSmoothBack (BaseVector & x, const BaseVector & b,
+                       int steps = 1) const override;
+ 
+
+    void GSSmoothBackPartial (BaseVector & x, const BaseVector & b,
+                              BaseVector & y) const override;
+ 
+
+
+
+
+    void SmoothBlock (int i, 
+		      FlatVector<TVX> & x,
+		      // const FlatVector<TVX> & b,
+		      FlatVector<TVX> & y) const;
+ 
+
+    ///
+    virtual void GSSmoothNumbering (BaseVector & x, const BaseVector & b,
+				    const Array<int> & numbering, 
+				    int forward = 1) const
+    {
+      ;
+    }
+  
+    /*  
+	virtual void MemoryUsage (Array<MemoryUsageStruct*> & mu) const
+	{
+	// Array<BandCholeskyFactors<TM>*> invdiag;
+
+
+	int nels = 0;
+	for (int i = 0; i < blocktable.Size(); i++)
+	if (invdiag[i])
+	{
+	int s = invdiag[i]->Size();
+	int bw = invdiag[i]->BandWidth();
+	nels += s*bw - (bw * (bw-1)) / 2;
+	nels += s;
+	}
+	mu.Append (new MemoryUsageStruct ("BlockJacSym Table", blocktable.NElements()*sizeof(int), 1));
+	mu.Append (new MemoryUsageStruct ("BlockJacSym", nels*sizeof(TM), 2*blocktable.Size()));
+	}
+    */
+  };
+
+
+}
+
+#endif

netgen/include/bspline.hpp

@@ -0,0 +1,116 @@
+#ifndef FILE_BSPLINE
+#define FILE_BSPLINE
+
+/**************************************************************************/
+/* File:   bspline.hpp                                                    */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   10. Aug. 2015                                                  */
+/**************************************************************************/
+
+
+namespace ngstd
+{
+
+  class BSpline 
+  {
+    shared_ptr<BSpline> diff = nullptr;
+    int order;
+    Array<double> t;
+    Array<double> c;
+    
+  public:
+    BSpline() = default;
+    NGS_DLL_HEADER BSpline (int aorder,
+             Array<double> at,
+             Array<double> ac);
+    NGS_DLL_HEADER BSpline (const BSpline &) = default;
+    NGS_DLL_HEADER BSpline & operator= (const BSpline &) = default;
+
+    void DoArchive(Archive& ar)
+    {
+      ar & order & t & c;
+    }
+
+    NGS_DLL_HEADER BSpline Differentiate () const;
+    NGS_DLL_HEADER BSpline Integrate () const;
+
+    NGS_DLL_HEADER double Evaluate (double x) const;
+    NGS_DLL_HEADER SIMD<double> Evaluate(SIMD<double> x) const;
+    double operator() (double x) const { return Evaluate(x); }
+    // Complex operator() (Complex x) const { return Evaluate(x.real()); }
+    /*I had to explicitly write double and SIMD<double>
+     here as these functions will be used in GenerateCode and I was
+     getting the error "templates must have C++ linkage"*/
+    NGS_DLL_HEADER AutoDiff<1,double> operator() (AutoDiff<1,double> x) const;
+    NGS_DLL_HEADER AutoDiffDiff<1,double> operator() (AutoDiffDiff<1,double> x) const;
+    NGS_DLL_HEADER AutoDiff<1,SIMD<double>> operator() (AutoDiff<1,SIMD<double>> x) const;
+    NGS_DLL_HEADER AutoDiffDiff<1,SIMD<double>> operator() (AutoDiffDiff<1,SIMD<double>> x) const;
+    
+    NGS_DLL_HEADER SIMD<double> operator() (SIMD<double> x) const;
+    // NGS_DLL_HEADER SIMD<Complex> operator() (SIMD<Complex> x) const;
+    
+    int GetOrder() const { return order; }
+    friend ostream & operator<< (ostream & ost, const BSpline & sp);
+  };
+
+  extern ostream & operator<< (ostream & ost, const BSpline & sp);
+
+  class BSpline2D
+  {
+    Array<double> px;
+    Array<double> py;
+    Array<double> v;
+    [[maybe_unused]] int order = 1;
+    bool extrapolate = true;
+
+    std::tuple<int,int,bool> Search(double x, double y) const;
+
+    template<typename T>
+    T Interpolate(int ix, int iy, T x, T y) const
+    {
+      double x0 = px[ix];
+      double x1 = px[ix+1];
+      double y0 = py[iy];
+      double y1 = py[iy+1];
+      double dx = x1-x0;
+      double dy = y1-y0;
+
+      auto fy0 = ((x1-x)*GetV(ix, iy) + (x-x0)*GetV(ix+1, iy))/dx;
+      auto fy1 = ((x1-x)*GetV(ix, iy+1) + (x-x0)*GetV(ix+1, iy+1))/dx;
+      return ((y1-y)*fy0 + (y-y0)*fy1)/dy;
+    }
+
+    double GetV(int ix, int iy) const
+    {
+      return v[ix*py.Size()+iy];
+    }
+
+  public:
+    BSpline2D() = default;
+    NGS_DLL_HEADER BSpline2D ( Array<double> x, Array<double> y, Array<double> av, int aorder, bool aextrapolate)
+      : px(x), py(y), v(av), order(aorder), extrapolate(aextrapolate) { }
+    NGS_DLL_HEADER BSpline2D (const BSpline2D &) = default;
+    NGS_DLL_HEADER BSpline2D & operator= (const BSpline2D &) = default;
+
+    void DoArchive(Archive& ar)
+    {
+      ar & px & py & v;
+    }
+
+    NGS_DLL_HEADER double Evaluate (double x, double y) const;
+    NGS_DLL_HEADER SIMD<double> Evaluate(SIMD<double> x, SIMD<double> y) const;
+    double operator() (double x, double y) const { return Evaluate(x, y); }
+    NGS_DLL_HEADER AutoDiff<1,double> operator() (AutoDiff<1,double> x, AutoDiff<1,double> y) const;
+    NGS_DLL_HEADER AutoDiffDiff<1,double> operator() (AutoDiffDiff<1,double> x, AutoDiffDiff<1,double> y) const;
+    NGS_DLL_HEADER AutoDiff<1,SIMD<double>> operator() (AutoDiff<1,SIMD<double>> x, AutoDiff<1,SIMD<double>> y) const;
+    NGS_DLL_HEADER AutoDiffDiff<1,SIMD<double>> operator() (AutoDiffDiff<1,SIMD<double>> x, AutoDiffDiff<1,SIMD<double>> y) const;
+
+    NGS_DLL_HEADER SIMD<double> operator() (SIMD<double> x, SIMD<double> y) const;
+
+    friend ostream & operator<< (ostream & ost, const BSpline2D & sp);
+  };
+  extern ostream & operator<< (ostream & ost, const BSpline2D & sp);
+
+}
+
+#endif

netgen/include/calcinverse.hpp

@@ -0,0 +1,141 @@
+#ifndef CALCINVERSE_HPP
+#define CALCINVERSE_HPP
+
+
+namespace ngbla
+{
+
+  /* **************************** Inverse *************************** */
+
+
+  enum class INVERSE_LIB { INV_NGBLA, INV_NGBLA_LU, INV_LAPACK, INV_NGBLA_QR, INV_CHOOSE };
+
+  /// Calculate inverse. Gauss elimination with row pivoting
+  template <class T2>
+  extern NGS_DLL_HEADER void CalcInverse (FlatMatrix<T2> inv, INVERSE_LIB il = INVERSE_LIB::INV_CHOOSE);
+
+  extern NGS_DLL_HEADER void CalcInverse (FlatMatrix<double> inv, INVERSE_LIB il = INVERSE_LIB::INV_CHOOSE);
+
+  template <class T, class T2>
+  inline void CalcInverse (const FlatMatrix<T> m, FlatMatrix<T2> inv)
+  {
+    inv = m;
+    CalcInverse (inv);
+  }
+
+  template <class T, class T2>
+  inline void CalcInverse (const FlatMatrix<T> m, Matrix<T2> & inv)
+  {
+    inv = m;
+    CalcInverse (inv);
+  }
+
+
+
+  /**
+     Calculates the inverse of a Matrix.
+  */
+
+  template <typename T>
+  inline Matrix<T> Inverse (const FlatMatrix<T> & m)
+  {
+    Matrix<T> inv(m.Height(),m.Height());
+    CalcInverse (m, inv);
+    return inv;
+  }
+
+  
+  inline void CalcInverse (double & m)
+  {
+    m = 1 / m;
+  }
+
+  inline void CalcInverse (Complex & m)
+  {
+    m = 1.0 / m;
+  }
+
+  template <int H, int W, typename T>
+  inline void CalcInverse (Mat<H,W,T> & m)
+  {
+    FlatMatrix<T> fm(m);
+    CalcInverse (fm);
+  }
+
+
+  INLINE void CalcInverse (const double & m, double & inv)
+  {
+    inv = 1 / m;
+  }
+
+  INLINE void CalcInverse (const Complex & m, Complex & inv)
+  {
+    inv = 1.0 / m;
+  }
+
+  template <int H, int W, typename T, typename TINV>
+  inline void CalcInverse (const Mat<H,W,T> & m, TINV & inv)
+  {
+    FlatMatrix<T> fm(m);
+    FlatMatrix<T> finv(inv);
+    CalcInverse (fm, finv);
+  }
+
+  template <typename T, typename TINV>
+  INLINE void CalcInverse (const Mat<0,0,T> & m, TINV & inv)
+  {
+    ;
+  }
+
+  template <typename T, typename TINV>
+  INLINE void CalcInverse (const Mat<1,1,T> & m, TINV & inv)
+  {
+    inv(0,0) = 1.0 / m(0,0);
+  }
+
+  template <typename T, typename TINV>
+  INLINE void CalcInverse (const Mat<2,2,T> & m, TINV & inv)
+  {
+    T idet = 1.0 / (m(0,0) * m(1,1) - m(0,1) * m(1,0));
+    inv(0,0) = idet * m(1,1);
+    inv(0,1) = -idet * m(0,1);
+    inv(1,0) = -idet * m(1,0);
+    inv(1,1) = idet * m(0,0);
+  }
+
+  template <typename T, typename TINV>
+  INLINE void CalcInverse (Mat<3,3,T> m, TINV & inv)
+  {
+    T h0 = m(4)*m(8)-m(5)*m(7);
+    T h1 = m(5)*m(6)-m(3)*m(8);
+    T h2 = m(3)*m(7)-m(4)*m(6);
+    T det = m(0) * h0 + m(1) * h1 + m(2) * h2;
+    T idet = 1.0 / det;
+    
+    inv(0,0) =  idet * h0; 
+    inv(0,1) = -idet * (m(1) * m(8) - m(2) * m(7));
+    inv(0,2) =  idet * (m(1) * m(5) - m(2) * m(4));
+    
+    inv(1,0) =  idet * h1; 
+    inv(1,1) =  idet * (m(0) * m(8) - m(2) * m(6));
+    inv(1,2) = -idet * (m(0) * m(5) - m(2) * m(3));
+    
+    inv(2,0) =  idet * h2; 
+    inv(2,1) = -idet * (m(0) * m(7) - m(1) * m(6));
+    inv(2,2) =  idet * (m(0) * m(4) - m(1) * m(3));
+    return;
+  }
+
+
+  
+  /// Computes the Schur Complement.
+  extern NGS_DLL_HEADER void CalcSchurComplement (const FlatMatrix<double> a, 
+				   FlatMatrix<double> s,
+				   const BitArray & used,
+				   LocalHeap & lh);
+
+}
+
+
+
+#endif