ngsolve 6.2.2506.post75.dev0__cp311-cp311-manylinux_2_28_x86_64.whl → 6.2.2506.post168.dev0__cp311-cp311-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post168.dev0.data/data/bin/ngs_nvcc

@@ -0,0 +1,22 @@
+#!/usr/bin/bash
+NGSCXX_DIR=$( cd $(dirname $0); pwd )
+PY_INCLUDE_FLAGS=-I$(python3 -c"import sysconfig;print(sysconfig.get_path('include'))")
+if [ -f /opt/rh/gcc-toolset-14/root/usr/bin/c++ ]
+  then NGSCXX=/opt/rh/gcc-toolset-14/root/usr/bin/c++
+  else NGSCXX=c++
+fi
+export CCACHE_NOHASHDIR=1
+
+
+if [ -f /usr/local/cuda/bin/nvcc ]
+  then NVCC=/usr/local/cuda/bin/nvcc
+  else NVCC=nvcc
+fi
+
+
+if [ -f /usr/bin/ccache ]
+  then /usr/bin/ccache $NVCC  -DHAVE_NETGEN_SOURCES -DHAVE_DLFCN_H -DHAVE_CXA_DEMANGLE -DUSE_TIMEOFDAY -DTCL -DLAPACK -DUSE_PARDISO -DNGS_PYTHON -D_GLIBCXX_USE_CXX11_ABI=1 -DNETGEN_PYTHON -DNG_PYTHON -DPYBIND11_SIMPLE_GIL_MANAGEMENT -DPARALLEL -DNG_MPI_WRAPPER -arch=native --expt-relaxed-constexpr --extended-lambda --diag-suppress=611 --diag-suppress=20011 --diag-suppress=20012 --diag-suppress=20013 --diag-suppress=20014 --diag-suppress=20015 -rdc=true -Xcompiler -std=c++17 -Xcompiler -DMAX_SYS_DIM=3 -Xcompiler -march=core-avx2 -Xcompiler -fabi-version=17 -Xcompiler -fPIC  -I/opt/_internal/cpython-3.11.13/include -I/opt/_internal/cpython-3.11.13/include/python3.11 -I$NGSCXX_DIR/../include/netgen -I$NGSCXX_DIR/../include/netgen/include $PY_INCLUDE_FLAGS $*
+
+  else $NVCC  -DHAVE_NETGEN_SOURCES -DHAVE_DLFCN_H -DHAVE_CXA_DEMANGLE -DUSE_TIMEOFDAY -DTCL -DLAPACK -DUSE_PARDISO -DNGS_PYTHON -D_GLIBCXX_USE_CXX11_ABI=1 -DNETGEN_PYTHON -DNG_PYTHON -DPYBIND11_SIMPLE_GIL_MANAGEMENT -DPARALLEL -DNG_MPI_WRAPPER -arch=native --expt-relaxed-constexpr --extended-lambda --diag-suppress=611 --diag-suppress=20011 --diag-suppress=20012 --diag-suppress=20013 --diag-suppress=20014 --diag-suppress=20015 -rdc=true -Xcompiler -std=c++17 -Xcompiler -DMAX_SYS_DIM=3 -Xcompiler -march=core-avx2 -Xcompiler -fabi-version=17 -Xcompiler -fPIC  -I/opt/_internal/cpython-3.11.13/include -I/opt/_internal/cpython-3.11.13/include/python3.11 -I$NGSCXX_DIR/../include/netgen -I$NGSCXX_DIR/../include/netgen/include $PY_INCLUDE_FLAGS $*
+
+fi

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/bin/ngs_nvlink

@@ -1,3 +1,4 @@
+#!/usr/bin/bash
 NGSCXX_DIR=$( cd $(dirname $0); pwd )
 PY_INCLUDE_FLAGS=-I$(python3 -c"import sysconfig;print(sysconfig.get_path('include'))")
 if [ -f /opt/rh/gcc-toolset-14/root/usr/bin/c++ ]
@@ -6,9 +7,11 @@ if [ -f /opt/rh/gcc-toolset-14/root/usr/bin/c++ ]
 fi
 export CCACHE_NOHASHDIR=1
 
+
 if [ -f /usr/local/cuda/bin/nvcc ]
   then NVCC=/usr/local/cuda/bin/nvcc
   else NVCC=nvcc
 fi
 
-$NGSCXX  -L$NGSCXX_DIR/../lib/python3.11/site-packages/netgen_mesher.libs -Wl,--rpath=$NGSCXX_DIR/../lib/python3.11/site-packages/netgen_mesher.libs $*
+$NVCC -rdc=true -arch=native $*
+

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/bdbequations.hpp

@@ -2783,9 +2783,11 @@ namespace ngfem
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradVectorH1<2> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradVectorH1<3> >;
 
+  extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradientBoundary<1> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradientBoundary<2> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradientBoundary<3> >;
 
+  extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradBoundaryVectorH1<1> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradBoundaryVectorH1<2> >;
   extern template class NGS_DLL_HEADER T_DifferentialOperator<DiffOpGradBoundaryVectorH1<3> >;
 

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/bilinearform.hpp

@@ -952,6 +952,9 @@ namespace ngcomp
     size_t GetDimX() const { return dimx; }
     size_t GetDimY() const { return dimy; }
     size_t GetNIP() const { return nip; }
+
+    FlatMatrix<double> GetPoints() const { return points; }
+    FlatMatrix<double> GetNormals() const { return normals; }
   };  
   
 

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/code_generation.hpp

@@ -57,7 +57,7 @@ namespace ngfem
 
     string pointer;
 
-    NGS_DLL_HEADER string AddPointer(const void *p );
+    NGS_DLL_HEADER string AddPointer(const void *p, string name = "", string type = "void *", string qualifiers = "");
 
     void AddLinkFlag(string flag);
 
@@ -287,7 +287,7 @@ namespace ngfem
   }
 
   std::filesystem::path CreateTempDir();
-  unique_ptr<SharedLibrary> CompileCode(const std::vector<std::variant<filesystem::path, string>> &codes, const std::vector<string> &link_flags, bool keep_files = false );
+  unique_ptr<SharedLibrary> CompileCode(const std::vector<std::variant<filesystem::path, string>> &codes, const std::vector<string> &link_flags, bool keep_files = false, optional<string> compiler = nullopt, optional<string> linker = nullopt);
   namespace detail {
       string GenerateL2ElementCode(int order);
   }

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/complex_wrapper.hpp

@@ -1,15 +1,17 @@
 #ifndef COMPLEX_WRAPPER
 #define COMPLEX_WRAPPER
 
+
+
 #include <complex>
 
+
 #ifdef USE_MYCOMPLEX
 #include <mycomplex.hpp>
 #endif
 
 
 
-
 // #ifdef __clang__
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 namespace std
@@ -25,18 +27,44 @@ namespace std
 
 
 
+
 namespace ngcore
 {
+  
 #ifdef USE_MYCOMPLEX
   typedef ngstd::MyComplex<double> Complex;
   using std::fabs;
-  inline double fabs (Complex v) { return ngstd::abs (v); }
+  INLINE double fabs (Complex v) { return ngstd::abs (v); }
 #else
   typedef std::complex<double> Complex;
   using std::fabs;
   inline double fabs (Complex v) { return std::abs (v); }
 #endif
+  
+}
+
+
+#if defined(__CUDA_ARCH__)
+namespace ngcore
+{
+  __device__ inline Complex conj(Complex a)
+  {
+    return Complex (a.real(), -a.imag());
+  }
+
+  __device__ inline Complex operator+ (Complex a, Complex b) {
+    return Complex(a.real()+b.real(), a.imag()+b.imag());
+  }
+  __device__ inline Complex& operator+= (Complex& a, Complex b) {
+    a = a+b;
+    return a;
+  }
 }
+#endif
+
+
+
+
 
 
 

ngsolve-6.2.2506.post168.dev0.data/data/include/netgen/cuda_core.hpp

@@ -0,0 +1,173 @@
+#ifndef CUDA_CORE_HPP
+#define CUDA_CORE_HPP
+
+#include <cuda_runtime.h>
+
+#include <core/array.hpp>
+#include <core/exception.hpp>
+
+namespace ngs_cuda
+{
+
+
+  // from CUDA C++ Programming Guide:
+  // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#atomic-functions
+#ifdef __CUDA_ARCH__
+#if __CUDA_ARCH__ < 600
+  inline __device__ double atomicAdd(double* address, double val)
+  {
+    unsigned long long int* address_as_ull =
+      (unsigned long long int*)address;
+    unsigned long long int old = *address_as_ull, assumed;
+
+    do {
+      assumed = old;
+      old = atomicCAS(address_as_ull, assumed,
+                      __double_as_longlong(val +
+                                           __longlong_as_double(assumed)));
+
+      // Note: uses integer comparison to avoid hang in case of NaN (since NaN != NaN)
+    } while (assumed != old);
+
+    return __longlong_as_double(old);
+  }
+#endif
+#endif
+
+
+
+  // Kernel wrapper only available if we are compiling the current file with the cuda compiler
+#ifdef __CUDACC__
+   
+  template<class F> __global__
+  void CUDA_forall(int n, F f)
+  {
+    int tid = blockIdx.x*blockDim.x+threadIdx.x;
+    for (int i = tid; i < n; i += blockDim.x*gridDim.x)
+      f(i);
+  }
+
+  template<class F> __global__
+  void CUDA_forall2(int n, F f)
+  {
+    int tid = (blockIdx.x*blockDim.y+threadIdx.y)*blockDim.x+threadIdx.x;
+    for (int i = tid; i < n; i += blockDim.x*blockDim.y*gridDim.x)
+      f(i);
+  }
+    
+#define DEVICE_LAMBDA __device__
+
+  template <class F>
+  inline void DeviceParallelFor (int n, F f)
+  {
+    // CUDA_forall<<<512,256>>> (n, f);
+    CUDA_forall<<<n/256+1,256>>> (n, f);
+    // CUDA_forall<<<4096,32>>> (n, f);           // slower
+    // CUDA_forall2<<<512,dim3(16,16)>>> (n, f);  // same performance
+  }   
+
+#endif // __CUDACC__
+
+
+
+
+
+
+
+  template <typename T>
+  class Dev 
+  {
+    T data;
+    
+  public:
+    __host__ __device__ Dev() = delete;
+    
+    static Dev<T> * Malloc(size_t size)
+    {
+      Dev<T> * ptr;
+      if (auto err = cudaMalloc (&ptr, size*sizeof(T)))
+        throw ngstd::Exception("cudaMalloc error, ec="+ngcore::ToString(err));
+      return ptr;        
+    }
+    
+    static void Free(Dev<T> * data)
+    {
+      cudaFree (data);   
+    }
+
+
+    
+    
+    T D2H() const
+    {
+      T res;
+      cudaMemcpy (&res, &data, sizeof(T), cudaMemcpyDeviceToHost);
+      return res;
+    }
+
+    void H2D (T val)
+
+    {
+      cudaMemcpy (this, &val, sizeof(T), cudaMemcpyHostToDevice);
+    }
+
+    void D2H (ngcore::FlatArray<T> hosta)
+    {
+      cudaMemcpy (hosta.Data(), &data, hosta.Size()*sizeof(T), cudaMemcpyDeviceToHost);
+    }
+
+    void H2D (ngcore::FlatArray<T> hosta)
+    {
+      cudaMemcpy (&data, hosta.Data(), hosta.Size()*sizeof(T), cudaMemcpyHostToDevice);
+    }
+    
+    __host__ __device__ Dev<T> & operator= (T d2)
+    {
+#ifdef __CUDA_ARCH__      
+      data = d2;
+#else
+      H2D(d2);
+#endif
+      return *this;
+    }
+
+    __host__ __device__ operator T() const
+    {
+#ifdef __CUDA_ARCH__
+      return data;
+#else
+      return D2H();
+#endif
+    }
+    
+    __device__ const T& operator*() const { return data; }
+    
+    template <typename T2>
+    __device__ auto & operator+= (T2 other) { data += other; return *this; }
+    template <typename T2>
+    __device__ auto & operator-= (T2 other) { data -= other; return *this; }
+    template <typename T2>
+    __device__ auto & operator*= (T2 other) { data *= other; return *this; }
+  };
+
+
+  template <typename T>
+  Dev<T> * Host2Device (const T& val)
+  {
+    auto ptr = Dev<T>::Malloc(1);
+    ptr->H2D(val);
+    return ptr;
+  }
+
+  template <typename T>
+  void Free(Dev<T> * dp)
+  {
+    Dev<T>::Free (dp);
+  }  
+
+  
+
+}
+
+#endif
+

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/cuda_linalg.hpp

@@ -101,8 +101,10 @@ namespace ngla
 
     bool disjoint_rows, disjoint_cols;
     size_t numblocks;
+    bool output_onto = false;
   public:
     DevConstantElementByElementMatrix (const T_ConstEBEMatrix & mat);
+    void Mult (const BaseVector & x, BaseVector & y) const override;    
     void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
     void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
 
@@ -120,7 +122,9 @@ namespace ngla
     Array<Dev<int>> indices, indices_trans;
  public:
     DevBlockDiagonalMatrixSoA (const BlockDiagonalMatrixSoA & mat);
+    void Mult (const BaseVector & x, BaseVector & y) const override;
     void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    void MultTrans (const BaseVector & x, BaseVector & y) const override;    
     void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
     int VHeight() const override { return dimy*blocks; }
     int VWidth() const override { return dimx*blocks; }

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/cuda_ngbla.hpp

@@ -1,9 +1,22 @@
 #ifndef CUDA_NGBLA
 #define CUDA_NGBLA
 
+#include <cuda_runtime.h>
+#include <cublas_v2.h>
+
+#include <vector.hpp>
+#include <matrix.hpp>
+
 #include "cuda_ngstd.hpp"
 #include "linalg_kernels.hpp"
 
+
+namespace ngla
+{
+  cublasHandle_t Get_CuBlas_Handle ();
+}
+
+
 namespace ngbla
 {
   using namespace ngs_cuda;
@@ -15,15 +28,15 @@ namespace ngbla
   template <typename T>  
   class Vector<Dev<T>> : public FlatVector<Dev<T>>
   { 
-    using FlatVector<Dev<T>>::size;
-    using FlatVector<Dev<T>>::data;
+    using FlatVector<Dev<T>>::Size;
+    using FlatVector<Dev<T>>::Data;
 
   public:
     Vector (Vector&) = delete;
     Vector (Vector&&v2)
       : FlatVector<Dev<T>>(v2.Size(), v2.Data())
     {
-      v2.data = nullptr;
+      v2.layout = { nullptr, 0 };      
     }
          
     Vector (size_t asize)
@@ -37,22 +50,31 @@ namespace ngbla
     
     ~Vector()
     {
-      Dev<T>::Free(data);
+      Dev<T>::Free(Data());
     }
-         
+
+
+    template<typename TB>
+    Vector & operator= (const Expr<TB> & v)
+    {
+      MatExpr<FlatVector<Dev<T>> >::operator= (v);
+      return *this;
+    }
+
+    
     void D2H (FlatVector<T> vec) const
     {
-      cudaMemcpy (vec.Data(), data, sizeof(T)*size, cudaMemcpyDeviceToHost);
+      cudaMemcpy (vec.Data(), Data(), sizeof(T)*Size(), cudaMemcpyDeviceToHost);
     }
 
     void H2D (FlatVector<T> vec)
     {
-      cudaMemcpy (data, vec.Data(), sizeof(T)*size, cudaMemcpyHostToDevice);
+      cudaMemcpy (Data(), vec.Data(), sizeof(T)*Size(), cudaMemcpyHostToDevice);
     }
 
     Vector<T> D2H() const
     {
-      Vector<T> vh(size);
+      Vector<T> vh(Size());
       D2H (vh);
       return vh;
     }
@@ -64,8 +86,74 @@ namespace ngbla
     cudaMemcpy (hvec.Data(), dvec.Data(), sizeof(double)*hvec.Size(), cudaMemcpyDeviceToHost);
     return hvec;
   }
+
+#ifdef OLDOLD
+#ifdef __CUDACC__  
+  template <typename TS, typename TD>
+  __global__ void kernel_Assign (size_t n,  TD pod_dst, TS pod_src)
+  {
+    auto dst = *pod_dst;
+    auto src = *pod_src;
+    
+    int tid = blockIdx.x*blockDim.x+threadIdx.x;
+    for (int i = tid; i < n; i += blockDim.x*gridDim.x)
+      if (i < 5)
+        dst(i) = src.S();
+      else
+        dst(i) = src.A()(i);
+  }
+#endif
+
+  template <typename T>
+  class AsPOD
+  {
+    std::array<char, sizeof(T)> data;
+  public:
+    AsPOD(const AsPOD&) = default;
+    INLINE AsPOD (const T & adata)
+    {
+      char * pdata = (char*)(void*)&adata;
+      for (int i = 0; i < sizeof(T); i++)
+        data[i] = pdata[i];
+    }
+
+    INLINE const T & operator* () const
+    {
+      T * val = (T*)(void*)&data[0];
+      return *val;
+    }
+    INLINE int operator[] (int i) const { return data[i]; }
+  };
+#endif
+  
   
 
+  template <typename TOP, typename T, typename TS, typename TDIST, typename TB>
+  class assign_trait<TOP, VectorView<T,TS,TDIST>, TB,
+                     enable_if_t < std::is_same<std::invoke_result_t<VectorView<T,TS,TDIST>,size_t>, Dev<double>&>::value, int>>
+  {
+  public:
+    static INLINE VectorView<T,TS,TDIST> & Assign (MatExpr<VectorView<T,TS,TDIST>> & self, const Expr<TB> & v)
+    {
+
+#ifdef __CUDACC__ 
+      
+      ngs_cuda::DeviceParallelFor
+        (self.Height(),
+         [devself=self.Spec(), devv=v.Spec()] DEVICE_LAMBDA (auto tid) -> void
+         {
+           // devself(tid) = devv(tid);
+           TOP()(devself(tid),devv(tid));
+         });
+
+#endif
+
+      return self.Spec();
+    }
+  };    
+
+
+
   
     
   template <typename T>  
@@ -137,6 +225,9 @@ namespace ngbla
                         SliceMatrix<Dev<double>, ORDERING::ColMajor> c,
                        double alpha, double beta)
   {
+    static Timer t("cublasDgemm");
+    CudaRegionTimer rt(t);
+
     cublasStatus_t stat =
       cublasDgemm(ngla::Get_CuBlas_Handle(), 
                   ORDA==ORDERING::RowMajor ? CUBLAS_OP_T : CUBLAS_OP_N, 

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/cuda_ngstd.hpp

@@ -4,94 +4,18 @@
 #include <cuda_runtime.h>
 #include <ngstd.hpp>
 
+#include "cuda_core.hpp"
 #include "cuda_profiler.hpp"
 
 namespace ngs_cuda
 {
   using namespace ngstd;
 
-  // from CUDA C++ Programming Guide:
-  // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#atomic-functions
-#ifdef __CUDA_ARCH__
-#if __CUDA_ARCH__ < 600
-  inline __device__ double atomicAdd(double* address, double val)
-  {
-      unsigned long long int* address_as_ull =
-                                (unsigned long long int*)address;
-      unsigned long long int old = *address_as_ull, assumed;
-
-      do {
-          assumed = old;
-          old = atomicCAS(address_as_ull, assumed,
-                          __double_as_longlong(val +
-                                 __longlong_as_double(assumed)));
-
-      // Note: uses integer comparison to avoid hang in case of NaN (since NaN != NaN)
-      } while (assumed != old);
-
-      return __longlong_as_double(old);
-  }
-#endif
-#endif
 
   
   extern int gpu_clock;
   void InitCUDA (int verbose = 2);
 
-
-  template <typename T>
-  class Dev 
-  {
-  public:
-    T data;
-    static Dev<T> * Malloc(size_t size)
-    {
-      Dev<T> * ptr;
-      if (auto err = cudaMalloc (&ptr, size*sizeof(T)))
-        throw Exception("cudaMalloc error, ec="+ToString(err));
-      return ptr;        
-    }
-    
-    static void Free(Dev<T> * data)
-    {
-        cudaFree (data);   
-    }
-
-    T D2H() const
-    {
-      T res;
-      cudaMemcpy (&res, &data, sizeof(T), cudaMemcpyDeviceToHost);
-      return res;
-    }
-
-    void H2D (T val)
-    {
-      cudaMemcpy (&data, &val, sizeof(T), cudaMemcpyHostToDevice);
-    }
-
-
-    void D2H (FlatArray<T> hosta)
-    {
-      cudaMemcpy (hosta.Data(), &data, hosta.Size()*sizeof(T), cudaMemcpyDeviceToHost);
-    }
-
-    void H2D (FlatArray<T> hosta)
-    {
-      cudaMemcpy (&data, hosta.Data(), hosta.Size()*sizeof(T), cudaMemcpyHostToDevice);
-    }
-
-    
-    __device__ Dev<T> & operator= (T d2) { data = d2; return *this; }
-    __device__ operator T() const { return data; } 
-    
-    template <typename T2>
-    __device__ auto & operator+= (T2 other) { data += other; return *this; }
-    template <typename T2>
-    __device__ auto & operator-= (T2 other) { data -= other; return *this; }
-    template <typename T2>
-    __device__ auto & operator*= (T2 other) { data *= other; return *this; }
-  };
-    
 }
 
 namespace ngcore {
@@ -105,43 +29,6 @@ namespace ngcore {
 namespace ngs_cuda
 {
 
-  /*
-  template <typename T>
-  class DevVar
-  {
-    T * ptr;
-  public:
-    DevVar()
-    {
-      cudaMalloc (&ptr, sizeof(T));
-    }
-
-    DevVar(T val)
-    {
-      cudaMalloc (&ptr, sizeof(T));
-      cudaMemcpy (ptr, &val, sizeof(T), cudaMemcpyHostToDevice);
-    }
-
-    operator T () const
-    {
-      T tmp;
-      cudaMemcpy (&tmp, ptr, sizeof(T), cudaMemcpyDeviceToHost);    
-      return tmp;
-    }
-
-    T * DevPtr() const { return ptr; }
-    T & DevRef() const { return *ptr; }
-
-  };
-
-  template <typename T>
-  inline ostream & operator<< (ostream & ost, DevVar<T> & var)
-  {
-    ost << T(var);
-    return ost;
-  }
-  */
-
     // TODO: Resize + error checking
   class DevStackMemory
   {

{ngsolve-6.2.2506.post75.dev0.data → ngsolve-6.2.2506.post168.dev0.data}/data/include/netgen/elementbyelement.hpp

@@ -131,10 +131,13 @@ namespace ngla
   {
     size_t h, w;
     Matrix<SCAL> matrix;
-    Table<int> col_dnums;
-    Table<int> row_dnums;
+    Table<int> col_dnums;   // output
+    Table<int> row_dnums;   // input
     bool disjoint_rows, disjoint_cols;
     Table<int> row_coloring, col_coloring;
+    bool output_onto = false;
+    bool output_matrix = false;
+    bool output_matrix_trans = false;
   public:
     ConstantElementByElementMatrix (size_t ah, size_t aw, Matrix<SCAL> amatrix,
                                     Table<int> acol_dnums, Table<int> arow_dnums);