ngsolve 6.2.2504.post44.dev0__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

netgen/include/mycomplex.hpp

@@ -76,7 +76,7 @@ INLINE const T arg(const MyComplex<T> &A)
 }
 
 template <class T>
-const MyComplex<T> conj(const MyComplex<T> &A)
+INLINE const MyComplex<T> conj(const MyComplex<T> &A)
 {
   return MyComplex<T>(A.a, -A.b);
 }

netgen/include/ngblas.hpp

@@ -412,10 +412,10 @@ namespace ngbla
 
   
   template <bool ADD, bool POS, ORDERING orda, ORDERING ordb>
-  void NgGEMM (SliceMatrix<double,orda> a, SliceMatrix<double, ordb> b, SliceMatrix<double> c);
+  INLINE void NgGEMM (SliceMatrix<double,orda> a, SliceMatrix<double, ordb> b, SliceMatrix<double> c);
 
   template <bool ADD, bool POS, ORDERING orda, ORDERING ordb>
-  void NgGEMM (SliceMatrix<double,orda> a, SliceMatrix<double, ordb> b, SliceMatrix<double,ColMajor> c);
+  INLINE void NgGEMM (SliceMatrix<double,orda> a, SliceMatrix<double, ordb> b, SliceMatrix<double,ColMajor> c);
   
   
 
@@ -428,7 +428,7 @@ namespace ngbla
   // t   t    C += A*B
   
   template <bool ADD, bool POS, ORDERING orda, ORDERING ordb>
-  inline void NgGEMM (SliceMatrix<double,orda> a, SliceMatrix<double, ordb> b, SliceMatrix<double> c)
+  INLINE void NgGEMM (SliceMatrix<double,orda> a, SliceMatrix<double, ordb> b, SliceMatrix<double> c)
   {
     // static Timer t("generic MM, add/pos/ord="+ToString(ADD)+ToString(POS)+ToString(orda)+ToString(ordb));
     // RegionTimer r(t);
@@ -584,12 +584,31 @@ namespace ngbla
       }
   }
 
-  template <typename TM, typename TVX, typename TVY>
-  extern void TestFunc (TM m, TVX x, TVY y);
-
+  // template <typename TM, typename TVX, typename TVY>
+  // extern void TestFunc (TM m, TVX x, TVY y);
+  
+  
+  template <typename TS, typename T> constexpr bool IsVec = false;
+  template <typename TS, int S> constexpr bool IsVec<TS, Vec<S,TS>> = true;  
+  
   template <bool ADD, bool POS, typename TM, ORDERING ORD, typename TX, typename TY>
   INLINE void NgGEMV (BareSliceMatrix<TM,ORD> a, FlatVector<const TX> x, FlatVector<TY> y)
   {
+    if constexpr (std::is_same<TM,double>() && std::is_same<TX,TY>() && IsVec<Complex,TX>)
+      {
+        FlatMatrix<double> mx(x.Size(), sizeof(TX)/sizeof(double), (double*)(void*)x.Addr(0));
+        FlatMatrix<double> my(y.Size(), sizeof(TX)/sizeof(double), (double*)(void*)y.Addr(0));
+        NgGEMM<ADD,POS> (a.AddSize(y.Size(), x.Size()),make_SliceMatrix(mx), make_SliceMatrix(my));
+        return;
+      }
+    if constexpr (std::is_same<TM,Complex>() && std::is_same<TX,TY>() && IsVec<Complex,TX>)
+      {
+        FlatMatrix<Complex> mx(x.Size(), sizeof(TX)/sizeof(Complex), &const_cast<Complex&>(*(x.Data()->Data())));
+        FlatMatrix<Complex> my(y.Size(), sizeof(TX)/sizeof(Complex), y.Data()->Data());
+        NgGEMM<ADD,POS> (a.AddSize(y.Size(), x.Size()),make_SliceMatrix(mx), make_SliceMatrix(my));
+        return;
+      }
+
     if (!ADD)
       {
         if (!POS)
@@ -635,6 +654,16 @@ namespace ngbla
   extern NGS_DLL_HEADER  
   void NgGEMV (double s, BareSliceMatrix<double,ord> a, SliceVector<double> x, SliceVector<double> y) NETGEN_NOEXCEPT;
   */
+
+
+
+
+
+
+
+  /* *********************** GEMV - SliceVector **************************** */
+
+
   
   template <bool ADD, ORDERING ord>
   extern NGS_DLL_HEADER  
@@ -714,7 +743,30 @@ namespace ngbla
   }
 
 
-
+  
+  
+  template <bool ADD, bool POS, typename TM, ORDERING ORD, typename TX, typename TY>
+  INLINE void NgGEMV (BareSliceMatrix<TM,ORD> a, SliceVector<TX> x, SliceVector<TY> y)
+  {
+    if constexpr (std::is_same<TM,double>() && std::is_same<TX,TY>() && IsVec<Complex,TX>)
+      {
+        constexpr int VS = sizeof(TX)/sizeof(double);
+        SliceMatrix<double> mx(x.Size(), VS, x.Dist()*VS, (double*)(void*)x.Addr(0));
+        SliceMatrix<double> my(y.Size(), VS, y.Dist()*VS, (double*)(void*)y.Addr(0));
+        NgGEMM<ADD,POS> (a.AddSize(y.Size(), x.Size()),make_SliceMatrix(mx), make_SliceMatrix(my));
+        return;
+      }
+    else if constexpr (std::is_same<TM,Complex>() && std::is_same<TX,TY>() && IsVec<Complex,TX>)
+      {
+        constexpr int VS = sizeof(TX)/sizeof(Complex);
+        SliceMatrix<Complex> mx(x.Size(), VS, x.Dist()*VS, &const_cast<Complex&>(*(x.Data()->Data())));
+        SliceMatrix<Complex> my(y.Size(), VS, y.Dist()*VS, y.Data()->Data());
+        NgGEMM<ADD,POS> (a.AddSize(y.Size(), x.Size()),make_SliceMatrix(mx), make_SliceMatrix(my));
+        return;
+      }
+    else
+      NgGEMV<ADD> (POS ? 1.0 : -1.0, a, x, y);
+  }
 
 
 
@@ -880,9 +932,14 @@ namespace ngbla
                          FlatVector<const TB>(prod.View().B().Range(0,w)),
                          FlatVector<T>(self.Spec().Range(0,h)));
       else
+        NgGEMV<ADD,POS> (make_BareSliceMatrix(prod.View().A()),
+                         SliceVector<TB>(prod.View().B().Range(0,w)),
+                         SliceVector<T>(self.Spec().Range(0,h)));
+        /*
         NgGEMV<ADD> (POS ? 1.0 : -1.0, make_BareSliceMatrix(prod.View().A()),
                      SliceVector<TB>(prod.View().B().Range(0,w)),
                      SliceVector<T>(self.Spec().Range(0,h)));
+        */
       return self.Spec();
     }
   };
@@ -1099,8 +1156,60 @@ namespace ngbla
     }
   };
   
+  // typedef void (*pmatmatcRR)(size_t, size_t, BareSliceMatrix<Complex,RowMajor>, BareSliceMatrix<Complex,RowMajor>,BareSliceMatrix<Complex,RowMajor>);
+
+  template <ORDERING OA, ORDERING OB>
+  using pmatmatc =  void (*)(size_t, size_t, BareSliceMatrix<Complex, OA>, BareSliceMatrix<Complex,OB>,BareSliceMatrix<Complex,RowMajor>);
+  template <bool ADD, bool POS, ORDERING OA, ORDERING OB>
+  extern NGS_DLL_HEADER pmatmatc<OA,OB> dispatch_matmatc[9];
+
+  template <bool ADD, bool POS, ORDERING OA, ORDERING OB>
+  extern NGS_DLL_HEADER void NgGEMMBare (size_t ah, size_t aw, size_t bw, BareSliceMatrix<Complex,OA> a, BareSliceMatrix<Complex,OB> b, BareSliceMatrix<Complex,RowMajor> c);
 
 
+  template <bool ADD, bool POS, ORDERING OA, ORDERING OB>
+  void NgGEMM (SliceMatrix<Complex,OA> a, SliceMatrix<Complex,OB> b, SliceMatrix<Complex,RowMajor> c)
+  {
+    size_t ah = a.Height();
+    size_t aw = a.Width();
+    size_t bw = b.Width();
+    if (aw < std::size(dispatch_matmatc<ADD,POS,OA,OB>))
+      {
+        (*dispatch_matmatc<ADD,POS,OA,OB>[aw])(ah, bw, make_BareSliceMatrix(a), make_BareSliceMatrix(b), make_BareSliceMatrix(c));
+        return;
+      }
+
+    NgGEMMBare<ADD,POS>(ah, aw, bw, make_BareSliceMatrix(a), make_BareSliceMatrix(b), make_BareSliceMatrix(c));
+  }
+  
+  template <bool ADD, bool POS, ORDERING OA, ORDERING OB>
+  void NgGEMM (SliceMatrix<Complex,OA> a, SliceMatrix<Complex,OB> b, SliceMatrix<Complex,ColMajor> c)
+  {
+    NgGEMM<ADD,POS> (Trans(b), Trans(a), Trans(c));
+  }
+  
+  template <typename OP, typename T, typename TA, typename TB>
+  class assign_trait<OP, T, MultExpr<TA, TB>,
+                     enable_if_t<IsConvertibleToSliceMatrix<TA,Complex>() &&
+                                 IsConvertibleToSliceMatrix<TB,Complex>() &&
+                                 IsConvertibleToSliceMatrix<T,Complex>(), int>>
+  {
+  public:
+    static inline T & Assign (MatExpr<T> & self, const Expr<MultExpr<TA, TB>> & prod) 
+    {
+      constexpr bool ADD = std::is_same<OP,typename MatExpr<T>::AsAdd>::value || std::is_same<OP,typename MatExpr<T>::AsSub>::value;
+      constexpr bool POS = std::is_same<OP,typename MatExpr<T>::As>::value || std::is_same<OP,typename MatExpr<T>::AsAdd>::value;
+
+      size_t n = CombinedSize(prod.View().A().Height(), self.Spec().Height());
+      size_t m = CombinedSize(prod.View().B().Width(), self.Spec().Width());
+      size_t k = CombinedSize(prod.View().A().Width(), prod.View().B().Height());
+      
+      NgGEMM<ADD,POS> (make_BareSliceMatrix(prod.View().A()).AddSize(n,k).RemoveConst(),
+                       make_BareSliceMatrix(prod.View().B()).AddSize(k,m).RemoveConst(),
+                       make_BareSliceMatrix(self.Spec()).AddSize(n,m));
+      return self.Spec();
+    }
+  };
 
   
 

netgen/include/potentialtools.hpp

@@ -13,9 +13,9 @@
 namespace ngsbem
 {
 
-  extern void AddChargeDensity (SingularMLMultiPole<Complex> & mp, shared_ptr<CoefficientFunction> current, ngcomp::Region reg);
+  extern void AddChargeDensity (SingularMLExpansion<Complex> & mp, shared_ptr<CoefficientFunction> current, ngcomp::Region reg);
   
-  extern void AddCurrentDensity (SingularMLMultiPole<Vec<3,Complex>> & mp, shared_ptr<CoefficientFunction> current, ngcomp::Region reg);
+  extern void AddCurrentDensity (SingularMLExpansion<Vec<3,Complex>> & mp, shared_ptr<CoefficientFunction> current, ngcomp::Region reg);
  
 }
 

netgen/include/preconditioner.hpp

@@ -414,7 +414,7 @@ namespace ngcomp
     ///
     // MGPreconditioner * low_order_preconditioner;
     ///
-    shared_ptr<Preconditioner> coarse_pre;
+    shared_ptr<BaseMatrix> coarse_pre;
     ///
     int finesmoothingsteps;
     ///
@@ -462,7 +462,7 @@ namespace ngcomp
     void MgTest () const;
 
     void SetDirectSolverCluster(shared_ptr<Array<int>> cluster);
-    void SetCoarsePreconditioner(shared_ptr<Preconditioner> prec);
+    void SetCoarsePreconditioner(shared_ptr<BaseMatrix> prec);
   };
 
   class CommutingAMGPreconditioner : public Preconditioner

netgen/include/prolongation.hpp

@@ -67,6 +67,11 @@ namespace ngmg
       y = tmp.Range(0, VWidth());
     }
 
+    shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override
+    {
+      return prol->CreateProlongationMatrix(level);
+    }
+
     AutoVector CreateRowVector() const override { return make_unique<VVector<double>> (VWidth()); }
     AutoVector CreateColVector() const override { return make_unique<VVector<double>> (VHeight()); }
   };
@@ -219,9 +224,7 @@ namespace ngmg
     }
 
     ///
-    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override
-    { return NULL; }
-
+    shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override;
 
     ///
     virtual void ProlongateInline (int finelevel, BaseVector & v) const override;

netgen/include/recursive_pol.hpp

@@ -1507,9 +1507,24 @@ namespace ngfem
   class NormalizedLegendreFunctions : public RecursivePolynomialNonStatic<NormalizedLegendreFunctions>
   {
     int  m;
+    static Matrix<double,ColMajor> matA, matB;
   public:
     NormalizedLegendreFunctions (size_t _m) : m(_m) { }
     
+
+    static void Calc(int mmax)
+    {
+      if (matA.Height() >= mmax+1) return;
+      matA.SetSize(mmax+1, mmax+1);
+      matB.SetSize(mmax+1, mmax+1);
+      for (int m = 0; m <= mmax; m++)
+        for (int n = m+2; n <= mmax; n++)
+          {
+            matA(n,m) = (2*n-1) / sqrt((n-m+0.0)*(n+m));
+            matB(n,m) = sqrt((n+m-1.0)*(n-m-1.0)) / sqrt((n-m+0.0)*(n+m));
+          }
+    }
+    
     template <typename T, typename S>
     NormalizedLegendreFunctions (size_t mmax, size_t nmax, T x, S && values)
     {
@@ -1524,23 +1539,60 @@ namespace ngfem
       auto y = Trans(values);
       
       y = 0.0;
-      double u = -sqrt((1-x)*(1+x));
+      T u = -sqrt((1-x)*(1+x));
       y(0,0)=1;
-      
-      for (double m = 0; m <= mmax; m++)
+
+      if (mmax+1 > matA.Height() || nmax > matA.Width())
+        {
+          for (int m = 0; m <= mmax; m++)
+            {
+              if (m > 0)
+                y(m,m)=y(m-1,m-1)*u*sqrt((2*m-1.0)/(2*m));
+              if (m < nmax)
+                y(m+1,m)=x*y(m,m)*sqrt(2*m+1.0);
+              for (int n = m+2; n <= nmax; n++)
+                y(n,m)=((2*n-1)*x*y(n-1,m) - 
+                        sqrt((n+m-1.0)*(n-m-1.0))*y(n-2,m))
+                  /sqrt((n-m+0.0)*(n+m));
+            }
+        }
+      else
         {
-          if (m > 0)
-            y(m,m)=y(m-1,m-1)*u*sqrt((2*m-1.0)/(2*m));
-          if (m < nmax)
-            y(m+1,m)=x*y(m,m)*sqrt(2*m+1.0);
-          for (int n = m+2; n <= nmax; n++)
-            y(n,m)=((2*n-1)*x*y(n-1,m) - 
-                    sqrt((n+m-1.0)*(n-m-1.0))*y(n-2,m))
-              /sqrt((n-m+0.0)*(n+m));
+          for (int m = 0; m <= mmax; m++)
+            {
+              if (m > 0)
+                y(m,m)=y(m-1,m-1)*u*sqrt((2*m-1.0)/(2*m));
+              if (m < nmax)
+                {
+                  T valold = y(m,m);
+                  
+                  T val = x*valold*sqrt(2*m+1.0);
+                  y(m+1,m)=val;
+                  
+                  auto coefsA = matA.Col(m);
+                  auto coefsB = matB.Col(m);
+                  
+                  for (int n = m+2; n <= nmax; n++)
+                    {
+                      T valnew = coefsA(n) * x * val - coefsB(n) * valold;
+                      y(n,m) = valnew;
+                      valold = val;
+                      val = valnew;
+                    }
+                }
+              /*
+              for (int n = m+2; n <= nmax; n++)
+                y(n,m) = matA(n,m) * x * y(n-1,m) - matB(n,m) * y(n-2,m);
+              */
+            }
         }
+      
       for (int n = 0; n <= nmax; n++)
+        y.Row(n).Range(0,n+1) *= sqrt(2*n+1.0);
+        /*
         for (int m = 0; m <= n; m++)
           y(n,m)=y(n,m)*sqrt(2*n+1.0);
+        */
     }
     
     template <class S>

netgen/include/simd_complex.hpp

@@ -56,6 +56,17 @@ namespace ngcore
     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]
@@ -266,6 +277,40 @@ namespace ngcore
     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));
+    }
+  };
+  
+  
 }
 
 

netgen/include/sparsecholesky.hpp

@@ -28,10 +28,14 @@ namespace ngla
 
   public:
     SparseFactorization (shared_ptr<const BaseSparseMatrix> amatrix,
-			 shared_ptr<BitArray> ainner,
-			 shared_ptr<const Array<int>> acluster);
+			 shared_ptr<BitArray> ainner = nullptr,
+			 shared_ptr<const Array<int>> acluster = nullptr);
     SparseFactorization() {}
 
+    virtual void SetSubset
+      (shared_ptr<BitArray> ainner,
+        shared_ptr<const Array<int>> acluster=nullptr);
+
     void DoArchive(Archive& ar) override;
 
     // virtual bool IsComplex() const override { return matrix.lock()->IsComplex(); }

netgen/include/sparsefactorization_interface.hpp

@@ -0,0 +1,159 @@
+#ifndef SPARSEFACTORIZATION_INTERFACE_HPP
+#define SPARSEFACTORIZATION_INTERFACE_HPP
+
+#include "basevector.hpp"
+#include "sparsecholesky.hpp"
+#include "sparsematrix.hpp"
+#include "../ngstd/python_ngstd.hpp"
+
+namespace ngla {
+
+  void ExportSparseFactorizationInterface(py::module &m);
+
+struct MapInnerDofs {
+  shared_ptr<BitArray> inner;
+  shared_ptr<const Array<int>> cluster;
+  Array<int> project;
+  Array<int> embed;
+  size_t size = 0;
+
+  MapInnerDofs() {}
+
+  void Init(shared_ptr<BitArray> ainner,
+               shared_ptr<const Array<int>> acluster = nullptr)
+  {
+    inner = ainner;
+    cluster = acluster;
+    if (!inner && !cluster) {
+      size = 0;
+      return;
+    }
+    if (inner) {
+      size = inner->NumSet();
+      project.SetSize(size);
+      embed.SetSize(inner->Size());
+      int j = 0;
+      for (int i = 0; i < inner->Size(); i++) {
+        if ((*inner)[i]) {
+          project[j] = i;
+          embed[i] = j++;
+        } else
+          embed[i] = -1;
+      }
+      return;
+    }
+
+    int j = 0;
+    for (int i = 0; i < cluster->Size(); i++) {
+      if ((*cluster)[i]) {
+        project.Append(i);
+        embed.Append(j++);
+      } else {
+        embed.Append(-1);
+      }
+    }
+    size = project.Size();
+  }
+
+  operator bool() const { return inner || cluster; }
+
+  template <typename T>
+  void Project(FlatVector<T> dst, FlatVector<T> src) const {
+    for (size_t i = 0; i < project.Size(); i++)
+      dst[i] = src[project[i]];
+  }
+
+  template <typename T> void Embed(T &dst, const T &src) const {
+    for (size_t i : Range(embed)) {
+      if (embed[i] >= 0)
+        dst[i] = src[embed[i]];
+      else
+        dst[i] = 0.0;
+    }
+  }
+
+  template <typename T>
+  void EmbedAdd(FlatVector<T> dst, FlatVector<T> src, T scale) const {
+    for (size_t i : Range(embed))
+      if (embed[i] >= 0)
+        dst[i] += scale * src[embed[i]];
+  }
+
+  template <typename T>
+  shared_ptr<SparseMatrixTM<T>>
+  ProjectMatrix(shared_ptr<const SparseMatrixTM<T>> m) {
+    Array<int> rowi, coli;
+    Array<T> vals;
+    // auto &dofs = *inner;
+
+    auto vals_ori = m->GetValues();
+
+    auto &cluster_array = *cluster;
+    auto &inner_bitarray = *inner;
+    auto is_used = [this, &inner_bitarray, &cluster_array](int i, int j) {
+      if (inner)
+        return inner_bitarray[i] && inner_bitarray[j];
+      return cluster_array[i] == cluster_array[j];
+    };
+
+    for (auto i : project)
+      for (auto j : m->GetRowIndices(i))
+        if (is_used(i, j)) {
+          rowi.Append(embed[i]);
+          coli.Append(embed[j]);
+          vals.Append(vals_ori[m->GetPosition(i, j)]);
+        }
+
+    auto res = SparseMatrixTM<T>::CreateFromCOO(rowi, coli, vals,
+                                                project.Size(), project.Size());
+    res->SetSPD(m->IsSPD());
+    return res;
+  }
+};
+
+class SparseFactorizationInterface : public SparseFactorization {
+protected:
+  shared_ptr<const BaseSparseMatrix> inner_mat;
+  shared_ptr<BaseVector> inner_rhs, inner_solution;
+  MapInnerDofs map_inner_dofs;
+  bool is_complex = false;
+  bool is_symmetric = false;
+  bool is_symmetric_storage = false;
+  bool is_analyzed = false;
+  int width, height, inner_width, inner_height;
+
+public:
+  SparseFactorizationInterface() = delete;
+  SparseFactorizationInterface(shared_ptr<const BaseMatrix> m,
+                               shared_ptr<BitArray> ainner = nullptr,
+                               shared_ptr<const Array<int>> acluster = nullptr);
+
+  virtual ~SparseFactorizationInterface() {}
+
+  void SetSubset(shared_ptr<BitArray> inner, shared_ptr<const Array<int>> cluster) override;
+
+  AutoVector CreateRowVector() const override {
+    return make_unique<VVector<double>>(Width());
+  }
+
+  AutoVector CreateColVector() const override {
+    return make_unique<VVector<double>>(Height());
+  }
+
+  shared_ptr<const BaseSparseMatrix> GetInnerMatrix() const {
+    return inner_mat;
+  }
+
+  void MultAdd(double s, const BaseVector &x, BaseVector &y) const override;
+  void MultAdd(Complex s, const BaseVector &x, BaseVector &y) const override;
+
+  virtual void Update() override;
+
+  virtual void Analyze() {}
+  virtual void Factor() {}
+  virtual void Solve(const BaseVector &rhs, BaseVector &solution) const = 0;
+};
+
+} // namespace ngla
+
+#endif // SPARSEFACTORIZATION_INTERFACE_HPP

netgen/include/sparsematrix.hpp

@@ -258,7 +258,7 @@ namespace ngla
       throw Exception ("BaseSparseMatrix::CreateBlockJacobiPrecond");
     }
 
-    virtual shared_ptr<BaseSparseMatrix> CreateTranspose() const
+    virtual shared_ptr<BaseSparseMatrix> CreateTranspose(bool sorted = true) const
     {
       throw Exception ("BaseSparseMatrix::CreateTranspose");      
     }
@@ -561,7 +561,7 @@ namespace ngla
     virtual tuple<int,int> EntrySizes() const override { return { ngbla::Height<TM>(), ngbla::Width<TM>() }; }
     
     shared_ptr<BaseSparseMatrix>
-      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&, int)> & creator) const;
+      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&, int)> & creator, bool sorted) const;
 
   public:
     using BaseMatrix::GetMemoryTracer;
@@ -619,7 +619,7 @@ namespace ngla
 
 
     BaseMatrix::OperatorInfo GetOperatorInfo () const override
-    { return { string("SparseMatrix")+typeid(TM).name(), this->Height(), this->Width() }; }
+    { return { string("SparseMatrix")+typeid(TM).name()+" (nze="+ToString(this->NZE())+")", this->Height(), this->Width() }; }
     
     virtual shared_ptr<BaseJacobiPrecond>
       CreateJacobiPrecond (shared_ptr<BitArray> inner) const override;
@@ -638,11 +638,11 @@ namespace ngla
     
     virtual shared_ptr<BaseSparseMatrix> Reorder (const Array<size_t> & reorder) const override;
     
-    virtual shared_ptr<BaseSparseMatrix> CreateTranspose() const override
+    virtual shared_ptr<BaseSparseMatrix> CreateTranspose(bool sorted) const override
     {
       return this->CreateTransposeTM
         ( [](const Array<int> & elsperrow, int width) -> shared_ptr<SparseMatrixTM<decltype(Trans(TM()))>>
-          { return make_shared<SparseMatrix<decltype(Trans(TM())), TV_COL, TV_ROW>> (elsperrow, width); } );
+          { return make_shared<SparseMatrix<decltype(Trans(TM())), TV_COL, TV_ROW>> (elsperrow, width); }, sorted );
     }
 
     virtual shared_ptr<BaseMatrix> DeleteZeroElements(double tol) const override;
@@ -669,6 +669,20 @@ namespace ngla
       for (size_t j = first; j < last; j++)
         vec[colpi[j]] += Trans(datap[j]) * el; 
     }
+
+    void AddRowTransToVectorAtomic (int row, TVY el, FlatVector<TVX> vec) const
+    {
+      size_t first = firsti[row];
+      size_t last = firsti[row+1];
+
+      const ColIdx * colpi = colnr.Addr(0);
+      const TM * datap = data.Addr(0);
+
+      for (size_t j = first; j < last; j++)
+        // vec[colpi[j]] += Trans(datap[j]) * el;
+        AtomicAdd (vec[colpi[j]], Trans(datap[j]) * el);
+    }
+
     
     ///
     void AddRowConjTransToVector (int row, TVY el, FlatVector<TVX> vec) const
@@ -858,9 +872,9 @@ namespace ngla
           double sb, const SparseMatrixTM<double> & matb);
   
   NGS_DLL_HEADER shared_ptr<SparseMatrixTM<double>>
-  MatMult (const SparseMatrixTM<double> & mata, const SparseMatrixTM<double> & matb);
+  MatMult (const SparseMatrixTM<double> & mata, const SparseMatrixTM<double> & matb, bool sort_output = true);
   NGS_DLL_HEADER shared_ptr<SparseMatrixTM<Complex>>
-  MatMult (const SparseMatrixTM<Complex> & mata, const SparseMatrixTM<Complex> & matb);
+  MatMult (const SparseMatrixTM<Complex> & mata, const SparseMatrixTM<Complex> & matb, bool sort_output = true);
 
 #ifdef GOLD
 #include <sparsematrix_spec.hpp>

netgen/include/sparsematrix_dyn.hpp

@@ -50,9 +50,9 @@ namespace ngla
     virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
     
     AutoVector CreateRowVector() const override
-    { throw make_unique<VVector<TSCAL>> (VWidth()); }
+    { return make_unique<VVector<TSCAL>> (VWidth()); }
     AutoVector CreateColVector() const override
-    { throw make_unique<VVector<TSCAL>> (VHeight()); }
+    { return make_unique<VVector<TSCAL>> (VHeight()); }
     
     virtual tuple<int,int> EntrySizes() const override { return { bh, bw }; }
   };