Changeset 94894c73 in tol


Ignore:
Timestamp:
Oct 12, 2009, 5:02:45 PM (17 years ago)
Author:
Víctor de Buen <vdebuen@…>
Branches:
1941-docker-image-to-test, devel, master
Children:
5d790bd
Parents:
98a619e
Message:

Fixed #757

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

Location:
tol
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • tol/btol/vmatrix_type/tol_bvmat_bsr_impl.h

    r98a619e r94894c73  
    552552
    553553///////////////////////////////////////////////////////////////////////////////
     554class assign_reg_matrix
     555///////////////////////////////////////////////////////////////////////////////
     556{
     557public:
     558  BText& desc_;
     559  BText& expr_;
     560  BVMat& vmat_;
     561
     562  assign_reg_matrix(BText& desc, BText& expr, BVMat& vmat)
     563  : desc_(desc),
     564    expr_(expr),
     565    vmat_(vmat)
     566  {}
     567  void action(const std::string& str) const
     568  {
     569    assign_reg_matrix& t = *((assign_reg_matrix*)this);
     570    t.expr_.Copy(str.c_str()+2, str.size()-4);
     571  //Std(BSR()+" assign_reg_matrix\n  desc_ = "+desc_+"\n  expr_="+t.expr_);
     572    BSyntaxObject* obj = GraAnything()->EvaluateExpr(t.expr_);
     573    if(!obj)
     574    {
     575      Error(BText("Cannot create ")+desc_+" from TOL expression \n"+expr_);
     576    }
     577    else if(obj->Grammar()==GraVMatrix())
     578    {
     579      t.vmat_ = VMat(obj);
     580    }
     581    else if(obj->Grammar()==GraMatrix())
     582    {
     583      BMat& M = Mat(obj);
     584      t.vmat_.DMat2VMat((BMatrix<double>&)M, false, .50, 0.0);
     585    }
     586    else
     587    {
     588      Error(BText("Cannot create ")+desc_+" from TOL expression \n"+expr_+"\n"
     589            " This expression is returning a "+obj->Grammar()->Name()+
     590            " instead of a Matrix or VMatrix");
     591    }
     592  }
     593  void operator()(const std::string& str) const
     594  {
     595    action(str);
     596  }
     597
     598  template<typename IteratorT>
     599  void operator()(IteratorT first, IteratorT last) const
     600  {
     601    std::string str;
     602    str.assign(first, last);
     603    action(str);
     604  }
     605
     606};
     607
     608
     609///////////////////////////////////////////////////////////////////////////////
     610class assign_const_sigma_to_res
     611///////////////////////////////////////////////////////////////////////////////
     612{
     613public:
     614  noise_info* noise_info_;
     615  assign_const_sigma_to_res( noise_info& noise_inf)
     616  : noise_info_(&noise_inf)
     617  {}
     618  void action(const double d) const
     619  {
     620    noise_info* noise_inf = noise_info_;
     621  //Std(BText("\nassign_const_sigma_to_res(")+d+")");
     622    noise_inf->sigmaName = "";
     623    noise_inf->sigmaIdx = -1;
     624    noise_inf->sigmaCte = d;
     625    noise_inf->sigPriExpr = "";
     626    noise_inf->cov.Eye(noise_inf->size,noise_inf->size,0,d);
     627    noise_inf->L.Eye(noise_inf->size,noise_inf->size,0,sqrt(d));
     628    noise_inf->Li.Eye(noise_inf->size,noise_inf->size,0,1/sqrt(d));
     629    noise_inf->arimaExpr= "";
     630  //Std(BText(" sigmaIdx=-1"));
     631  //Std(BText(" sigmaCte=")+noise_info_->sigmaCte);
     632  }
     633  void operator()(const double d) const
     634  {
     635    action(d);
     636  }
     637  void action(const std::string& str) const
     638  {
     639    action(atof(str.c_str()));
     640  }
     641  template<typename IteratorT>
     642  void operator()(IteratorT first, IteratorT last) const
     643  {
     644    std::string str;
     645    str.assign(first, last);
     646    action(str);
     647  }
     648};
     649
     650///////////////////////////////////////////////////////////////////////////////
    554651class assign_sigma_to_noise
    555652///////////////////////////////////////////////////////////////////////////////
    … …  
    577674  //Std(BText("\nassign_sigma_to_noise(")+str.c_str()+")");
    578675  //Std(BText("sigmaIdx=")+sigInf->index);
    579     t->noise_info_->sigmaName  = sigInf.name;
    580     t->noise_info_->sigmaIdx   = sigInf.index;
    581     t->noise_info_->sigmaCte   = BDat::Nan();
    582     t->noise_info_->covExpr    = "";
     676    t->noise_info_->sigmaName = sigInf.name;
     677    t->noise_info_->sigmaIdx = sigInf.index;
     678    t->noise_info_->sigmaCte = BDat::Nan();
     679    t->noise_info_->sigPriExpr = "";
    583680    t->noise_info_->cov.Eye(noise_info_->size,noise_info_->size,0,1);
    584     t->noise_info_->covIsDiag=true;
     681    t->noise_info_->L = t->noise_info_->cov;
     682    t->noise_info_->Li = t->noise_info_->cov;
     683    t->noise_info_->arimaExpr= "";
    585684  }
    586685  void operator()(const boost::reference_wrapper<int>& pos) const
    … …  
    648747
    649748///////////////////////////////////////////////////////////////////////////////
    650 class assign_reg_matrix
    651 ///////////////////////////////////////////////////////////////////////////////
    652 {
    653 public:
    654   BText& desc_;
    655   BText& expr_;
    656   BVMat& vmat_;
    657 
    658   assign_reg_matrix(BText& desc, BText& expr, BVMat& vmat)
    659   : desc_(desc),
    660     expr_(expr),
    661     vmat_(vmat)
     749class assign_cov_to_res
     750///////////////////////////////////////////////////////////////////////////////
     751{
     752public:
     753  noise_info* noise_info_;
     754  assign_cov_to_res(noise_info& noise_inf)
     755  : noise_info_(&noise_inf)
    662756  {}
    663757  void action(const std::string& str) const
    664758  {
    665     assign_reg_matrix& t = *((assign_reg_matrix*)this);
    666     t.expr_.Copy(str.c_str()+2, str.size()-4);
    667   //Std(BSR()+" assign_reg_matrix\n  desc_ = "+desc_+"\n  expr_="+t.expr_);
    668     BSyntaxObject* obj = GraAnything()->EvaluateExpr(t.expr_);
    669     if(!obj)
    670     {
    671       Error(BText("Cannot create ")+desc_+" from TOL expression \n"+expr_);
    672     }
    673     else if(obj->Grammar()==GraVMatrix())
    674     {
    675       t.vmat_ = VMat(obj);
    676     }
    677     else if(obj->Grammar()==GraMatrix())
    678     {
    679       BMat& M = Mat(obj);
    680       t.vmat_.DMat2VMat((BMatrix<double>&)M, false, .50, 0.0);
    681     }
     759    noise_info* noise_inf = noise_info_;
     760  //Std(BText("\nassign_covariance_to_res(")+str.c_str()+")");
     761    BText expr(str.c_str()+2, str.size()-4);
     762    BUserVMat* u = (BUserVMat*)GraVMatrix()->EvaluateExpr(expr);
     763    double s2 = 1;
     764    if(noise_inf->sigmaName.size())
     765    {
     766      s2 = noise_inf->sigmaCte;
     767    }
     768    int err = 0;
     769    if(!u)
     770    {
     771      err = -999999;
     772      Error(BSR()+"A valid VMatrix expression was expected as covariance "
     773            "instead of "+expr+" for noise "+noise_inf->name.c_str());
     774    }
    682775    else
    683776    {
    684       Error(BText("Cannot create ")+desc_+" from TOL expression \n"+expr_+"\n"
    685             " This expression is returning a "+obj->Grammar()->Name()+
    686             " instead of a Matrix or VMatrix");
    687     }
    688   }
    689   void operator()(const std::string& str) const
    690   {
    691     action(str);
     777      BVMat &cov=noise_inf->cov;
     778      BVMat &L=noise_inf->L;
     779      BVMat &Li=noise_inf->Li;
     780      BVMat Lf, D;
     781      cov = u->Contens();
     782      int r = cov.Rows();
     783      int c = cov.Columns();
     784      int n = noise_inf->size;
     785      if((r!=n)||(c!=n))
     786      {
     787        err = -999998;
     788        Error(BSR()+"An square ("+n+"x"+n+") VMatrix expression was expected as "
     789             "covariance instead of ("+r+"x"+c+") "+expr+
     790              " for noise "+noise_inf->name.c_str());
     791      }
     792      else
     793      {
     794        err = BVMat::CholeskiFactor(cov,Lf,BVMat::ECFO_XtX,true,true,true);
     795        if(err)
     796        {
     797          Error(BSR()+"Non symmetric positive definite covariance matrix "+expr+
     798                " for noise "+noise_inf->name.c_str());
     799        }
     800        else
     801        {
     802          D.Eye(n);
     803          L.Convert(Lf,BVMat::ESC_chlmRsparse);
     804          err = BVMat::CholeskiSolve(Lf, D, Li, BVMat::ECSS_L);
     805          if(err)
     806          {
     807            Error(BSR()+"Cannot inverse Choleski Factor of covariance matrix"+
     808                  " for noise "+noise_inf->name.c_str());
     809          }
     810        }
     811      }
     812    }
    692813  }
    693814
    … …  
    699820    action(str);
    700821  }
    701 
    702 };
    703 
    704 
    705 ///////////////////////////////////////////////////////////////////////////////
    706 class assign_const_sigma_to_res
     822};
     823
     824///////////////////////////////////////////////////////////////////////////////
     825class assign_covinv_to_res
    707826///////////////////////////////////////////////////////////////////////////////
    708827{
    709828public:
    710829  noise_info* noise_info_;
    711   assign_const_sigma_to_res( noise_info& noise_inf)
     830  assign_covinv_to_res(noise_info& noise_inf)
    712831  : noise_info_(&noise_inf)
    713832  {}
    714   void action(const double d) const
    715   {
    716     noise_info* noise_inf = noise_info_;
    717   //Std(BText("\nassign_const_sigma_to_res(")+d+")");
    718     noise_inf->sigmaName  = "";
    719     noise_inf->sigmaIdx   = -1;
    720     noise_inf->sigmaCte   = d;
    721     noise_inf->covExpr    = "";
    722     noise_inf->cov.Eye(noise_inf->size,noise_inf->size,0,noise_inf->sigmaCte);
    723     noise_inf->covIsDiag=true;
    724   //Std(BText(" sigmaIdx=-1"));
    725   //Std(BText(" sigmaCte=")+noise_info_->sigmaCte);
    726   }
    727   void operator()(const double d) const
    728   {
    729     action(d);
    730   }
    731833  void action(const std::string& str) const
    732834  {
    733     action(atof(str.c_str()));
    734   }
     835    noise_info* noise_inf = noise_info_;
     836  //Std(BText("\nassign_covariance_to_res(")+str.c_str()+")");
     837    BText expr(str.c_str()+2, str.size()-4);
     838    BUserVMat* u = (BUserVMat*)GraVMatrix()->EvaluateExpr(expr);
     839    int err = 0;
     840    if(!u)
     841    {
     842      err = -999999;
     843      Error(BSR()+"A valid VMatrix expression was expected as inverse covariance "
     844            "instead of "+expr+" for noise "+noise_inf->name.c_str());
     845    }
     846    else
     847    {
     848      BVMat &cov=noise_inf->cov;
     849      BVMat &L=noise_inf->L;
     850      BVMat &Li=noise_inf->Li;
     851      BVMat Litf, Lit, D, covi;
     852      covi = u->Contens();
     853      int r = covi.Rows();
     854      int c = covi.Columns();
     855      int n = noise_inf->size;
     856      if((r!=n)||(c!=n))
     857      {
     858        err = -999998;
     859        Error(BSR()+"An square ("+n+"x"+n+") VMatrix expression was expected as "
     860             "inverse covariance instead of ("+r+"x"+c+") "+expr+
     861              " for noise "+noise_inf->name.c_str());
     862      }
     863      else
     864      {
     865        err = BVMat::CholeskiFactor(covi,Litf,BVMat::ECFO_XtX,true,true,true);
     866        if(err)
     867        {
     868          Error(BSR()+"Non symmetric positive definite inverse covariance matrix "+expr+
     869                " for noise "+noise_inf->name.c_str());
     870        }
     871        else
     872        {
     873          D.Eye(n);
     874          Lit.Convert(Litf,BVMat::ESC_chlmRsparse);
     875          Li = Lit.T();
     876          err = BVMat::CholeskiSolve(L, D, Litf, BVMat::ECSS_Lt);
     877          if(err)
     878          {
     879            Error(BSR()+"Cannot inverse Choleski Factor of inverse covariance matrix"+
     880                  " for noise "+noise_inf->name.c_str());
     881          }
     882        }
     883      }
     884    }
     885  }
     886
    735887  template<typename IteratorT>
    736888  void operator()(IteratorT first, IteratorT last) const
    … …  
    742894};
    743895
    744 
    745 ///////////////////////////////////////////////////////////////////////////////
    746 class assign_covariance_to_res
     896///////////////////////////////////////////////////////////////////////////////
     897class assign_covl_to_res
    747898///////////////////////////////////////////////////////////////////////////////
    748899{
    749900public:
    750901  noise_info* noise_info_;
    751   assign_covariance_to_res(noise_info& noise_inf)
     902  assign_covl_to_res(noise_info& noise_inf)
    752903  : noise_info_(&noise_inf)
    753904  {}
    … …  
    756907    noise_info* noise_inf = noise_info_;
    757908  //Std(BText("\nassign_covariance_to_res(")+str.c_str()+")");
    758     noise_inf->sigmaName  = "";
    759     noise_inf->sigmaIdx   = -2;
    760     noise_inf->sigmaCte   = 1;
    761     noise_inf->covExpr    = str;
    762     BUserVMat* u = (BUserVMat*)GraVMatrix()->EvaluateExpr(str.c_str());
     909    BText expr(str.c_str()+2, str.size()-4);
     910    BUserVMat* u = (BUserVMat*)GraVMatrix()->EvaluateExpr(expr);
    763911    int err = 0;
    764912    if(!u)
    765913    {
    766914      err = -999999;
     915      Error(BSR()+"A valid VMatrix expression was expected as "
     916            "Choleski decomposition of covariance instead of "+expr+
     917            " for noise "+noise_inf->name.c_str());
    767918    }
    768919    else
    769920    {
    770       noise_inf->cov = u->Contens();
    771       noise_inf->covIsDiag=noise_inf->cov.IsDiagonal();
    772     }
    773     if(err)
    774     {
    775       Error(BText("Not valid covariance definition ")+str.c_str());
    776     }
    777   //Std(BText(" sigmaIdx=-1"));
    778   //Std(BText(" sigmaCte=")+noise_info_->sigmaCte);
    779   }
     921      BVMat &cov=noise_inf->cov;
     922      BVMat &L=noise_inf->L;
     923      BVMat &Li=noise_inf->Li;
     924      BVMat Lf, D;
     925      Lf = u->Contens();
     926      int r = Lf.Rows();
     927      int c = Lf.Columns();
     928      int n = noise_inf->size;
     929      if((r!=n)||(c!=n))
     930      {
     931        err = -999998;
     932        Error(BSR()+"An square ("+n+"x"+n+") VMatrix expression was expected as "
     933            "Choleski decomposition of covariance instead of "
     934            "("+r+"x"+c+") "+expr+" for noise "+noise_inf->name.c_str());
     935      }
     936      else
     937      {
     938        if(Lf.code_==BVMat::ESC_chlmRfactor)
     939        {
     940          L.Convert(Lf,BVMat::ESC_chlmRsparse);         
     941        }
     942        else
     943        {
     944          L = Lf;
     945          err = BVMat::CholeskiFactor(L,Lf,BVMat::ECFO_X,true,true,true);
     946          if(err)
     947          {
     948            Error(BSR()+"Non valid Choleski decomposition covariance matrix "+expr+
     949                  " for noise "+noise_inf->name.c_str());
     950          }
     951        }
     952        if(!err)
     953        {
     954          D.Eye(n);
     955          L.Convert(Lf,BVMat::ESC_chlmRsparse);
     956          err = BVMat::CholeskiSolve(Lf, D, Li, BVMat::ECSS_L);
     957          if(err)
     958          {
     959            Error(BSR()+"Cannot inverse Choleski factor of covariance matrix"+
     960                  " for noise "+noise_inf->name.c_str());
     961          }
     962        }
     963      }
     964    }
     965  }
     966
    780967  template<typename IteratorT>
    781968  void operator()(IteratorT first, IteratorT last) const
    … …  
    786973  }
    787974};
     975
     976///////////////////////////////////////////////////////////////////////////////
     977class assign_covlinv_to_res
     978///////////////////////////////////////////////////////////////////////////////
     979{
     980public:
     981  noise_info* noise_info_;
     982  assign_covlinv_to_res(noise_info& noise_inf)
     983  : noise_info_(&noise_inf)
     984  {}
     985  void action(const std::string& str) const
     986  {
     987    noise_info* noise_inf = noise_info_;
     988  //Std(BText("\nassign_covariance_to_res(")+str.c_str()+")");
     989    BText expr(str.c_str()+2, str.size()-4);
     990    BUserVMat* u = (BUserVMat*)GraVMatrix()->EvaluateExpr(expr);
     991    int err = 0;
     992    if(!u)
     993    {
     994      err = -999999;
     995      Error(BSR()+"A valid VMatrix expression was expected as "
     996            "Choleski inverse decomposition of covariance instead of "+expr+
     997            " for noise "+noise_inf->name.c_str());
     998    }
     999    else
     1000    {
     1001      BVMat &cov=noise_inf->cov;
     1002      BVMat &L=noise_inf->L;
     1003      BVMat &Li=noise_inf->Li;
     1004      BVMat Lit, Litf, D;
     1005      Litf = u->Contens();
     1006      int r = Litf.Rows();
     1007      int c = Litf.Columns();
     1008      int n = noise_inf->size;
     1009      if((r!=n)||(c!=n))
     1010      {
     1011        err = -999998;
     1012        Error(BSR()+"An square ("+n+"x"+n+") VMatrix expression was expected as "
     1013            "Choleski inverse decomposition of covariance instead of "
     1014            "("+r+"x"+c+") "+expr+" for noise "+noise_inf->name.c_str());
     1015      }
     1016      else
     1017      {
     1018        if(Litf.code_==BVMat::ESC_chlmRfactor)
     1019        {
     1020          Lit.Convert(Litf,BVMat::ESC_chlmRsparse);         
     1021          Li = Li.T();
     1022        }
     1023        else
     1024        {
     1025          Lit = Litf;
     1026          Li = Li.T();
     1027          err = BVMat::CholeskiFactor(Lit,Litf,BVMat::ECFO_X,true,true,true);
     1028          if(err)
     1029          {
     1030            Error(BSR()+"Non valid Choleski inverse decomposition covariance matrix "+expr+
     1031                  " for noise "+noise_inf->name.c_str());
     1032          }
     1033        }
     1034        if(!err)
     1035        {
     1036          D.Eye(n);
     1037          err = BVMat::CholeskiSolve(L, D, Litf, BVMat::ECSS_Lt);
     1038          if(err)
     1039          {
     1040            Error(BSR()+"Cannot inverse Choleski Factor of inverse covariance matrix"+
     1041                  " for noise "+noise_inf->name.c_str());
     1042          }
     1043        }
     1044      }
     1045    }
     1046  }
     1047
     1048  template<typename IteratorT>
     1049  void operator()(IteratorT first, IteratorT last) const
     1050  {
     1051    std::string str;
     1052    str.assign(first, last);
     1053    action(str);
     1054  }
     1055};
     1056
    7881057
    7891058///////////////////////////////////////////////////////////////////////////////
    … …  
    14801749 
    14811750protected:     
    1482   int expand2AllEqu(noise_info& resInfo,
    1483                     const BVMat& A, BVMat& A_);
     1751  int expand2AllEqu(noise_info& resInfo, BVMat& A_);
    14841752
    14851753  int expand2AllEqu_covAndFactors(noise_info& resInfo);

  • tol/btol/vmatrix_type/vmat_bsr.cpp

    r98a619e r94894c73  
    7070   
    7171/////////////////////////////////////////////////////////////////////////////
    72 int bys_sparse_reg::expand2AllEqu(
    73   noise_info& resInfo,
    74   const BVMat& A,
    75   BVMat& A_)
    76 /////////////////////////////////////////////////////////////////////////////
    77 {
     72int bys_sparse_reg::expand2AllEqu(noise_info& resInfo, BVMat& A_)
     73/////////////////////////////////////////////////////////////////////////////
     74{
     75  BVMat A = A_;
    7876//Std(BText("\nTRACE bys_sparse_reg::expand2AllEqu 1"));
    7977  int s = resInfo.equIdx.size();
    … …  
    130128/////////////////////////////////////////////////////////////////////////////
    131129{
    132 //Std(BText("\nTRACE bys_sparse_reg::expand2AllEqu_covAndFactors 1"));
    133   int k, n, err;
    134   BVMat cov, L, Ls, Li, D;
    135   cov = resInfo.cov;
    136   n = cov.Rows();
    137   if(resInfo.covIsDiag)
    138   {
    139   //Std(BText("\nTRACE bys_sparse_reg::expand2AllEqu_covAndFactors 2"));
    140     L = cov;
    141     Li = cov;
    142     double* xCov, *xL, * xLi;
    143     int nzmax;
    144     cov.StoredData(xCov, nzmax);
    145     L  .StoredData(xL,   nzmax);
    146     Li .StoredData(xLi,  nzmax);
    147     for(k=0; k<nzmax; k++)
    148     {
    149       xL [k] = sqrt(xCov[k]);
    150       xLi[k] = 1.0/xL[k];
    151     }
    152     if(err = expand2AllEqu(resInfo, cov, resInfo.cov)) { return(err); }
    153     if(err = expand2AllEqu(resInfo, L,   resInfo.L  )) { return(err); }
    154     if(err = expand2AllEqu(resInfo, Li,  resInfo.Li )) { return(err); }
    155   }
    156   else
    157   {
    158   //Std(BText("\nTRACE bys_sparse_reg::expand2AllEqu_covAndFactors 3"));
    159     err = BVMat::CholeskiFactor(cov,L,BVMat::ECFO_XtX,true,true,true);
    160     if(err)
    161     {
    162       Error(BSR()+"Non symmetric definite positive covariance matrix for noise "+
    163         resInfo.name.c_str());
    164       return(err);
    165     }
    166     D.Eye(n);
    167     err = BVMat::CholeskiSolve(L, D, Li, BVMat::ECSS_L);
    168     if(err)
    169     {
    170       Error(BSR()+"Cannot inverse Choleski Factor of covariance matrix for noise "+
    171         resInfo.name.c_str());
    172       return(err);
    173     }
    174     Ls.Convert(L,BVMat::ESC_chlmRsparse);
    175     if(err = expand2AllEqu(resInfo, cov, resInfo.cov)) { return(err); }
    176     if(err = expand2AllEqu(resInfo, Ls,  resInfo.L  )) { return(err); }
    177     if(err = expand2AllEqu(resInfo, Li,  resInfo.Li )) { return(err); }
    178   }
    179 //Std(BText("\nTRACE bys_sparse_reg::expand2AllEqu_covAndFactors END"));
     130  int err = 0;
     131  if(err = expand2AllEqu(resInfo, resInfo.cov)) { return(err); }
     132  if(err = expand2AllEqu(resInfo, resInfo.L  )) { return(err); }
     133  if(err = expand2AllEqu(resInfo, resInfo.Li )) { return(err); }
    180134  return(err);
    181135};

  • tol/btol/vmatrix_type/vmat_bsr_joint.cpp

    r98a619e r94894c73  
    6363      posSign, negSign, unknown, product,
    6464      initValue, like, power2, member, nonLinearFilters,
    65       noiseSize, normalDist, normalNu, eq, le, ge,
     65      noiseSize, normalDist, normalNu, eq, le, ge, tolExpression,
    6666      argumentSeparator, endOfSentence,
    6767      openParenthesys, closeParenthesys,
    … …  
    9898      assign_sig_pri assign_sig_pri_(s.noise.info);
    9999      assign_const_sigma_to_res assign_const_sigma_to_res_(s.noise.info);
    100       assign_covariance_to_res  assign_covariance_to_res_ (s.noise.info);
     100      assign_cov_to_res  assign_cov_to_res_ (s.noise.info);
     101      assign_covinv_to_res  assign_covinv_to_res_ (s.noise.info);
     102      assign_covl_to_res  assign_covl_to_res_ (s.noise.info);
     103      assign_covlinv_to_res  assign_covlinv_to_res_ (s.noise.info);
    101104      assign_non_lin_flt_to_noise assign_non_lin_flt_to_noise_(s.noise.info);
    102105      assign_pos_sign_to_equ_term assign_pos_sign_to_equ_term_(s.equ_var_term_info);
    … …  
    160163      ge = str_p(">=")
    161164        ;
     165      tolExpression = confix_p(str_p("{$"), (*(anychar_p)), "$}")
     166        ;
    162167  // TOL identifiers
    163168      identifier_simple =
    … …  
    192197        ureal_p[assign_const_sigma_to_res_]
    193198        ;
    194       covariance =
    195         (
    196           (
    197             str_p("SetDiag") >>
    198             confix_p("([[", (*(anychar_p)), "]])")
    199           )
    200           |
    201           (
    202             str_p("Diag") >>
    203             confix_p("(", (*(anychar_p)), ")")
    204           )
    205         )
    206         [assign_covariance_to_res_]
     199      covariance =         
     200        (str_p("Cov")       >>str_p("=")>>tolExpression[assign_cov_to_res_]    ) |
     201        (str_p("CovInv")    >>str_p("=")>>tolExpression[assign_covinv_to_res_] ) |
     202        (str_p("CovChol")   >>str_p("=")>>tolExpression[assign_covl_to_res_]   ) |
     203        (str_p("CovInvChol")>>str_p("=")>>tolExpression[assign_covlinv_to_res_])
    207204        ;
    208205      arima =
    209206        (
    210           (
    211             str_p("*") >>
    212             str_p("ARIMA.COV") >>
    213             confix_p("([[", (*(anychar_p)), "]])")[assign_a(s.noise.info.arimaExpr)]
    214           )
    215           |
    216           eps_p[assign_a(s.noise.info.arimaExpr,"")]
     207          (str_p("ARIMA.COV") | (str_p("Cov") >>str_p("=")>> str_p("ArimaCovariance"))) >>
     208          confix_p("([[", (*(anychar_p)), "]])")[assign_a(s.noise.info.arimaExpr)]
    217209        )
    218210        ;
    219211      resSigmaDef =
    220212        (
    221           covariance |
    222213          constantSigma |
    223214          variantSigma |
    224215          error_sigmaExpected
    225216        ) >>
    226         arima
     217        (
     218          (str_p("*") >> (arima | covariance) )
     219          | eps_p
     220        )
    227221        ;
    228222      noiseName=
    … …  
    338332      nonLinearFilters = (
    339333        str_p("with") >> str_p("non") >> str_p("linear") >> str_p("filters") >>
    340         (confix_p("{$", (*(anychar_p)), "$}")[assign_non_lin_flt_to_noise_])
     334        tolExpression[assign_non_lin_flt_to_noise_]
    341335      ) | (
    342336         eps_p[assign_non_lin_flt_to_noise_]
    … …  
    354348          normalDist >>
    355349          openParenthesys >>
    356           normalNu >>
    357           argumentSeparator >>
    358           resSigmaDef >>
    359         //power2 >>
     350            normalNu >>
     351            argumentSeparator >>
     352            resSigmaDef >>
    360353          closeParenthesys
    361354        ) | error_noiseDistribDeclareExpected) >>

  • tol/btol/vmatrix_type/vmat_bsr_primary.cpp

    r98a619e r94894c73  
    6363      posSign, negSign, unknown, product,
    6464      initValue, like, power2, member, nonLinearFilters,
    65       noiseSize, normalDist, normalNu, eq, le, ge,
     65      noiseSize, normalDist, normalNu, eq, le, ge, tolExpression,
    6666      argumentSeparator, endOfSentence,
    6767      openParenthesys, closeParenthesys,
    … …  
    9696      assign_sig_pri assign_sig_pri_(s.noise.info);
    9797      assign_const_sigma_to_res assign_const_sigma_to_res_(s.noise.info);
    98       assign_covariance_to_res  assign_covariance_to_res_ (s.noise.info);
     98      assign_cov_to_res  assign_cov_to_res_ (s.noise.info);
     99      assign_covinv_to_res  assign_covinv_to_res_ (s.noise.info);
     100      assign_covl_to_res  assign_covl_to_res_ (s.noise.info);
     101      assign_covlinv_to_res  assign_covlinv_to_res_ (s.noise.info);
    99102      assign_non_lin_flt_to_noise assign_non_lin_flt_to_noise_(s.noise.info);
    100103      assign_reg_matrix assign_output_(s.descY_, s.exprY_, s.Y_);
    … …  
    155158        ;
    156159      ge = str_p(">=")
     160        ;
     161      tolExpression = confix_p(str_p("{$"), (*(anychar_p)), "$}")
    157162        ;
    158163  // TOL identifiers
    … …  
    186191        ureal_p[assign_const_sigma_to_res_]
    187192        ;
    188       covariance =
    189         (
    190           (
    191             str_p("SetDiag") >>
    192             confix_p("([[", (*(anychar_p)), "]])")
    193           )
    194           |
    195           (
    196             str_p("Diag") >>
    197             confix_p("(", (*(anychar_p)), ")")
    198           )
     193      covariance =         
     194        (str_p("Cov")       >>str_p("=")>>tolExpression[assign_cov_to_res_]    ) |
     195        (str_p("CovInv")    >>str_p("=")>>tolExpression[assign_covinv_to_res_] ) |
     196        (str_p("CovChol")   >>str_p("=")>>tolExpression[assign_covl_to_res_]   ) |
     197        (str_p("CovInvChol")>>str_p("=")>>tolExpression[assign_covlinv_to_res_])
     198        ;
     199      arima =
     200        (
     201          (str_p("ARIMA.COV") | (str_p("Cov") >>str_p("=")>> str_p("Arima"))) >>
     202          confix_p("([[", (*(anychar_p)), "]])")[assign_a(s.noise.info.arimaExpr)]
    199203        )
    200         [assign_covariance_to_res_]
    201         ;
    202       arima =
    203         (
    204           (
    205             str_p("*") >>
    206             str_p("ARIMA.COV") >>
    207             confix_p("([[", (*(anychar_p)), "]])")[assign_a(s.noise.info.arimaExpr)]
    208           )
    209           |
    210           eps_p[assign_a(s.noise.info.arimaExpr,"")]
    211         )
    212204        ;
    213205      resSigmaDef =
    214206        (
    215           covariance |
    216207          constantSigma |
    217208          variantSigma |
    218209          error_sigmaExpected
    219210        ) >>
    220         arima
     211        (
     212          (str_p("*") >> (arima | covariance) )
     213          | eps_p
     214        )
    221215        ;
    222216      knownReal =
    … …  
    311305      nonLinearFilters = (
    312306        str_p("with") >> str_p("non") >> str_p("linear") >> str_p("filters") >>
    313         (confix_p("{$", (*(anychar_p)), "$}")[assign_non_lin_flt_to_noise_])
     307        tolExpression[assign_non_lin_flt_to_noise_]
    314308      ) | (
    315309         eps_p[assign_non_lin_flt_to_noise_]
    … …  
    336330        endOfSentence[add_res]
    337331        ;
    338       output = str_p("Output") >> ch_p('=') >>
    339       //str_p("{$") >> (((*(anychar_p)) - str_p("$}"))[assign_output_]) >> str_p("$}")
    340         confix_p("{$", (*(anychar_p)), "$}") [assign_output_]
     332      output = str_p("Output") >> ch_p('=') >>  tolExpression[assign_output_]
    341333        >> endOfSentence;
    342       input  = str_p("Input") >> ch_p('=') >>
    343       //str_p("{$") >> (((*(anychar_p)) - str_p("$}"))[assign_input_ ]) >> str_p("$}")
    344         confix_p("{$", (*(anychar_p)), "$}") [assign_input_]
     334      input  = str_p("Input")  >> ch_p('=') >>  tolExpression [assign_input_]
    345335        >> endOfSentence;
    346336

  • tol/stdlib/math/stat/models/bayesian/bysMcmc/bsr/_import.tol

    r98a619e r94894c73  
    295295    "["+IntText(segment::Get.Equation.Size(0))+timeExpr+"]"+
    296296    "\n  ~ Normal(0,"<<s2+s2Prior);
    297   Real arima.size = segment::Get.ARIMA.Size(0);
    298   If(arima.size,
    299   {
    300     FPutText(fileHandler, "*ARIMA.COV([[");
     297  Real arima.size = If(!FunctionExist("Text","segment::Get.ARIMA.Size"),0,
     298     segment::Get.ARIMA.Size(0));
     299  Case(
     300  arima.size,
     301  {
     302    FPutText(fileHandler, " * Cov = ArimaCovariance([[");
    301303    Set For(1, arima.size, Real(Real af)
    302304    {
    … …  
    309311    });
    310312    FPutText(fileHandler, "]])")
     313  },
     314  FunctionExist("Text","segment::Get.Cov"),
     315  {
     316    FPutText(fileHandler, " * Cov = {$ "+segment::Get.Cov(0)+" $}")
     317  },
     318  FunctionExist("Text","segment::Get.CovInv"),
     319  {
     320    FPutText(fileHandler, " * CovInv = {$ "+segment::Get.CovInv(0)+" $}")
     321  },
     322  FunctionExist("Text","segment::Get.CovChol"),
     323  {
     324    FPutText(fileHandler, " * CovChol = {$ "+segment::Get.CovChol(0)+" $}")
     325  },
     326  FunctionExist("Text","segment::Get.CovInvChol"),
     327  {
     328    FPutText(fileHandler, " * CovInvChol = {$ "+segment::Get.CovInvChol(0)+" $}")
    311329  });
    312330  FPutText(fileHandler, ")");
Note: See TracChangeset for help on using the changeset viewer.