ngsolve 6.2.2506.post75.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/simd_complex.hpp

@@ -0,0 +1,329 @@
+#ifndef FILE_SIMD_COMPLEX
+#define FILE_SIMD_COMPLEX
+
+/**************************************************************************/
+/* File:   simd.hpp                                                       */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   06. Nov. 16                                                    */
+/**************************************************************************/
+
+#include <core/simd.hpp>
+
+namespace ngcore
+{
+
+  INLINE SIMD<mask64> Mask128 (int64_t nr)
+  {
+#ifdef __CUDA_ARCH__
+    return 2*nr;
+
+#else // __CUDA_ARCH__
+  #ifdef __AVX512F__
+
+    return _mm512_cmpgt_epi64_mask(_mm512_set1_epi64(nr),
+                                   _mm512_set_epi64(3, 3, 2, 2, 1, 1, 0, 0));
+
+  #elif defined(__AVX__)
+
+    return my_mm256_cmpgt_epi64(_mm256_set1_epi64x(nr),
+                                _mm256_set_epi64x(1, 1, 0, 0));
+
+  #elif defined NETGEN_ARCH_AMD64
+    return _mm_cmpgt_epi32(_mm_set1_epi32(nr),
+                           _mm_set_epi32(0, 0, 0, 0));
+  #else
+    return 2*nr;
+  #endif
+#endif // __CUDA_ARCH__
+  }
+
+
+  
+  template <int N>
+  class SIMD<Complex, N>
+  {
+    SIMD<double,N> re, im;
+  public:
+    SIMD () = default;
+    SIMD (SIMD<double,N> _r, SIMD<double,N> _i = 0.0) : re(_r), im(_i) { ; }
+    SIMD (Complex c) : re(c.real()), im(c.imag()) { ; }
+    SIMD (double d) : re(d), im(0.0) { ; }
+    static constexpr int Size() { return SIMD<double>::Size(); }
+
+    auto real() const { return re; }
+    auto imag() const { return im; }
+    auto & real() { return re; }
+    auto & imag() { return im; }
+
+
+    auto Lo() const
+    {
+      if constexpr (N == 2) return Complex(re.Lo(), im.Lo());
+      else return SIMD<Complex,N/2> (re.Lo(), im.Lo());
+    }
+    auto Hi() const
+    {
+      if constexpr (N == 2) return Complex(re.Hi(), im.Hi());
+      else return SIMD<Complex,N/2> (re.Hi(), im.Hi());
+    }
+    
+    // Numbers in SIMD structure are not necessarily in same order as in memory
+    // for instance:
+    // [x0,y0,x1,y1,x2,y2,x3,y3] -> [x0,x2,x1,x3,y0,y2,y1,y3]
+    void LoadFast (Complex * p)
+    {
+      SIMD<double,N> c1((double*)p);
+      SIMD<double,N> c2((double*)(p+SIMD<double>::Size()/2));
+      std::tie(re,im) = Unpack(c1,c2);
+    }
+
+    void StoreFast (Complex * p)
+    {
+      auto [h1,h2] = Unpack(re,im);
+      h1.Store((double*)p);
+      h2.Store((double*)(p+SIMD<double,N>::Size()/2));
+    }
+
+    void LoadFast (Complex * p, int nr)
+    {
+      SIMD<double> c1((double*)p, Mask128(nr));
+      SIMD<double> c2((double*)(p+SIMD<double>::Size()/2), Mask128(nr-SIMD<double>::Size()/2));
+      std::tie(re,im) = Unpack(c1,c2);
+    }
+
+    void StoreFast (Complex * p, int nr)
+    {
+      auto [h1,h2] = Unpack(re,im);
+      h1.Store((double*)p, Mask128(nr));
+      h2.Store((double*)(p+SIMD<double>::Size()/2), Mask128(nr-SIMD<double>::Size()/2));
+    }
+  };
+
+  // templatize all with N ???
+  template <int N>
+  inline SIMD<double, N> Real(SIMD<Complex, N> a) { return a.real(); }
+  template <int N>
+  inline SIMD<double, N> Imag(SIMD<Complex, N> a) { return a.imag(); }
+
+  template <int N> INLINE auto operator+ (SIMD<Complex, N> a, SIMD<Complex, N> b)
+  { return SIMD<Complex, N> (a.real()+b.real(), a.imag()+b.imag()); }
+  template <int N> INLINE auto operator+ (SIMD<Complex, N> a, SIMD<double, N> b)
+  { return SIMD<Complex, N> (a.real()+b, a.imag()); }
+  template <int N> INLINE auto operator+ (SIMD<double, N> b, SIMD<Complex, N> a)
+  { return SIMD<Complex, N> (a.real()+b, a.imag()); }
+  template <int N> INLINE auto operator+ (SIMD<Complex, N> a, double b)
+  { return SIMD<Complex, N> (a.real()+b, a.imag()); }
+  template <int N> INLINE auto operator+ (double b, SIMD<Complex, N> a)
+  { return SIMD<Complex, N> (a.real()+b, a.imag()); }
+  template <int N> INLINE auto operator+ (SIMD<Complex, N> a, Complex b)
+  { return a + SIMD<Complex, N> (b); }
+  template <int N> INLINE auto operator+ (Complex b, SIMD<Complex, N> a)
+  { return a + SIMD<Complex, N> (b); }    
+
+  
+  template <int N> INLINE auto operator- (SIMD<Complex, N> a, SIMD<Complex, N> b)
+  { return SIMD<Complex, N> (a.real()-b.real(), a.imag()-b.imag()); }
+  
+
+  template <int N>
+  INLINE auto operator- (SIMD<Complex, N> a)
+  { return SIMD<Complex, N>(-a.real(), -a.imag()); }
+
+  
+  template <int N> INLINE auto operator* (SIMD<Complex, N> a, SIMD<Complex, N> b)
+  { return SIMD<Complex, N> (a.real()*b.real()-a.imag()*b.imag(),
+                             a.real()*b.imag()+a.imag()*b.real()); }
+  template <int N> INLINE auto operator* (SIMD<double, N> a, SIMD<Complex, N> b)
+  { return SIMD<Complex, N> (a*b.real(), a*b.imag()); }
+  template <int N> INLINE auto operator* (SIMD<Complex, N> b, SIMD<double, N> a)
+  { return SIMD<Complex, N> (a*b.real(), a*b.imag()); }
+  
+  template <int N> INLINE auto operator* (double a, SIMD<Complex, N> b)
+  { return SIMD<Complex, N> (a*b.real(), a*b.imag()); }
+  template <int N> INLINE auto operator* (SIMD<Complex, N> b, double a)
+  { return SIMD<Complex, N> (a*b.real(), a*b.imag()); }
+  template <int N> INLINE auto operator* (Complex a, SIMD<Complex, N> b)
+  { return SIMD<Complex, N> (a)*b; }
+  template <int N> INLINE auto operator* (SIMD<Complex, N> b, Complex a)
+  { return SIMD<Complex, N> (a)*b; }
+  template <int N> INLINE auto operator* (SIMD<double, N> b, Complex a)
+  { return SIMD<Complex, N> (a.real()*b, a.imag()*b); }
+  template <int N> INLINE auto operator* (Complex a, SIMD<double, N> b)
+  { return SIMD<Complex, N> (a.real()*b, a.imag()*b); }
+
+  
+  template <int N>
+  INLINE SIMD<Complex, N> & operator+= (SIMD<Complex, N> & a, SIMD<Complex, N> b)
+  { a.real()+=b.real(); a.imag()+=b.imag(); return a; }
+  template <int N>
+  INLINE SIMD<Complex, N> & operator-= (SIMD<Complex, N> & a, SIMD<Complex, N> b)
+  { a.real()-=b.real(); a.imag()-=b.imag(); return a; }
+
+  template <int N>
+  INLINE SIMD<Complex, N> & operator*= (SIMD<Complex, N> & a, double b)
+  { a.real()*= b; a.imag() *= b; return a; }  
+  template <int N>
+  INLINE SIMD<Complex, N> & operator*= (SIMD<Complex, N> & a, Complex b)
+  { a = a*SIMD<Complex, N>(b); return a; }
+  template <int N>
+  INLINE SIMD<Complex, N> & operator*= (SIMD<Complex, N> & a, SIMD<double> b)
+  { a.real()*= b; a.imag() *= b; return a; }
+  template <int N>
+  INLINE SIMD<Complex, N> & operator*= (SIMD<Complex, N> & a, SIMD<Complex, N> b)
+  { a = a*b; return a; }
+
+  template <int N>
+  INLINE SIMD<Complex, N> Inv (SIMD<Complex, N> a)
+  {
+    SIMD<double> n2 = a.real()*a.real()+a.imag()*a.imag();
+    return SIMD<Complex, N> (a.real()/n2, -a.imag()/n2);
+  }
+  
+  template <int N> INLINE auto operator/ (double a, SIMD<Complex, N> b)
+  { return a * Inv(b); }
+
+  template <int N> INLINE auto operator/ (Complex a, SIMD<Complex, N> b)
+  { return a * Inv(b); }
+
+  template <int N> INLINE auto operator/ (SIMD<Complex, N> a, SIMD<Complex, N> b)
+  { return a * Inv(b); }
+
+  template <int N> INLINE auto operator/ (SIMD<Complex, N> a, SIMD<double, N> b)
+  { return a * (1.0/b); }
+  
+  template <int N>
+  INLINE Complex HSum (SIMD<Complex, N> sc)
+  {
+    auto [re,im] = HSum(sc.real(), sc.imag());
+    return Complex(re,im);
+  }
+
+  template <int N>
+  INLINE auto HSum (SIMD<Complex, N> sc1, SIMD<Complex, N> sc2)
+  {
+    auto [re1,im1,re2,im2] = HSum(sc1.real(), sc1.imag(), sc2.real(), sc2.imag());
+    return std::tuple(Complex(re1,im1), Complex(re2,im2));
+  }
+  
+  template <int N>
+  ostream & operator<< (ostream & ost, SIMD<Complex, N> c)
+  {
+    ost << c.real() << ", " << c.imag();
+    return ost;
+  }
+
+
+  template <typename FUNC, int N>
+  SIMD<Complex, N> SIMDComplexWrapper (SIMD<Complex, N> x, FUNC f)
+  {
+    Complex hx[N];
+    x.StoreFast(hx);
+    for (auto & hxi : hx) hxi = f(hxi);
+    x.LoadFast(hx);
+    return x;
+  }
+
+  template <int N>
+  inline SIMD<Complex, N> cos (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return cos(c); }); }
+  
+  template <int N>
+  inline SIMD<Complex, N> sin (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return sin(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> tan (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return tan(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> atan (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return atan(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> acos (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return acos(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> asin (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return asin(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> cosh (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return cosh(c); }); }
+  
+  template <int N>
+  inline SIMD<Complex, N> sinh (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return sinh(c); }); }
+  
+  template <int N>
+  inline SIMD<Complex, N> exp (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return exp(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> log (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return log(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> sqrt (SIMD<Complex, N> x)
+  { return SIMDComplexWrapper (x, [](Complex c) { return sqrt(c); }); }
+
+  template <int N>
+  inline SIMD<Complex, N> Conj (SIMD<Complex, N> x)
+  { return SIMD<Complex, N> (x.real(), -x.imag()); } 
+
+  template <int N>
+  INLINE SIMD<Complex, N> IfPos (SIMD<Complex, N> a, SIMD<Complex, N> b, SIMD<Complex, N> c)
+  {
+    return SIMD<Complex, N> (IfPos (a.real(), b.real(), c.real()),
+                             IfPos (a.real(), b.imag(), c.imag()));
+  }
+
+
+  template <int N>
+  INLINE SIMD<Complex, N> If (SIMD<mask64, N> a, SIMD<Complex, N> b, SIMD<Complex, N> c)
+  {
+    return SIMD<Complex, N> (If (a, b.real(), c.real()),
+                             If (a, b.imag(), c.imag()));
+  }
+
+
+
+  
+  template <typename T, size_t S> class MakeSimdCl;
+  
+  template <size_t S>
+  class MakeSimdCl<Complex,S>
+  {
+    std::array<Complex,S> a;
+  public:
+    MakeSimdCl (std::array<Complex,S> aa) : a(aa)  { ; }
+    auto Get() const
+    {
+      std::array<double,S> ar, ai;
+      for (int j = 0; j < S; j++)
+        {
+          ar[j] = ngbla::Real(a[j]);
+          ai[j] = ngbla::Imag(a[j]);
+        }
+      
+      return SIMD<Complex,S> (MakeSimd(ar), MakeSimd(ai));
+    }
+  };
+  
+  
+}
+
+
+namespace ngbla
+{
+  template <typename T> struct is_scalar_type;
+  template <int N>
+  struct is_scalar_type<ngcore::SIMD<double,N>> { static constexpr bool value = true; };
+
+  template <typename T> struct is_scalar_type;
+  template <int N>
+  struct is_scalar_type<ngcore::SIMD<ngcore::Complex,N>> { static constexpr bool value = true; };
+}
+
+
+#endif

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/smoother.hpp

@@ -0,0 +1,253 @@
+#ifndef FILE_SMOOTHER
+#define FILE_SMOOTHER
+
+/*********************************************************************/
+/* File:   smoother.hh                                               */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   20. Apr. 2000                                             */
+/*********************************************************************/
+
+namespace ngmg
+{
+
+  /** 
+      Smoothing iteration for multigrid method.
+      Pure virtual base class.
+  */
+  class NGS_DLL_HEADER Smoother
+  {
+  protected:
+    /// additive or multiplicative smoothing
+    int additive; 
+    /// should coarse levels be updated, too ?
+    int updateall;
+    /// 
+    Flags flags;
+  public: 
+    /// Constructor
+    Smoother();
+    /// Constructor
+    Smoother(const Flags & aflags); 
+    /// Destructor
+    virtual ~Smoother();
+  
+    /// Update smoother (fine level or all levels)
+    virtual void Update (bool force_update = 0) = 0;
+
+    /// Do steps iterations of pre-smoothing
+    virtual void PreSmooth (int level, ngla::BaseVector & u, 
+			    const ngla::BaseVector & f, int steps) const = 0;
+
+
+    /// Do steps iterations of pre-smoothing
+    virtual void PreSmoothResiduum (int level, ngla::BaseVector & u, 
+				    const ngla::BaseVector & f, 
+				    ngla::BaseVector & res, 
+				    int steps) const 
+    {
+      PreSmooth (level, u, f, steps);
+      Residuum (level, u, f, res);
+    }
+
+
+    /// Do steps iterations of post-smoothing
+    virtual void PostSmooth (int level, ngla::BaseVector & u, 
+			     const ngla::BaseVector & f, int steps) const = 0;
+    /// Apply the preconditioning action (additive or multiplicative)
+    virtual void Precond (int level, const ngla::BaseVector & f, ngla::BaseVector & u) const;
+
+    /// 
+    virtual void Residuum (int level, ngla::BaseVector & u, 
+			   const ngla::BaseVector & f, 
+			   ngla::BaseVector & d) const = 0;
+
+    ///
+    void SetAdditive () { additive = 1; }
+    ///
+    void SetUpdateAll (int ua) { updateall = ua; }
+    ///
+    void SetMultiplicative () { additive = 0; }
+    ///
+    int Additive () const { return additive; }
+
+    ///
+    virtual AutoVector CreateVector(int level) const = 0;
+
+    virtual Array<MemoryUsage> GetMemoryUsage () const { return Array<MemoryUsage>(); }
+  private:
+  MemoryTracer mt = { "Smoother" };
+  public:
+  const MemoryTracer& GetMemoryTracer() const { return mt; }
+  };
+
+
+  /**
+     Gauss-Seidel smoother.
+     Common relaxation of unknowns in node.
+  */
+  class GSSmoother : public Smoother
+  {
+    ///
+    // const MeshAccess & ma;
+    ///
+    const BilinearForm & biform;
+    ///
+    Array<shared_ptr<BaseJacobiPrecond>> jac;
+  
+  public:
+    ///
+    GSSmoother (const MeshAccess & ama,
+		const BilinearForm & abiform);
+    ///
+    virtual ~GSSmoother();
+  
+    ///
+    virtual void Update (bool force_update = 0);
+    ///
+    virtual void PreSmooth (int level, ngla::BaseVector & u, 
+			    const ngla::BaseVector & f, int steps) const;
+    ///
+    virtual void PostSmooth (int level, ngla::BaseVector & u, 
+			     const ngla::BaseVector & f, int steps) const;
+
+    virtual void PreSmoothResiduum (int level, ngla::BaseVector & u, 
+				    const ngla::BaseVector & f, 
+				    ngla::BaseVector & res, 
+				    int steps) const;
+
+    ///
+    virtual void Residuum (int level, ngla::BaseVector & u, 
+			   const ngla::BaseVector & f, ngla::BaseVector & d) const;
+    ///
+    virtual AutoVector CreateVector(int level) const;
+  };
+
+
+  /**
+     Anisotropic smoother.
+     Common relaxation of vertically aligned nodes.
+  */
+  class AnisotropicSmoother : public Smoother
+  {
+    ///
+    const MeshAccess & ma;
+    ///
+    const BilinearForm & biform;
+    ///
+    Array<shared_ptr<BaseBlockJacobiPrecond>> jac;
+  
+  public:
+    ///
+    AnisotropicSmoother (const MeshAccess & ama,
+			 const BilinearForm & abiform);
+    ///
+    virtual ~AnisotropicSmoother();
+  
+    ///
+    virtual void Update (bool forace_update = 0);
+    ///
+    virtual void PreSmooth (int level, ngla::BaseVector & u, 
+			    const ngla::BaseVector & f, int steps) const;
+    ///
+    virtual void PostSmooth (int level, ngla::BaseVector & u, 
+			     const ngla::BaseVector & f, int steps) const;
+    ///
+    virtual void Residuum (int level, ngla::BaseVector & u, 
+			   const ngla::BaseVector & f, ngla::BaseVector & d) const;
+    ///
+    virtual AutoVector CreateVector(int level) const;
+  };
+
+
+
+
+
+  /**
+     Block-Gauss-Seidel smoother.
+     Blocks are defined by underlying FESpace.
+  */
+  class BlockSmoother : public Smoother
+  {
+    ///
+    // const MeshAccess & ma;
+    ///
+    const BilinearForm & biform;
+    ///
+    const LinearForm * constraint;
+    ///
+    Array<shared_ptr<BaseBlockJacobiPrecond>> jac;
+    ///
+    Array<shared_ptr<BaseMatrix>> inv;
+    ///
+    shared_ptr<Array<int>> direct;
+    shared_ptr<Array<int>> userdefined_direct;
+
+    Array<shared_ptr<Table<int>>> smoothing_blocks;
+
+  public:
+    ///
+    BlockSmoother (const MeshAccess & ama,
+		   const BilinearForm & abiform, const Flags & aflags);
+    ///
+    BlockSmoother (const MeshAccess & ama,
+		   const BilinearForm & abiform,
+		   const LinearForm & aconstraint, const Flags & aflags);
+    ///
+    virtual ~BlockSmoother();
+  
+    ///
+    virtual void Update (bool forace_update = 0);
+    ///
+    virtual void PreSmooth (int level, BaseVector & u, 
+			    const BaseVector & f, int steps) const;
+    ///
+    virtual void PreSmoothResiduum (int level, ngla::BaseVector & u, 
+				    const ngla::BaseVector & f, 
+				    ngla::BaseVector & res, 
+				    int steps) const;
+
+    ///
+    virtual void PostSmooth (int level, ngla::BaseVector & u, 
+			     const ngla::BaseVector & f, int steps) const;
+    ///
+    virtual void Precond (int level, const ngla::BaseVector & f, ngla::BaseVector & u) const;
+    ///
+    virtual void Residuum (int level, ngla::BaseVector & u, 
+			   const ngla::BaseVector & f, ngla::BaseVector & d) const;
+    ///
+    virtual AutoVector CreateVector(int level) const;
+
+    virtual Array<MemoryUsage> GetMemoryUsage () const;
+
+    void SetDirectSolverCluster(shared_ptr<Array<int>> cluster)
+    {  userdefined_direct = cluster; }
+  };
+
+
+
+
+
+#ifdef XXX_OBSOLETE
+  /**
+     Matrix - vector multiplication by smoothing step.
+  */
+  class SmoothingPreconditioner : public ngla::BaseMatrix
+  {
+    ///
+    const Smoother & smoother;
+    ///
+    int level;
+  public:
+    ///
+    SmoothingPreconditioner (const Smoother & asmoother,
+			     int alevel = 0);
+    ///
+    virtual void Mult (const ngla::BaseVector & f, ngla::BaseVector & u) const;
+    ///
+    virtual AutoVector CreateVector () const;
+  };
+#endif
+
+}
+
+#endif

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/solve.hpp

@@ -0,0 +1,89 @@
+#ifndef FILE_SOLVE
+#define FILE_SOLVE
+
+/*********************************************************************/
+/* File:   solve.hpp                                                 */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   25. Mar. 2000                                             */
+/*********************************************************************/
+
+
+/* 
+   NGS Solvers: BVP, Instationary, ...
+*/
+
+
+#include <ngstd.hpp>
+#include <nginterface.h>
+
+#include <comp.hpp>
+#include <multigrid.hpp>
+
+struct Tcl_Interp;
+
+
+/*
+#ifdef WIN32
+   #define LOCAL_EXPORTS __declspec(dllexport)
+#else
+   #define LOCAL_EXPORTS 
+#endif
+*/
+
+/**
+   A collection of solvers.
+   Numerical procedures NumProc, e.g. for
+   the solution of boundary value problems NumProcBVP or
+   eigen value problems NumProcEVP, and many many more.
+ */
+namespace ngsolve
+{
+  using namespace std;
+
+  using namespace ngstd;
+  using namespace ngla;
+  using namespace ngfem;
+  using namespace ngcomp;
+  using namespace ngmg;
+}
+
+
+/*
+#include "numproc.hpp"
+#include "pde.hpp"
+*/
+
+
+/*
+#ifdef WIN32 
+// trick from http://social.msdn.microsoft.com/Forums/en/vclanguage/thread/ab642c88-2d2d-4f5d-9fd7-2341442d5a46
+// all new/delete allocation is done from ngsolve heap
+
+NGS_DLL_HEADER void * __cdecl my_operator_new_replacement(size_t _count);
+NGS_DLL_HEADER void __cdecl my_operator_delete_replacement(void * _ptr);
+NGS_DLL_HEADER void * __cdecl my_operator_new_array_replacement(size_t _count);
+NGS_DLL_HEADER void __cdecl my_operator_delete_array_replacement(void * _ptr);
+
+#ifndef NGS_EXPORTS
+inline void * __cdecl operator new(size_t _count) {
+    return my_operator_new_replacement(_count);
+}
+inline void __cdecl operator delete(void * _ptr) {
+    my_operator_delete_replacement(_ptr);
+}
+inline void * __cdecl operator new[](size_t _count) {
+    return my_operator_new_array_replacement(_count);
+}
+inline void __cdecl operator delete[](void * _ptr) {
+    my_operator_delete_array_replacement(_ptr);
+}
+
+#endif
+
+#endif
+*/
+
+
+
+
+#endif