Changeset ab4c03e in tol

Timestamp:

Nov 25, 2009, 8:02:47 PM (17 years ago)

Author:

Víctor de Buen <vdebuen@…>

Branches:

1941-docker-image-to-test, devel, master

Children:

c7623c38

Parents:

752eb20

Message:

Fixes #787

git-svn-id: ​https://www.tol-project.org/svn/tolp/trunk@1730 be4846ae-f051-483a-831f-b64e7d08527f

Location:

tol/btol/vmatrix_type

Files:

• tol_bvmat.h (modified) (2 diffs)
• vmat.cpp (modified) (3 diffs)
• vmat_convert.cpp (modified) (2 diffs)
• vmat_io.cpp (modified) (3 diffs)
• vmatgra.cpp (modified) (2 diffs)

tol/btol/vmatrix_type/tol_bvmat.h

@@ -266 +266 @@
 //Copy operator
   const BVMat& operator = (const BVMat& v);  
+  ECode Code() const { return(code_); }
   int  Check       () const;
   void Pack        ();
+  void Pack        (double sparsity);
   void Copy        (const BVMat& v);
   void BlasRDense  (int nrow, int ncol);
@@ -335 +337 @@
                                const BVMat& a);
 private:
+  static size_t bytes_blasRdense(int nzmax);
+  static size_t bytes_chlmRsparse(int nzmax, int ncol, bool packed);
   size_t bytes_blasRdense  () const;
   size_t bytes_chlmRsparse () const;

tol/btol/vmatrix_type/vmat.cpp

@@ -288 +288 @@
 ////////////////////////////////////////////////////////////////////////////////
 {
+  int nz,ncol,nrow,dense_size,sparse_size;
+  BVMat aux;
   switch(code_) {
   case(ESC_blasRdense  ) : 
   {
+    nz = NonNullCells(0);
+    ncol=Columns();
+    nrow=Rows();
+    dense_size = bytes_blasRdense(nrow*ncol);
+    sparse_size = bytes_chlmRsparse(nz, ncol, true);
+    if(sparse_size<dense_size)
+    {
+      aux.Convert(*this,ESC_chlmRsparse);
+      *this = aux;
+    }
     break;
   }
   case(ESC_chlmRsparse ) : 
   {
-    int nnz = NonNullCells(0);
-    if(s_.chlmRsparse_->nzmax > nnz)
-    {
-      cholmod_drop(0,s_.chlmRsparse_, common_);
-    }
-    cholmod_sort(s_.chlmRsparse_, common_);
-    break;
+    cholmod_drop(0,s_.chlmRsparse_, common_);
+    nz = NonNullCells(0);
+    ncol=Columns();
+    nrow=Rows();
+    dense_size = bytes_blasRdense(nrow*ncol);
+    sparse_size = bytes_chlmRsparse(nz, ncol, true);
+    if(sparse_size>dense_size)
+    {
+      aux.Convert(*this,ESC_blasRdense);
+      *this = aux;
+    }
+    else
+    {
+      cholmod_sort(s_.chlmRsparse_,   common_);
+    }
+    break;
+  }
+  case(ESC_chlmRtriplet) : 
+  {
+    Drop(0);
+    nz = NonNullCells(0);
+    ncol=Columns();
+    nrow=Rows();
+    dense_size = bytes_blasRdense(nrow*ncol);
+    sparse_size = bytes_chlmRsparse(nz, ncol, true);
+    if(sparse_size<dense_size)
+    {
+      aux.Convert(*this,ESC_chlmRsparse);
+    }
+    else
+    {
+      aux.Convert(*this,ESC_blasRdense);
+    }
+    *this = aux;
+    break; 
   }
   case(ESC_chlmRfactor ) : 
@@ -307 +347 @@
     cholmod_pack_factor(s_.chlmRfactor_,common_);
     break;
-  }
-  case(ESC_chlmRtriplet) : 
-  {
-    int nnz = NonNullCells(0);
-    if(s_.chlmRtriplet_->nzmax > nnz)
-    {
-      Drop(0);
-    }
-    break; 
   }
   default: 
     Error(I2("FATAL ERROR in",
-             "ERROR FATAL en")+" BVMat::Pack(const BVMat& v)"); 
+             "ERROR FATAL en")+" BVMat::Pack()"); 
+    assert(1); }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+  void BVMat::Pack(double sparsity)
+//Importing method
+////////////////////////////////////////////////////////////////////////////////
+{
+  if(sparsity==BDat::Nan()) { Pack(); return; }
+  int nz,ncol,nrow;
+  double sparseRatio;
+  BVMat aux;
+  switch(code_) {
+  case(ESC_blasRdense  ) : 
+  {
+    nz = NonNullCells(0);
+    ncol=Columns();
+    nrow=Rows();
+    sparseRatio = 1.0 - double(nz)/double(nrow*ncol);
+    if(sparseRatio>sparsity)
+    {
+      aux.Convert(*this,ESC_chlmRsparse);
+      *this = aux;
+    }
+    break;
+  }
+  case(ESC_chlmRsparse ) : 
+  {
+    cholmod_drop(0,s_.chlmRsparse_, common_);
+    nz = NonNullCells(0);
+    ncol=Columns();
+    nrow=Rows();
+    sparseRatio = 1.0 - double(nz)/double(nrow*ncol);
+    if(sparseRatio<sparsity)
+    {
+      aux.Convert(*this,ESC_blasRdense);
+      *this = aux;
+    }
+    else
+    {
+      cholmod_sort(s_.chlmRsparse_,   common_);
+    }
+    break;
+  }
+  case(ESC_chlmRtriplet) : 
+  {
+    Drop(0);
+    nz = NonNullCells(0);
+    ncol=Columns();
+    nrow=Rows();
+    sparseRatio = 1.0 - double(nz)/double(nrow*ncol);
+    if(sparseRatio>=sparsity)
+    {
+      aux.Convert(*this,ESC_chlmRsparse);
+    }
+    else
+    {
+      aux.Convert(*this,ESC_blasRdense);
+    }
+    *this = aux;
+    break; 
+  }
+  case(ESC_chlmRfactor ) : 
+  {
+    cholmod_pack_factor(s_.chlmRfactor_,common_);
+    break;
+  }
+  default: 
+    Error(I2("FATAL ERROR in",
+             "ERROR FATAL en")+" BVMat::Pack()"); 
     assert(1); }
 };
@@ -1075 +1176 @@
   int c = Columns();
   double cells = StoredCells();
+  double nz = NonNullCells();
   double denseCells = (double)r*(double)c;
-  double cellPercent = round(10000.0*cells/denseCells)/100.0;
   double bytes = Bytes();
   double denseBytes = sizeof(BVMat)+sizeof(cholmod_dense)+ 
                      (denseCells)*sizeof(double);
+  double nzPercent = round(10000.0*nz/denseCells)/100.0;
+  double cellPercent = round(10000.0*cells/denseCells)/100.0;
   double bytesPercent = round(10000.0*bytes/denseBytes)/100.0;
   aux +=BText("\n")+ 
+        " Non zero cells "+nz+"/("+r+"x"+c+")="+nzPercent+"%\n"+
         " Stored cells "+cells+"/("+r+"x"+c+")="+cellPercent+"%\n"+
         " Stored bytes "+bytes+"/"+denseBytes+"="+bytesPercent+"%\n"; 

tol/btol/vmatrix_type/vmat_convert.cpp

@@ -198 +198 @@
   B_ = (BVMat*)&B;
   int result = 0;
-  if((A.code_==ESC_chlmRsparse) && (B.code_!=ESC_chlmRsparse))
+  if((A.code_==ESC_chlmRsparse) && (B.code_==ESC_chlmRsparse))
+  {
+    result = -1;
+  }
+  else if((A.code_==ESC_chlmRsparse) && (B.code_!=ESC_chlmRsparse))
   { 
     warn_convert2cRs(fName,B);
@@ -254 +258 @@
   B_ = (BVMat*)&B;
   int result = 0;
-  if((A.code_==ESC_blasRdense) && (B.code_!=ESC_blasRdense))
+  if((A.code_==ESC_blasRdense) && (B.code_==ESC_blasRdense))
+  {
+    result = -1;
+  }
+  else if((A.code_==ESC_blasRdense) && (B.code_!=ESC_blasRdense))
   { 
     warn_convert2bRd(fName,B);

tol/btol/vmatrix_type/vmat_io.cpp

@@ -381 +381 @@
 
 ////////////////////////////////////////////////////////////////////////////////
+  size_t BVMat::bytes_blasRdense(int nzmax) 
+//Exporting method
+////////////////////////////////////////////////////////////////////////////////
+{
+  return(sizeof(cholmod_dense)+ nzmax*sizeof(double));
+};
+
+////////////////////////////////////////////////////////////////////////////////
+  size_t BVMat::bytes_chlmRsparse(int nzmax, int ncol, bool packed) 
+//Exporting method
+////////////////////////////////////////////////////////////////////////////////
+{
+  return(sizeof(cholmod_sparse)+ 
+         (ncol+1+((packed)?0:ncol))*sizeof(int)+
+         nzmax*(sizeof(int) + sizeof(double)) );
+};
+
+////////////////////////////////////////////////////////////////////////////////
   size_t BVMat::bytes_blasRdense() const
 //Exporting method
@@ -386 +404 @@
 {
   cholmod_dense& a = *s_.blasRdense_;
-  return(sizeof(cholmod_dense)+ a.nzmax*sizeof(double));
+  return(bytes_blasRdense(a.nzmax));
 };
 
@@ -395 +413 @@
 {
   cholmod_sparse& a = *s_.chlmRsparse_;
-  return(sizeof(cholmod_sparse)+ 
-         (a.ncol+1+((a.packed)?0:a.ncol))*sizeof(int)+
-         a.nzmax*(sizeof(int) + sizeof(double)) );
+  return(bytes_chlmRsparse(a.nzmax,a.ncol,a.packed!=0));
 };
 

tol/btol/vmatrix_type/vmatgra.cpp

@@ -468 +468 @@
 //--------------------------------------------------------------------
 DeclareContensClass(BVMat, BVMatTemporary, BVMatPack);
-DefExtOpr(1, BVMatPack, "Pack", 1, 1, 
-  "VMatrix",
-  "(VMatrix data)",
-  I2("Packs an sparse matrix to be stored in the minimum posible size."
-     "It has no effect over non sparse matrices.",
-     "Empaqueta una matriz sparse para que ocupe el mínimo espacio posible."
-     "No tiene ningún efecto sobre matrices no sparse."),
+DefExtOpr(1, BVMatPack, "Pack", 1, 2, 
+  "VMatrix Real",
+  "(VMatrix data [, Real sparsity=?])",
+  I2("Converts a virtual matrix to be stored in the optimal way:"
+     " * Converts a dense matrix to sparse if it has enough zero cells, ie if \n"
+     "  1-VNonNullCells(M)/(VRows(M)*VColumns(M)) >= sparsity\n"
+     " * Converts an sparse matrix to dense if it hasn't enough zero cells, ie if \n"
+     "  1-VNonNullCells(M)/(VRows(M)*VColumns(M)) <= sparsity\n"
+     " Sparse matrices will be packed internally in other case.\n"
+     " * Converts triplet matrices to dense or sparse, following the same explained "
+     "rules\n"
+     "If argument 'sparsity' is unknown then it will be calculated to ensure the "
+     "minimum size of returned matrix."
+,
+     "Convierte una matriz virtual para ser almacenados en la forma óptima:\n"
+     " * Convierte una matriz densa a escasa si tiene bastantes celdas cero, es decir, si\n"
+     "1-VNonNullCells (M) / (VRows (M) * VColumns (M))> = sparsity\n"
+     "* Convierte una matriz dispersa a densa si no hay bastantes celdas cero, es decir, si\n"
+     "1-VNonNullCells (M) / (VRows (M) * VColumns (M)) <= sparsity\n"
+     "Si no es así, las matrices sparse serán empaquetadas al máximo internamente.\n"
+     "* Convierte las matrices triplet a denso o sparse según estas mismas reglas\n"
+     "* Las matrices factor serán empaquetadas al máximo internamente\n"
+     "Si el argumento 'sparsity' es desconocido entonces será calculado "
+     "para garantizar el mínimo tamaño posible de la matriz devuelta."),
 BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -480 +497 @@
 //--------------------------------------------------------------------
 {
-  contens_.Copy(VMat(Arg(1)));
-  contens_.Pack();
+  contens_ = VMat(Arg(1));
+  if(Arg(2)) 
+  { 
+    double sparsity = Real(Arg(2));
+    contens_.Pack(sparsity); 
+  }
+  else
+  {
+    contens_.Pack(); 
+  }
   assert(contens_.Check());
 }