Changeset 53456bc in tol

Timestamp:

May 17, 2015, 9:07:07 AM (11 years ago)

Author:

Víctor de Buen <vdebuen@…>

Branches:

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

Children:

1e43dec

Parents:

2789f1d

Message:

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

Location:

tol/btol

Files:

• matrix_type/matgra.cpp (modified) (1 diff)
• real_type/datgrav.cpp (modified) (8 diffs)
• vmatrix_type/tol_bvmat.h (modified) (2 diffs)
• vmatrix_type/vmat_chol.cpp (modified) (3 diffs)
• vmatrix_type/vmatgra.cpp (modified) (1 diff)

tol/btol/matrix_type/matgra.cpp

@@ -4662 +4662 @@
   {
     contens_(i,0)=i+1;
-    contens_(i,1)=acf(i);
+    contens_(i,1)=pacf(i);
     contens_(i,2)=sigma;
   }

tol/btol/real_type/datgrav.cpp

@@ -809 +809 @@
   if(g->Grammar()==GraText())
   {
+    const BText& gt = Text(g);
     graOpt.AllocBuffer(1);
-    graOpt[0] = FindGrammar(Text(g));
+    graOpt[0] = FindGrammar(gt);
   }
   else if(g->Grammar()==GraSet())
@@ -889 +890 @@
 }
 
+
+//--------------------------------------------------------------------
+  bool DestroyIdNeeded(BSyntaxObject*& result, int nObj0)
+//--------------------------------------------------------------------
+{
+  if(result)
+  {
+    return(false);
+  }
+  {
+    int nObj1 = AliveObjects();
+    if(nObj1>nObj0) 
+    { 
+      DESTROY(result);
+      result = NULL;
+      return(true);
+    }
+    else
+    {
+      return(false);
+    }
+  }
+};
+
 //--------------------------------------------------------------------
   DeclareContensClass(BDat, BDatTemporary, BDatObjectExist);
@@ -901 +926 @@
 {
   BSyntaxObject* g = Arg(1);
-  const BText&  name = Text(Arg(2));
+  const BText& name = Text(Arg(2));
   BArray<BSyntaxObject*> graOpt;
   int i;
@@ -909 +934 @@
   contens_ = false;
   if(!GetGrammarOptions(g, graOpt)) { return; }
+  int nObj0 = AliveObjects();
   for(i=0; !result && (i<graOpt.Size()); i++)
   {
@@ -930 +956 @@
       if(result && Set(result).Struct()!=found)
       {
-        result = NULL;
+        DestroyIdNeeded(result, nObj0);
       }
     }
@@ -942 +968 @@
         if(!nb.IsInstanceOf((BClass*)found))
         {  
-          result = NULL;
+          DestroyIdNeeded(result, nObj0);
         }  
       }
@@ -948 +974 @@
   }
   contens_ = result!=NULL;  
+  DestroyIdNeeded(result, nObj0);
 }
 
@@ -2155 +2182 @@
 {
   contens_ = Dat(Arg(1));
-  BSys::SleepMilliSeconds((BInt)contens_.Value()*1000);
+  BSys::SleepMilliSeconds((int)(contens_.Value()*1000.0));
 }
 

tol/btol/vmatrix_type/tol_bvmat.h

@@ -742 +742 @@
   BVMat CholeskiSolve(const BVMat& B, const BText& sys)const;
   BVMat CholeskiInv  ()const;
+  int CholeskiUpdate (const BVMat& C_, bool upDown);
+  int CholeskiAddRow (const BVMat& R_, int rowPos);
+  int CholeskiDelRow (const BVMat& R_, int rowPos);
 
   static int CholeskiFactor(const BVMat& X, BVMat& L, 
@@ -755 +758 @@
   static int CholeskiInv   (const BVMat& X, BVMat& Xi);
   static int CholeskiMinRes(const BVMat& X, const BVMat& b, BVMat& a);
+  static int CholeskiUpdate (const BVMat& L, const BVMat& C_, bool upDown);
+  static int CholeskiAddRow (const BVMat& L, const BVMat& R_, int rowPos);
+  static int CholeskiDelRow (const BVMat& L, const BVMat& R_, int rowPos);
   
 private:

tol/btol/vmatrix_type/vmat_chol.cpp

@@ -76 +76 @@
   res = cholmod_factorize(X.s_.chlmRsparse_,L.s_.chlmRfactor_,common_);
   TRACE_CHOLMOD_ALLOCATE("Cholmod.R.Factor",X.s_.chlmRsparse_)
-  isNotPosDef = (L.s_.chlmRfactor_->minor<L.s_.chlmRfactor_->n);
+  
+  isNotPosDef = (common_->status == CHOLMOD_NOT_POSDEF)||
+                (L.s_.chlmRfactor_->minor<L.s_.chlmRfactor_->n);
   cholmod_change_factor
   (
@@ -739 +741 @@
   
 
-
 ////////////////////////////////////////////////////////////////////////////////
   BVMat BVMat::CholeskiSolve(const BVMat& B, ECholSolSys sys) const
@@ -810 +811 @@
   return(0);
 };
+
+
+////////////////////////////////////////////////////////////////////////////////
+  int BVMat::CholeskiUpdate (const BVMat& L, const BVMat& C_, bool upDown)
+////////////////////////////////////////////////////////////////////////////////
+{
+  if(!L .CheckDefined("CholeskiUpdate")) { return(-1); }
+  if(!C_.CheckDefined("CholeskiUpdate")) { return(-1); }
+  int result = 0;
+  BVMat *C__=NULL;
+  if(L.code_==ESC_chlmRfactor)
+  {
+    convertIfNeeded_all2cRs(C_,C__,"CholeskiUpdate");
+  }
+  else
+  {
+    err_invalid_subtype("CholeskiUpdate",L);
+    result = -2;
+    return(result);
+  }
+  BVMat &C = *C__;
+  cholmod_factor* l = L.s_.chlmRfactor_;
+  cholmod_sparse* c = cholmod_submatrix(
+    C.s_.chlmRsparse_, (int*)l->Perm, l->n, NULL, -1, 1, 1, common_);
+  result = cholmod_updown(upDown, c, l, common_);
+  bool isNotPosDef = (common_->status == CHOLMOD_NOT_POSDEF)||
+                (L.s_.chlmRfactor_->minor<L.s_.chlmRfactor_->n);
+  if(isNotPosDef)
+  {
+    result == -1;
+    err_cannot_apply("CholeskiUpdate","",L); 
+  }
+  else
+  {
+    CholmodFree_sparse(&c,common_);
+    
+  }
+  if(C__!=&C_) { delete C__; }
+  return(result);
+}
+   
+
+////////////////////////////////////////////////////////////////////////////////
+  int BVMat::CholeskiUpdate (const BVMat& C_, bool upDown)
+//Matrix algebra operator
+////////////////////////////////////////////////////////////////////////////////
+{
+  return(CholeskiUpdate(*this,C_,upDown));
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+  int BVMat::CholeskiAddRow (const BVMat& L, const BVMat& R_, int rowPos)
+////////////////////////////////////////////////////////////////////////////////
+{
+  if(!L .CheckDefined("CholeskiAddRow")) { return(-1); }
+  if(!R_.CheckDefined("CholeskiAddRow")) { return(-1); }
+  int result = 0;
+  BVMat *R__=NULL;
+  if(L.code_==ESC_chlmRfactor)
+  {
+    convertIfNeeded_all2cRs(R_,R__,"CholeskiAddRow");
+  }
+  else
+  {
+    err_invalid_subtype("CholeskiAddRow",L);
+    result = -2;
+    return(result);
+  }
+  BVMat &R = *R__;
+  result = cholmod_rowadd(rowPos, R.s_.chlmRsparse_, L.s_.chlmRfactor_, common_);
+  if(R__!=&R_) { delete R__; }
+  return(result);
+}
+   
+
+////////////////////////////////////////////////////////////////////////////////
+  int BVMat::CholeskiAddRow (const BVMat& R_, int rowPos)
+//Matrix algebra operator
+////////////////////////////////////////////////////////////////////////////////
+{
+  return(CholeskiAddRow(*this,R_,rowPos));
+};
+
+////////////////////////////////////////////////////////////////////////////////
+  int BVMat::CholeskiDelRow (const BVMat& L, const BVMat& R_, int rowPos)
+////////////////////////////////////////////////////////////////////////////////
+{
+  if(!L .CheckDefined("CholeskiDelRow")) { return(-1); }
+  if(!R_.CheckDefined("CholeskiDelRow")) { return(-1); }
+  int result = 0;
+  BVMat *R__=NULL;
+  if(L.code_==ESC_chlmRfactor)
+  {
+    convertIfNeeded_all2cRs(R_,R__,"CholeskiDelRow");
+  }
+  else
+  {
+    err_invalid_subtype("CholeskiDelRow",L);
+    result = -2;
+    return(result);
+  }
+  BVMat &R = *R__;
+  result = cholmod_rowdel(rowPos, R.s_.chlmRsparse_, L.s_.chlmRfactor_, common_);
+  if(R__!=&R_) { delete R__; }
+  return(result);
+}
+   
+
+////////////////////////////////////////////////////////////////////////////////
+  int BVMat::CholeskiDelRow (const BVMat& R_, int rowPos)
+//Matrix algebra operator
+////////////////////////////////////////////////////////////////////////////////
+{
+  return(CholeskiDelRow(*this,R_,rowPos));
+};
+
+
+

tol/btol/vmatrix_type/vmatgra.cpp

@@ -2333 +2333 @@
 
 
+//--------------------------------------------------------------------
+DeclareContensClass(BDat, BDatTemporary, BDatCholeskiUpdate);
+DefExtOpr(1, BDatCholeskiUpdate, "CholeskiUpdate", 3, 3, 
+  "VMatrix VMatrix Real",
+  "(VMatrix L, VMatrix C, Real upDown)",
+  "Updates a LL' Cholesky factorization computing LL'+CC' if upDown "
+  "is true or LL'-CC' in other case.",
+  BOperClassify::MatrixAlgebra_);
+//--------------------------------------------------------------------
+void BDatCholeskiUpdate::CalcContens()
+//--------------------------------------------------------------------
+{
+  contens_ = BVMat::CholeskiUpdate(VMat(Arg(1)), VMat(Arg(2)), (bool)Real(Arg(3)));
+}
+
+
+//--------------------------------------------------------------------
+DeclareContensClass(BDat, BDatTemporary, BDatCholeskiAddRow);
+DefExtOpr(1, BDatCholeskiAddRow, "CholeskiAddRow", 3, 3, 
+  "VMatrix VMatrix Real",
+  "(VMatrix factor, VMatrix rowData, Real rowPos)",
+  "Adds a new row to a Cholesky factorization.",
+  BOperClassify::MatrixAlgebra_);
+//--------------------------------------------------------------------
+void BDatCholeskiAddRow::CalcContens()
+//--------------------------------------------------------------------
+{
+  contens_ = BVMat::CholeskiAddRow(VMat(Arg(1)), VMat(Arg(2)), (int)Real(Arg(3)));
+}
+
+//--------------------------------------------------------------------
+DeclareContensClass(BDat, BDatTemporary, BDatCholeskiDelRow);
+DefExtOpr(1, BDatCholeskiDelRow, "CholeskiDelRow", 3, 3, 
+  "VMatrix VMatrix Real",
+  "(VMatrix factor, VMatrix rowData, Real rowPos)",
+  "Deletes a row to a Cholesky factorization.",
+  BOperClassify::MatrixAlgebra_);
+//--------------------------------------------------------------------
+void BDatCholeskiDelRow::CalcContens()
+//--------------------------------------------------------------------
+{
+  contens_ = BVMat::CholeskiDelRow(VMat(Arg(1)), VMat(Arg(2)), (int)Real(Arg(3)));
+}
+
 /*------------------------------------------------------------------------------
   vmat_stats.cpp: Statistics methods