| 21 | |
| 22 | //! class used in PF |
| 23 | class MarginalizedParticle : public BM{ |
| 24 | protected: |
| 25 | //! discrte particle |
| 26 | dirac est_emp; |
| 27 | //! internal Bayes Model |
| 28 | shared_ptr<BM> bm; |
| 29 | //! pdf with for transitional par |
| 30 | shared_ptr<pdf> par; // pdf for non-linear part |
| 31 | //! link from this to bm |
| 32 | shared_ptr<datalink_part> cond2bm; |
| 33 | //! link from cond to par |
| 34 | shared_ptr<datalink_part> cond2par; |
| 35 | //! link from emp 2 par |
| 36 | shared_ptr<datalink_part> emp2bm; |
| 37 | //! link from emp 2 par |
| 38 | shared_ptr<datalink_part> emp2par; |
| 39 | |
| 40 | //! custom posterior - product |
| 41 | class eprod_2:public eprod_base { |
| 42 | protected: |
| 43 | MarginalizedParticle ∓ |
| 44 | public: |
| 45 | eprod_2(MarginalizedParticle &m):mp(m){} |
| 46 | const epdf* factor(int i) const {return (i==0) ? &mp.bm->posterior() : &mp.est_emp;} |
| 47 | const int no_factors() const {return 2;} |
| 48 | } est; |
| 49 | |
| 50 | public: |
| 51 | MarginalizedParticle():est(*this){}; |
| 52 | BM* _copy() const{return new MarginalizedParticle(*this);}; |
| 53 | void bayes(const vec &dt, const vec &cond){ |
| 54 | vec par_cond(par->dimensionc()); |
| 55 | cond2par->filldown(cond,par_cond); // copy ut |
| 56 | emp2par->filldown(est_emp._point(),par_cond); // copy xt-1 |
| 57 | |
| 58 | //sample new particle |
| 59 | est_emp.set_point(par->samplecond(par_cond)); |
| 60 | //if (evalll) |
| 61 | vec bm_cond(bm->dimensionc()); |
| 62 | cond2bm->filldown(cond, bm_cond);// set e.g. ut |
| 63 | emp2bm->filldown(est_emp._point(), bm_cond);// set e.g. ut |
| 64 | bm->bayes(dt, bm_cond); |
| 65 | ll=bm->_ll(); |
| 66 | } |
| 67 | const eprod_2& posterior() const {return est;} |
| 68 | |
| 69 | void set_prior(const epdf *pdf0){ |
| 70 | const eprod *ep=dynamic_cast<const eprod*>(pdf0); |
| 71 | if (ep){ // full prior |
| 72 | bdm_assert(ep->no_factors()==2,"Incompatible prod"); |
| 73 | bm->set_prior(ep->factor(0)); |
| 74 | est_emp.set_point(ep->factor(1)->sample()); |
| 75 | } else { |
| 76 | // assume prior is only for emp; |
| 77 | est_emp.set_point(pdf0->sample()); |
| 78 | } |
| 79 | } |
| 80 | |
| 81 | /*! parse structure |
| 82 | \code |
| 83 | class = "BootstrapParticle"; |
| 84 | parameter_pdf = {class = 'epdf_offspring', ...}; |
| 85 | observation_pdf = {class = 'epdf_offspring',...}; |
| 86 | \endcode |
| 87 | If rvs are set, then it checks for compatibility. |
| 88 | */ |
| 89 | void from_setting(const Setting &set){ |
| 90 | BM::from_setting ( set ); |
| 91 | par = UI::build<pdf> ( set, "parameter_pdf", UI::compulsory ); |
| 92 | bm = UI::build<BM> ( set, "bm", UI::compulsory ); |
| 93 | } |
| 94 | void validate(){ |
| 95 | yrv = bm->_rv(); |
| 96 | dimy = bm->dimension(); |
| 97 | set_rv( par->_rv()); |
| 98 | set_dim( par->dimension()); |
| 99 | |
| 100 | rvc = par->_rvc().subt(par->_rv().copy_t(-1)); |
| 101 | rvc.add(bm->_rvc()); // |
| 102 | |
| 103 | cond2bm=new datalink_part; |
| 104 | cond2par=new datalink_part; |
| 105 | emp2bm =new datalink_part; |
| 106 | emp2par =new datalink_part; |
| 107 | cond2bm->set_connection(bm->_rvc(), rvc); |
| 108 | cond2par->set_connection(par->_rvc(), rvc); |
| 109 | emp2bm->set_connection(bm->_rvc(), _rv()); |
| 110 | emp2par->set_connection(par->_rvc(), _rv().copy_t(-1)); |
| 111 | |
| 112 | dimc = rvc._dsize(); |
| 113 | }; |
| 114 | }; |
| 115 | UIREGISTER(MarginalizedParticle); |
| 116 | |
| 117 | //! class used in PF |
| 118 | class BootstrapParticle : public BM{ |
| 119 | dirac est; |
| 120 | shared_ptr<pdf> par; |
| 121 | shared_ptr<pdf> obs; |
| 122 | shared_ptr<datalink_part> cond2par; |
| 123 | shared_ptr<datalink_part> cond2obs; |
| 124 | shared_ptr<datalink_part> xt2obs; |
| 125 | shared_ptr<datalink_part> xtm2par; |
| 126 | public: |
| 127 | BM* _copy() const{return new BootstrapParticle(*this);}; |
| 128 | void bayes(const vec &dt, const vec &cond){ |
| 129 | vec par_cond(par->dimensionc()); |
| 130 | cond2par->filldown(cond,par_cond); // copy ut |
| 131 | xtm2par->filldown(est._point(),par_cond); // copy xt-1 |
| 132 | |
| 133 | //sample new particle |
| 134 | est.set_point(par->samplecond(par_cond)); |
| 135 | //if (evalll) |
| 136 | vec obs_cond(obs->dimensionc()); |
| 137 | cond2obs->filldown(cond, obs_cond);// set e.g. ut |
| 138 | xt2obs->filldown(est._point(), obs_cond);// set e.g. ut |
| 139 | ll=obs->evallogcond(dt,obs_cond); |
| 140 | } |
| 141 | const dirac& posterior() const {return est;} |
| 142 | |
| 143 | void set_prior(const epdf *pdf0){est.set_point(pdf0->sample());} |
| 144 | |
| 145 | /*! parse structure |
| 146 | \code |
| 147 | class = "BootstrapParticle"; |
| 148 | parameter_pdf = {class = 'epdf_offspring', ...}; |
| 149 | observation_pdf = {class = 'epdf_offspring',...}; |
| 150 | \endcode |
| 151 | If rvs are set, then it checks for compatibility. |
| 152 | */ |
| 153 | void from_setting(const Setting &set){ |
| 154 | BM::from_setting ( set ); |
| 155 | par = UI::build<pdf> ( set, "parameter_pdf", UI::compulsory ); |
| 156 | obs = UI::build<pdf> ( set, "observation_pdf", UI::compulsory ); |
| 157 | } |
| 158 | void validate(){ |
| 159 | yrv = obs->_rv(); |
| 160 | dimy = obs->dimension(); |
| 161 | set_rv( par->_rv()); |
| 162 | set_dim( par->dimension()); |
| 163 | |
| 164 | rvc = par->_rvc().subt(par->_rv().copy_t(-1)); |
| 165 | rvc.add(obs->_rvc()); // |
| 166 | |
| 167 | cond2obs=new datalink_part; |
| 168 | cond2par=new datalink_part; |
| 169 | xt2obs =new datalink_part; |
| 170 | xtm2par =new datalink_part; |
| 171 | cond2obs->set_connection(obs->_rvc(), rvc); |
| 172 | cond2par->set_connection(par->_rvc(), rvc); |
| 173 | xt2obs->set_connection(obs->_rvc(), _rv()); |
| 174 | xtm2par->set_connection(par->_rvc(), _rv().copy_t(-1)); |
| 175 | |
| 176 | dimc = rvc._dsize(); |
| 177 | }; |
| 178 | }; |
| 179 | UIREGISTER(BootstrapParticle); |
| 180 | |
224 | | class MPF : public BM { |
225 | | //! \var log_level_enums means |
226 | | //! TODO DOPLNIT |
227 | | LOG_LEVEL(MPF,means); |
228 | | |
229 | | protected: |
230 | | //! particle filter on non-linear variable |
231 | | shared_ptr<PF> pf; |
232 | | //! Array of Bayesian models |
233 | | Array<BM*> BMs; |
234 | | |
235 | | //! internal class for pdf providing composition of eEmp with external components |
236 | | |
237 | | class mpfepdf : public epdf { |
238 | | //! pointer to particle filter |
239 | | shared_ptr<PF> &pf; |
240 | | //! pointer to Array of BMs |
241 | | Array<BM*> &BMs; |
242 | | public: |
243 | | //! constructor |
244 | | mpfepdf ( shared_ptr<PF> &pf0, Array<BM*> &BMs0 ) : epdf(), pf ( pf0 ), BMs ( BMs0 ) { }; |
245 | | //! a variant of set parameters - this time, parameters are read from BMs and pf |
246 | | void read_parameters() { |
247 | | rv = concat ( pf->posterior()._rv(), BMs ( 0 )->posterior()._rv() ); |
248 | | dim = pf->posterior().dimension() + BMs ( 0 )->posterior().dimension(); |
249 | | bdm_assert_debug ( dim == rv._dsize(), "Wrong name " ); |
250 | | } |
251 | | vec mean() const; |
252 | | |
253 | | vec variance() const; |
254 | | |
255 | | void qbounds ( vec &lb, vec &ub, double perc = 0.95 ) const; |
256 | | |
257 | | vec sample() const NOT_IMPLEMENTED(0); |
258 | | |
259 | | double evallog ( const vec &val ) const NOT_IMPLEMENTED(0); |
260 | | }; |
261 | | |
262 | | //! Density joining PF.est with conditional parts |
263 | | mpfepdf jest; |
264 | | |
265 | | //! datalink from global yt and cond (Up) to BMs yt and cond (Down) |
266 | | datalink_m2m this2bm; |
267 | | //! datalink from global yt and cond (Up) to PFs yt and cond (Down) |
268 | | datalink_m2m this2pf; |
269 | | //!datalink from PF part to BM |
270 | | datalink_part pf2bm; |
271 | | |
272 | | public: |
273 | | //! Default constructor. |
274 | | MPF () : jest ( pf, BMs ) {}; |
275 | | //! set all parameters at once |
276 | | void set_pf ( shared_ptr<pdf> par0, int n0, RESAMPLING_METHOD rm = SYSTEMATIC ) { |
277 | | if (!pf) pf=new PF; |
278 | | pf->set_model ( par0, par0 ); // <=== nasty!!! |
279 | | pf->set_parameters ( n0, rm ); |
280 | | pf->set_rv(par0->_rv()); |
281 | | BMs.set_length ( n0 ); |
282 | | } |
283 | | //! set a prototype of BM, copy it to as many times as there is particles in pf |
284 | | void set_BM ( const BM &BMcond0 ) { |
285 | | |
286 | | int n = pf->__w().length(); |
287 | | BMs.set_length ( n ); |
288 | | // copy |
289 | | //BMcond0 .condition ( pf->posterior()._sample ( 0 ) ); |
290 | | for ( int i = 0; i < n; i++ ) { |
291 | | BMs ( i ) = (BM*) BMcond0._copy(); |
292 | | } |
293 | | }; |
294 | | |
295 | | void bayes ( const vec &yt, const vec &cond ); |
296 | | |
297 | | const epdf& posterior() const { |
298 | | return jest; |
299 | | } |
300 | | |
301 | | //!Access function |
302 | | const BM* _BM ( int i ) { |
303 | | return BMs ( i ); |
304 | | } |
305 | | PF& _pf() {return *pf;} |
306 | | |
307 | | |
308 | | virtual double logpred ( const vec &yt ) const NOT_IMPLEMENTED(0); |
309 | | |
310 | | virtual epdf* epredictor() const NOT_IMPLEMENTED(NULL); |
311 | | |
312 | | virtual pdf* predictor() const NOT_IMPLEMENTED(NULL); |
313 | | |
314 | | |
315 | | /*! configuration structure for basic PF |
316 | | \code |
317 | | BM = BM_class; // Bayesian filtr for analytical part of the model |
318 | | parameter_pdf = pdf_class; // transitional pdf for non-parametric part of the model |
319 | | prior = epdf_class; // prior probability density |
320 | | --- optional --- |
321 | | n = 10; // number of particles |
322 | | resmethod = 'systematic', or 'multinomial', or 'stratified' |
323 | | // resampling method |
324 | | \endcode |
325 | | */ |
326 | | void from_setting ( const Setting &set ) { |
327 | | BM::from_setting( set ); |
328 | | |
329 | | shared_ptr<pdf> par = UI::build<pdf> ( set, "parameter_pdf", UI::compulsory ); |
330 | | |
331 | | pf = new PF; |
332 | | // prior must be set before BM |
333 | | pf->prior_from_set ( set ); |
334 | | pf->resmethod_from_set ( set ); |
335 | | pf->set_model ( par, par ); // too hackish! |
336 | | |
337 | | shared_ptr<BM> BM0 = UI::build<BM> ( set, "BM", UI::compulsory ); |
338 | | set_BM ( *BM0 ); |
339 | | |
340 | | //set drv |
341 | | //??set_yrv(concat(BM0->_yrv(),u) ); |
342 | | set_yrv ( BM0->_yrv() ); |
343 | | rvc = BM0->_rvc().subt ( par->_rv() ); |
344 | | //find potential input - what remains in rvc when we subtract rv |
345 | | RV u = par->_rvc().subt ( par->_rv().copy_t ( -1 ) ); |
346 | | rvc.add ( u ); |
347 | | dimc = rvc._dsize(); |
348 | | validate(); |
349 | | } |
350 | | |
351 | | void validate() { |
352 | | BM::validate(); |
353 | | try { |
354 | | pf->validate(); |
355 | | } catch ( std::exception ) { |
356 | | throw UIException ( "Error in PF part of MPF:" ); |
357 | | } |
358 | | jest.read_parameters(); |
359 | | this2bm.set_connection ( BMs ( 0 )->_yrv(), BMs ( 0 )->_rvc(), yrv, rvc ); |
360 | | this2pf.set_connection ( pf->_yrv(), pf->_rvc(), yrv, rvc ); |
361 | | pf2bm.set_connection ( BMs ( 0 )->_rvc(), pf->posterior()._rv() ); |
362 | | } |
363 | | }; |
364 | | UIREGISTER ( MPF ); |
| 399 | // class MPF : public BM { |
| 400 | // //! Introduces new option |
| 401 | // //! \li means - meaning TODO |
| 402 | // LOG_LEVEL(MPF,means); |
| 403 | // protected: |
| 404 | // //! particle filter on non-linear variable |
| 405 | // shared_ptr<PF> pf; |
| 406 | // //! Array of Bayesian models |
| 407 | // Array<BM*> BMs; |
| 408 | // |
| 409 | // //! internal class for pdf providing composition of eEmp with external components |
| 410 | // |
| 411 | // class mpfepdf : public epdf { |
| 412 | // //! pointer to particle filter |
| 413 | // shared_ptr<PF> &pf; |
| 414 | // //! pointer to Array of BMs |
| 415 | // Array<BM*> &BMs; |
| 416 | // public: |
| 417 | // //! constructor |
| 418 | // mpfepdf ( shared_ptr<PF> &pf0, Array<BM*> &BMs0 ) : epdf(), pf ( pf0 ), BMs ( BMs0 ) { }; |
| 419 | // //! a variant of set parameters - this time, parameters are read from BMs and pf |
| 420 | // void read_parameters() { |
| 421 | // rv = concat ( pf->posterior()._rv(), BMs ( 0 )->posterior()._rv() ); |
| 422 | // dim = pf->posterior().dimension() + BMs ( 0 )->posterior().dimension(); |
| 423 | // bdm_assert_debug ( dim == rv._dsize(), "Wrong name " ); |
| 424 | // } |
| 425 | // vec mean() const; |
| 426 | // |
| 427 | // vec variance() const; |
| 428 | // |
| 429 | // void qbounds ( vec &lb, vec &ub, double perc = 0.95 ) const; |
| 430 | // |
| 431 | // vec sample() const NOT_IMPLEMENTED(0); |
| 432 | // |
| 433 | // double evallog ( const vec &val ) const NOT_IMPLEMENTED(0); |
| 434 | // }; |
| 435 | // |
| 436 | // //! Density joining PF.est with conditional parts |
| 437 | // mpfepdf jest; |
| 438 | // |
| 439 | // //! datalink from global yt and cond (Up) to BMs yt and cond (Down) |
| 440 | // datalink_m2m this2bm; |
| 441 | // //! datalink from global yt and cond (Up) to PFs yt and cond (Down) |
| 442 | // datalink_m2m this2pf; |
| 443 | // //!datalink from PF part to BM |
| 444 | // datalink_part pf2bm; |
| 445 | // |
| 446 | // public: |
| 447 | // //! Default constructor. |
| 448 | // MPF () : jest ( pf, BMs ) {}; |
| 449 | // //! set all parameters at once |
| 450 | // void set_pf ( shared_ptr<pdf> par0, int n0, RESAMPLING_METHOD rm = SYSTEMATIC ) { |
| 451 | // if (!pf) pf=new PF; |
| 452 | // pf->set_model ( par0, par0 ); // <=== nasty!!! |
| 453 | // pf->set_parameters ( n0, rm ); |
| 454 | // pf->set_rv(par0->_rv()); |
| 455 | // BMs.set_length ( n0 ); |
| 456 | // } |
| 457 | // //! set a prototype of BM, copy it to as many times as there is particles in pf |
| 458 | // void set_BM ( const BM &BMcond0 ) { |
| 459 | // |
| 460 | // int n = pf->__w().length(); |
| 461 | // BMs.set_length ( n ); |
| 462 | // // copy |
| 463 | // //BMcond0 .condition ( pf->posterior()._sample ( 0 ) ); |
| 464 | // for ( int i = 0; i < n; i++ ) { |
| 465 | // BMs ( i ) = (BM*) BMcond0._copy(); |
| 466 | // } |
| 467 | // }; |
| 468 | // |
| 469 | // void bayes ( const vec &yt, const vec &cond ); |
| 470 | // |
| 471 | // const epdf& posterior() const { |
| 472 | // return jest; |
| 473 | // } |
| 474 | // |
| 475 | // //!Access function |
| 476 | // const BM* _BM ( int i ) { |
| 477 | // return BMs ( i ); |
| 478 | // } |
| 479 | // PF& _pf() {return *pf;} |
| 480 | // |
| 481 | // |
| 482 | // virtual double logpred ( const vec &yt ) const NOT_IMPLEMENTED(0); |
| 483 | // |
| 484 | // virtual epdf* epredictor() const NOT_IMPLEMENTED(NULL); |
| 485 | // |
| 486 | // virtual pdf* predictor() const NOT_IMPLEMENTED(NULL); |
| 487 | // |
| 488 | // |
| 489 | // /*! configuration structure for basic PF |
| 490 | // \code |
| 491 | // BM = BM_class; // Bayesian filtr for analytical part of the model |
| 492 | // parameter_pdf = pdf_class; // transitional pdf for non-parametric part of the model |
| 493 | // prior = epdf_class; // prior probability density |
| 494 | // --- optional --- |
| 495 | // n = 10; // number of particles |
| 496 | // resmethod = 'systematic', or 'multinomial', or 'stratified' |
| 497 | // // resampling method |
| 498 | // \endcode |
| 499 | // */ |
| 500 | // void from_setting ( const Setting &set ) { |
| 501 | // BM::from_setting( set ); |
| 502 | // |
| 503 | // shared_ptr<pdf> par = UI::build<pdf> ( set, "parameter_pdf", UI::compulsory ); |
| 504 | // |
| 505 | // pf = new PF; |
| 506 | // // prior must be set before BM |
| 507 | // pf->prior_from_set ( set ); |
| 508 | // pf->resmethod_from_set ( set ); |
| 509 | // pf->set_model ( par, par ); // too hackish! |
| 510 | // |
| 511 | // shared_ptr<BM> BM0 = UI::build<BM> ( set, "BM", UI::compulsory ); |
| 512 | // set_BM ( *BM0 ); |
| 513 | // |
| 514 | // //set drv |
| 515 | // //??set_yrv(concat(BM0->_yrv(),u) ); |
| 516 | // set_yrv ( BM0->_yrv() ); |
| 517 | // rvc = BM0->_rvc().subt ( par->_rv() ); |
| 518 | // //find potential input - what remains in rvc when we subtract rv |
| 519 | // RV u = par->_rvc().subt ( par->_rv().copy_t ( -1 ) ); |
| 520 | // rvc.add ( u ); |
| 521 | // dimc = rvc._dsize(); |
| 522 | // validate(); |
| 523 | // } |
| 524 | // |
| 525 | // void validate() { |
| 526 | // BM::validate(); |
| 527 | // try { |
| 528 | // pf->validate(); |
| 529 | // } catch ( std::exception ) { |
| 530 | // throw UIException ( "Error in PF part of MPF:" ); |
| 531 | // } |
| 532 | // jest.read_parameters(); |
| 533 | // this2bm.set_connection ( BMs ( 0 )->_yrv(), BMs ( 0 )->_rvc(), yrv, rvc ); |
| 534 | // this2pf.set_connection ( pf->_yrv(), pf->_rvc(), yrv, rvc ); |
| 535 | // pf2bm.set_connection ( BMs ( 0 )->_rvc(), pf->posterior()._rv() ); |
| 536 | // } |
| 537 | // }; |
| 538 | // UIREGISTER ( MPF ); |
368 | | class MPF_ARXg :public BM{ |
369 | | protected: |
370 | | shared_ptr<PF> pf; |
371 | | //! pointer to Array of BMs |
372 | | Array<ARX*> BMso; |
373 | | //! pointer to Array of BMs |
374 | | Array<ARX*> BMsp; |
375 | | //!parameter evolution |
376 | | shared_ptr<fnc> g; |
377 | | //!observation function |
378 | | shared_ptr<fnc> h; |
379 | | |
380 | | public: |
381 | | void bayes(const vec &yt, const vec &cond ); |
382 | | void from_setting(const Setting &set) ; |
383 | | void validate() { |
384 | | bdm_assert(g->dimensionc()==g->dimension(),"not supported yet"); |
385 | | bdm_assert(h->dimensionc()==g->dimension(),"not supported yet"); |
386 | | } |
387 | | |
388 | | double logpred(const vec &cond) const NOT_IMPLEMENTED(0.0); |
389 | | epdf* epredictor() const NOT_IMPLEMENTED(NULL); |
390 | | pdf* predictor() const NOT_IMPLEMENTED(NULL); |
391 | | const epdf& posterior() const {return pf->posterior();}; |
392 | | |
393 | | void log_register( logger &L, const string &prefix ){ |
394 | | BM::log_register(L,prefix); |
395 | | logrec->ids.set_size ( 3 ); |
396 | | logrec->ids(1)= L.add_vector(RV("Q",dimension()*dimension()), prefix+L.prefix_sep()+"Q"); |
397 | | logrec->ids(2)= L.add_vector(RV("R",dimensiony()*dimensiony()), prefix+L.prefix_sep()+"R"); |
398 | | |
399 | | }; |
400 | | void log_write() const { |
401 | | BM::log_write(); |
402 | | mat mQ=zeros(dimension(),dimension()); |
403 | | mat pom=zeros(dimension(),dimension()); |
404 | | mat mR=zeros(dimensiony(),dimensiony()); |
405 | | mat pom2=zeros(dimensiony(),dimensiony()); |
406 | | mat dum; |
407 | | const vec w=pf->posterior()._w(); |
408 | | for (int i=0; i<w.length(); i++){ |
409 | | BMsp(i)->posterior().mean_mat(dum,pom); |
410 | | mQ += w(i) * pom; |
411 | | BMso(i)->posterior().mean_mat(dum,pom2); |
412 | | mR += w(i) * pom2; |
413 | | |
414 | | } |
415 | | logrec->L.log_vector ( logrec->ids ( 1 ), cvectorize(mQ) ); |
416 | | logrec->L.log_vector ( logrec->ids ( 2 ), cvectorize(mR) ); |
417 | | |
418 | | } |
419 | | }; |
420 | | UIREGISTER(MPF_ARXg); |
| 542 | // class MPF_ARXg :public BM{ |
| 543 | // protected: |
| 544 | // shared_ptr<PF> pf; |
| 545 | // //! pointer to Array of BMs |
| 546 | // Array<ARX*> BMso; |
| 547 | // //! pointer to Array of BMs |
| 548 | // Array<ARX*> BMsp; |
| 549 | // //!parameter evolution |
| 550 | // shared_ptr<fnc> g; |
| 551 | // //!observation function |
| 552 | // shared_ptr<fnc> h; |
| 553 | // |
| 554 | // public: |
| 555 | // void bayes(const vec &yt, const vec &cond ); |
| 556 | // void from_setting(const Setting &set) ; |
| 557 | // void validate() { |
| 558 | // bdm_assert(g->dimensionc()==g->dimension(),"not supported yet"); |
| 559 | // bdm_assert(h->dimensionc()==g->dimension(),"not supported yet"); |
| 560 | // } |
| 561 | // |
| 562 | // double logpred(const vec &cond) const NOT_IMPLEMENTED(0.0); |
| 563 | // epdf* epredictor() const NOT_IMPLEMENTED(NULL); |
| 564 | // pdf* predictor() const NOT_IMPLEMENTED(NULL); |
| 565 | // const epdf& posterior() const {return pf->posterior();}; |
| 566 | // |
| 567 | // void log_register( logger &L, const string &prefix ){ |
| 568 | // BM::log_register(L,prefix); |
| 569 | // logrec->ids.set_size ( 3 ); |
| 570 | // logrec->ids(1)= L.add_vector(RV("Q",dimension()*dimension()), prefix+L.prefix_sep()+"Q"); |
| 571 | // logrec->ids(2)= L.add_vector(RV("R",dimensiony()*dimensiony()), prefix+L.prefix_sep()+"R"); |
| 572 | // |
| 573 | // }; |
| 574 | // void log_write() const { |
| 575 | // BM::log_write(); |
| 576 | // mat mQ=zeros(dimension(),dimension()); |
| 577 | // mat pom=zeros(dimension(),dimension()); |
| 578 | // mat mR=zeros(dimensiony(),dimensiony()); |
| 579 | // mat pom2=zeros(dimensiony(),dimensiony()); |
| 580 | // mat dum; |
| 581 | // const vec w=pf->posterior()._w(); |
| 582 | // for (int i=0; i<w.length(); i++){ |
| 583 | // BMsp(i)->posterior().mean_mat(dum,pom); |
| 584 | // mQ += w(i) * pom; |
| 585 | // BMso(i)->posterior().mean_mat(dum,pom2); |
| 586 | // mR += w(i) * pom2; |
| 587 | // |
| 588 | // } |
| 589 | // logrec->L.log_vector ( logrec->ids ( 1 ), cvectorize(mQ) ); |
| 590 | // logrec->L.log_vector ( logrec->ids ( 2 ), cvectorize(mR) ); |
| 591 | // |
| 592 | // } |
| 593 | // }; |
| 594 | // UIREGISTER(MPF_ARXg); |