Changeset 519d0f3 in tol

Timestamp:

Aug 26, 2010, 11:12:48 AM (16 years ago)

Author:

Víctor de Buen <vdebuen@…>

Branches:

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

Children:

daf1fa0

Parents:

cdcc881

Message:

New function Histogram faster than Frequency

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

Location:

tol/btol/vmatrix_type

Files:

• tol_bvmat.h (modified) (3 diffs)
• vmat_convert.cpp (modified) (2 diffs)
• vmat_stats.cpp (modified) (1 diff)
• vmatgra.cpp (modified) (1 diff)

tol/btol/vmatrix_type/tol_bvmat.h

@@ -436 +436 @@
   void DMat2triplet(const BMatrix<double>& d, int nrow, int columns,
                     const BArray<int>& rowIdx, const BArray<int>& colIdx);
+  bool AddTriplet(const BMatrix<double>& ijx);
   void BSet2sparse (const BSet& sparseDef);
   void BPol2sparse (const BPolyn<BDat>& pol_, int nrow, int ncol);
@@ -532 +533 @@
   void TruncStdGaussian(const BVMat& D, const BVMat& d_, 
                         const BVMat& z0_, int ncol, int burnin);
+  void Histogram(const BVMat& M, int parts);
+  void Histogram(const BVMat& M, int parts, double min, double max);
 private:
   static cholmod_dense_struct*   bRd_rand(int nrow, int ncol,
@@ -541 +544 @@
                                       BVMat& b, 
                                       BVMat& z);
+  void Histogram_bRd(const BVMat& M, int parts);
+  void Histogram_bRd(const BVMat& M, int parts, double min, double max);
   
 /*------------------------------------------------------------------------------

tol/btol/vmatrix_type/vmat_convert.cpp

@@ -307 +307 @@
   { 
     warn_convert2bRd(fName,A);
-    A_ = new BVMat(A, ESC_blasRdense); 
+    A_ = new BVMat;
+    A_->Convert(A, ESC_blasRdense); 
   }
   return(0);
@@ -616 +617 @@
 };
 
-
+////////////////////////////////////////////////////////////////////////////////
+  bool BVMat::AddTriplet(const BMatrix<double>& ijx)
+////////////////////////////////////////////////////////////////////////////////
+{
+  static BText fName = "AddTriplet(Matrix triplets)";
+  Error(BText("Still not impemented function VMatrix ")+fName);
+  return(false);
+/*
+  int k, n = ijx.Rows();
+  bool ok = true;
+  if(code_  != ESC_chlmRtriplet)
+  {
+    err_wrong_defined(fName, *this);
+    ok = false;
+  }
+  else
+  {
+    int nrow; 
+    int ncol;
+    cholmod_triplet *all = cholmod_allocate_triplet
+      (nrow,ncol,n,0,CHOLMOD_REAL,common_);
+    int*    r_ = (int*)   s_.chlmRtriplet_->i;
+    int*    c_ = (int*)   s_.chlmRtriplet_->j;
+    double* x_ = (double*)s_.chlmRtriplet_->x;
+    for(k=0; k<n; k++)
+    {
+      r_[k] = (int)ijx(k,0)-1;
+      c_[k] = (int)ijx(k,1)-1;
+      x_[k] = ijx(k,2);
+      if((r_[k]<0)||(r_[k]>=nrow))
+      {
+        err_cannot_apply(fName, 
+          BText("Row index ")+(r_[k]+1)+" out of range 1..."+(nrow+1), 
+          *this);
+        ok = false;
+        break;
+      }
+      else if((c_[k]<0)||(c_[k]>=ncol))
+      {
+        err_cannot_apply(fName, 
+          BText("Columns index ")+(c_[k]+1)+" out of range 1..."+(ncol+1), 
+          *this);
+        ok = false;
+        break;
+      }
+      s_.chlmRtriplet_->nnz++; 
+    }
+  }
+  return(false);
+*/
+};
 
 ////////////////////////////////////////////////////////////////////////////////

tol/btol/vmatrix_type/vmat_stats.cpp

@@ -779 +779 @@
 };
 
-
+////////////////////////////////////////////////////////////////////////////////
+  void BVMat::Histogram_bRd(const BVMat& M, int parts, double min, double max)
+////////////////////////////////////////////////////////////////////////////////
+{
+  int i,j,p;
+  int n = M.s_.blasRdense_->nzmax;
+  int r = M.s_.blasRdense_->nrow;
+  int c = M.s_.blasRdense_->ncol;
+  BlasRDense(parts, c+1);
+  BArray<double> sorted(r);
+  double* h = (double*)s_.blasRdense_->x; 
+  double step = (max-min)/double(parts);
+  for(p=0; p<parts-1; p++)
+  {
+    *(h++) = min+step*(p+1);
+  }
+  *(h++) = max;
+  memset(h,0,sizeof(double)*parts*c);
+  const double* x = (const double*)M.s_.blasRdense_->x; 
+  for(j=0; j<c; j++)
+  {
+    double* h0 = ((double*)s_.blasRdense_->x)+r*j;
+    for(i=0; i<r; i++, x++)
+    {
+      p = (int)((*x-min)/step)-1;
+      if(p<0) { p=0; }
+      if(p>=parts) { p=parts-1; }
+      h0[p] += 1.0/parts;
+    }
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+  void BVMat::Histogram_bRd(const BVMat& M, int parts)
+////////////////////////////////////////////////////////////////////////////////
+{
+  int k;
+  int n = M.s_.blasRdense_->nzmax;
+  double* x = (double*)M.s_.blasRdense_->x; 
+  double min = BDat::PosInf();
+  double max = BDat::NegInf();
+  for(k=0; k<n; k++, x++)
+  {
+    if(*x<min) { min=*x; }
+    if(*x>max) { max=*x; }
+  }
+  Histogram_bRd(M,parts,min,max);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+  void BVMat::Histogram(const BVMat& M_, int parts, double min, double max)
+////////////////////////////////////////////////////////////////////////////////
+{
+  BVMat *M__=NULL;
+  convertIfNeeded_all2bRd(M_, M__, "Histogram");  
+  BVMat &M = *M__;
+  Histogram_bRd(M,parts,min,max);
+  if(M__!=&M_) { delete M__; }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+  void BVMat::Histogram(const BVMat& M_, int parts)
+////////////////////////////////////////////////////////////////////////////////
+{
+  BVMat *M__=NULL;
+  convertIfNeeded_all2bRd(M_, M__, "Histogram");
+  BVMat &M = *M__;
+  Histogram_bRd(M,parts);
+  if(M__!=&M_) { delete M__; }
+}

tol/btol/vmatrix_type/vmatgra.cpp

@@ -2536 +2536 @@
 }
 
-
+//--------------------------------------------------------------------
+DeclareContensClass(BVMat, BVMatTemporary, BVMatHistogram);
+DefExtOpr(1, BVMatHistogram,  "Histogram", 2, 4, "VMatrix Real Real Real",
+  "(VMatrix M, Real p [, Real min, Real max])",
+  I2("Makes a frequency analysis of p intervals for the each column "
+     "of a matrix M:rxc and returns a matrix with c+1 columns and p rows. "
+     "In the first column contains the upper bound of each interval. "
+     "The rest of columns j=2..c+1 contain the ratio of values of (j-1)-th "
+     "column of M belonging to the interval corresponding to the row.",
+     "Hace un analisis de frecuencia de p intervalos para cada  "
+     "columna de una matriz M:rxc y devuelve una matriz con c+1 columnas y p filas. "
+     "La primera columna contiene el limite superior de cada intervalo. "
+     "Las siguientes columnas j=2..c+1 contienen la proporción de valores de "
+     "la columna (j-1)-ésima de M que pertenecen al intervalo correspondiente "
+     "a la fila.")+"\n"+
+  I2("Defining the size of internal intervals as ",
+     "Definiendo el tamaño de los intervalos interiores como ")+"\n"+
+     "  h = (max-min)/p\n"+
+  I2("we will have the next p intervals",
+     "tendremos los siguientes p intervalos")+"\n"+
+     " min         < x <= min + h          \n"+
+     " min+h       < x <= min + h*2        \n"+
+     "              ...                    \n"+
+     " min+h*(p-1) < x <= min + h*p = max  \n",
+    BOperClassify::Statistic_);
+//--------------------------------------------------------------------
+void BVMatHistogram::CalcContens()
+//--------------------------------------------------------------------
+{
+  BVMat& M = VMat (Arg(1));
+  int  parts = (BInt)Real(Arg(2));
+  if(Arg(3) && Arg(4)) 
+  { 
+    double min = Real(Arg(3));
+    double max = Real(Arg(4));
+    contens_.Histogram(M,parts,min,max);
+  }
+  else
+  {
+    contens_.Histogram(M,parts);
+  }
+//contens_.Pack(0.5)
+}
+
+/*
+//--------------------------------------------------------------------
+class BSetMergeTriplet: public BExternalOperator
+//--------------------------------------------------------------------
+{
+public:
+  BSetMergeTriplet()
+  : BExternalOperator
+    (
+      "MergeTriplet", GraVMatrix(), "VMatrix Matrix", NIL, 2, 2,
+      "(VMatrix cum, Matrix triplets)",
+                  I2(""  ,
+               ""),
+                  BOperClassify::MatrixtAlgebra_
+    )
+  {
+  }
+
+ ~BSetMergeTriplet() {}
+
+  BSyntaxObject* Evaluator(BList* arg) const
+  { 
+    if(CheckNonDeclarativeAction("MergeTriplet")) { return(NULL); }
+    BUserSet* uCum = UVMat(lst->Car());
+    BVMat& cum = uCum->Contens();
+    BMat& triplets = Mat(Arg(lst->Cdr()->Car()));
+    cum.AddTriplet(triplets);
+    SAFE_DESTROY(arg, uCum);
+    return(uCum);
+  }
+ private:
+  DeclareClassNewDelete(BSetMergeTriplet);
+};
+*/
+
+