Show
Ignore:
Timestamp:
11/25/09 12:14:38 (15 years ago)
Author:
mido
Message:

ASTYLER RUN OVER THE WHOLE LIBRARY, JUPEE

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • library/bdm/base/datasources.h

    r723 r737  
    2828*/ 
    2929class MemDS : public DS { 
    30         protected: 
    31                 //! internal matrix of data 
    32                 mat Data; 
    33                 //! active column in the Data matrix 
    34                 int time; 
    35                 //!  vector of rows that are presented in Dt 
    36                 ivec rowid; 
    37  
    38         public: 
    39                 int max_length() {return Data.cols();} 
    40                 void getdata ( vec &dt ) const; 
    41                 void getdata ( vec &dt, const ivec &indeces ); 
    42                 void set_drv (const RV &drv,const  RV &urv ); 
    43  
    44                 void write ( const vec &ut ) { 
    45                         bdm_error ( "MemDS::write is not supported" ); 
     30protected: 
     31        //! internal matrix of data 
     32        mat Data; 
     33        //! active column in the Data matrix 
     34        int time; 
     35        //!  vector of rows that are presented in Dt 
     36        ivec rowid; 
     37 
     38public: 
     39        int max_length() { 
     40                return Data.cols(); 
     41        } 
     42        void getdata ( vec &dt ) const; 
     43        void getdata ( vec &dt, const ivec &indeces ); 
     44        void set_drv ( const RV &drv, const  RV &urv ); 
     45 
     46        void write ( const vec &ut ) { 
     47                bdm_error ( "MemDS::write is not supported" ); 
     48        } 
     49 
     50        void write ( const vec &ut, const ivec &indices ) { 
     51                bdm_error ( "MemDS::write is not supported" ); 
     52        } 
     53 
     54        void step(); 
     55        //!Default constructor 
     56        MemDS () {}; 
     57        //! Convenience constructor 
     58        MemDS ( mat &Dat, ivec &rowid0 ); 
     59        /*! Create object from the following structure 
     60        \code 
     61        { class = "MemDS"; 
     62           Data = (...);            // Data matrix or data vector 
     63           --- optional --- 
     64           drv = {class="RV"; ...} // Identification how rows of the matrix Data will be known to others 
     65           time = 0;               // Index of the first column to user_info, 
     66           rowid = [1,2,3...];     // ids of rows to be used 
     67        } 
     68        \endcode 
     69 
     70        If the optional fields are not given, they will be filled as follows: 
     71        \code 
     72        rowid= [0, 1, 2, ...number_of_rows_of_Data]; 
     73        drv = {names=("ch0", "ch1", "ch2", ..."number_of_rows_of_Data"); 
     74              sizes=( 1    1    1 ...); 
     75                  times=( 0    0    0 ...); 
     76                  }; 
     77        time = 0; 
     78        \endcode 
     79        If \c rowid is given, \c drv will be named after indeces in rowids. 
     80 
     81        Hence the data provided by method \c getdata() will be full column of matrix Data starting from the first record. 
     82        */ 
     83        void from_setting ( const Setting &set ) { 
     84                UI::get ( Data, set, "Data", UI::compulsory ); 
     85                if ( !UI::get ( time, set, "time", UI::optional ) ) { 
     86                        time = 0; 
    4687                } 
    47  
    48                 void write ( const vec &ut, const ivec &indices ) { 
    49                         bdm_error ( "MemDS::write is not supported" ); 
     88                if ( !UI::get ( rowid, set, "rowid", UI::optional ) ) { 
     89                        rowid = linspace ( 0, Data.rows() - 1 ); 
    5090                } 
    51  
    52                 void step(); 
    53                 //!Default constructor 
    54                 MemDS () {}; 
    55                 //! Convenience constructor 
    56                 MemDS ( mat &Dat, ivec &rowid0); 
    57                 /*! Create object from the following structure 
    58                 \code 
    59                 { class = "MemDS"; 
    60                    Data = (...);            // Data matrix or data vector 
    61                    --- optional --- 
    62                    drv = {class="RV"; ...} // Identification how rows of the matrix Data will be known to others 
    63                    time = 0;               // Index of the first column to user_info, 
    64                    rowid = [1,2,3...];     // ids of rows to be used 
     91                shared_ptr<RV> r = UI::build<RV> ( set, "drv", UI::optional ); 
     92                if ( !r ) { 
     93                        r = new RV(); 
     94                        for ( int i = 0; i < rowid.length(); i++ ) { 
     95                                r->add ( RV ( "ch" + num2str ( rowid ( i ) ), 1, 0 ) ); 
     96                        } 
    6597                } 
    66                 \endcode 
    67                  
    68                 If the optional fields are not given, they will be filled as follows: 
    69                 \code 
    70                 rowid= [0, 1, 2, ...number_of_rows_of_Data]; 
    71                 drv = {names=("ch0", "ch1", "ch2", ..."number_of_rows_of_Data"); 
    72                       sizes=( 1    1    1 ...); 
    73                           times=( 0    0    0 ...); 
    74                           }; 
    75                 time = 0; 
    76                 \endcode 
    77                 If \c rowid is given, \c drv will be named after indeces in rowids. 
    78                  
    79                 Hence the data provided by method \c getdata() will be full column of matrix Data starting from the first record.  
    80                 */ 
    81                 void from_setting(const Setting &set){ 
    82                         UI::get(Data, set, "Data", UI::compulsory); 
    83                         if(!UI::get(time, set,"time", UI::optional)) {time =0;} 
    84                         if(!UI::get(rowid, set, "rowid",UI::optional)) {rowid =linspace(0,Data.rows()-1);} 
    85                         shared_ptr<RV> r=UI::build<RV>(set,"drv",UI::optional); 
    86                         if (!r) {r=new RV(); 
    87                                 for (int i=0; i<rowid.length(); i++){ r->add(RV("ch"+num2str(rowid(i)), 1, 0));} 
    88                         } 
    89                         set_drv(*r,RV()); //empty urv 
    90                         dtsize=r->_dsize(); 
    91                         ytsize = dtsize; 
    92                         utsize=0; 
    93                 } 
    94 }; 
    95 UIREGISTER(MemDS); 
     98                set_drv ( *r, RV() ); //empty urv 
     99                dtsize = r->_dsize(); 
     100                ytsize = dtsize; 
     101                utsize = 0; 
     102        } 
     103}; 
     104UIREGISTER ( MemDS ); 
    96105 
    97106/*!  \brief Simulate data from a static pdf (epdf) 
     
    101110 
    102111class EpdfDS: public DS { 
    103         protected: 
    104                 //! internal pointer to epdf from which we samplecond 
    105                 shared_ptr<epdf> iepdf; 
    106                 //! internal storage of data sample 
    107                 vec dt; 
    108         public: 
    109                 void step() { 
    110                         dt=iepdf->sample(); 
    111                 } 
    112                 void getdata ( vec &dt_out ) const { 
    113                         dt_out = dt; 
    114                 } 
    115                 void getdata ( vec &dt_out, const ivec &ids ) { 
    116                         dt_out = dt ( ids ); 
    117                 } 
    118                 const RV& _drv() const { 
    119                         return iepdf->_rv(); 
    120                 } 
    121  
    122                 /*! 
    123                 \code 
    124                 class = "EpdfDS"; 
    125                 epdf = {class="epdf_offspring", ...}// uncondtitional density to sample from 
    126                 \endcode 
    127  
    128                 */ 
    129                 void from_setting ( const Setting &set ) { 
    130                         iepdf=UI::build<epdf> ( set,"epdf",UI::compulsory ); 
    131                         bdm_assert(iepdf->isnamed(), "Input epdf must be named, check if RV is given correctly"); 
    132                         dt =  zeros(iepdf->dimension()); 
    133                         dtsize=dt.length(); 
    134                         ytsize=dt.length(); 
    135                         set_drv(iepdf->_rv(),RV()); 
    136                         utsize =0; 
    137                         validate(); 
    138                 } 
    139                 void validate() { 
    140                         dt = iepdf->sample(); 
    141                 } 
     112protected: 
     113        //! internal pointer to epdf from which we samplecond 
     114        shared_ptr<epdf> iepdf; 
     115        //! internal storage of data sample 
     116        vec dt; 
     117public: 
     118        void step() { 
     119                dt = iepdf->sample(); 
     120        } 
     121        void getdata ( vec &dt_out ) const { 
     122                dt_out = dt; 
     123        } 
     124        void getdata ( vec &dt_out, const ivec &ids ) { 
     125                dt_out = dt ( ids ); 
     126        } 
     127        const RV& _drv() const { 
     128                return iepdf->_rv(); 
     129        } 
     130 
     131        /*! 
     132        \code 
     133        class = "EpdfDS"; 
     134        epdf = {class="epdf_offspring", ...}// uncondtitional density to sample from 
     135        \endcode 
     136 
     137        */ 
     138        void from_setting ( const Setting &set ) { 
     139                iepdf = UI::build<epdf> ( set, "epdf", UI::compulsory ); 
     140                bdm_assert ( iepdf->isnamed(), "Input epdf must be named, check if RV is given correctly" ); 
     141                dt =  zeros ( iepdf->dimension() ); 
     142                dtsize = dt.length(); 
     143                ytsize = dt.length(); 
     144                set_drv ( iepdf->_rv(), RV() ); 
     145                utsize = 0; 
     146                validate(); 
     147        } 
     148        void validate() { 
     149                dt = iepdf->sample(); 
     150        } 
    142151}; 
    143152UIREGISTER ( EpdfDS ); 
     
    146155Still having only one density but allowing conditioning on either input or delayed values. 
    147156*/ 
    148 class PdfDS :public DS { 
    149         protected: 
    150                 //! internal pointer to epdf from which we samplecond 
    151                 shared_ptr<pdf> ipdf; 
    152                 //! internal storage of data sample 
    153                 vec yt; 
    154                 //! input vector 
    155                 vec ut; 
    156                 //! datalink between ut and regressor 
    157                 datalink_buffered ut2rgr; 
    158                 //! datalink between yt and regressor 
    159                 datalink_buffered yt2rgr; 
    160                 //! numeric values of regressor 
    161                 vec rgr; 
    162                  
    163         public: 
    164                 void step() { 
    165                         yt2rgr.store_data(yt); // y is now history 
    166                         ut2rgr.filldown ( ut,rgr ); 
    167                         yt2rgr.filldown ( yt,rgr ); 
    168                         yt=ipdf->samplecond ( rgr ); 
    169                         ut2rgr.store_data(ut); //u is now history 
     157class PdfDS : public DS { 
     158protected: 
     159        //! internal pointer to epdf from which we samplecond 
     160        shared_ptr<pdf> ipdf; 
     161        //! internal storage of data sample 
     162        vec yt; 
     163        //! input vector 
     164        vec ut; 
     165        //! datalink between ut and regressor 
     166        datalink_buffered ut2rgr; 
     167        //! datalink between yt and regressor 
     168        datalink_buffered yt2rgr; 
     169        //! numeric values of regressor 
     170        vec rgr; 
     171 
     172public: 
     173        void step() { 
     174                yt2rgr.store_data ( yt ); // y is now history 
     175                ut2rgr.filldown ( ut, rgr ); 
     176                yt2rgr.filldown ( yt, rgr ); 
     177                yt = ipdf->samplecond ( rgr ); 
     178                ut2rgr.store_data ( ut ); //u is now history 
     179        } 
     180        void getdata ( vec &dt_out ) const { 
     181                bdm_assert_debug ( dt_out.length() >= utsize + ytsize, "Short output vector" ); 
     182                dt_out.set_subvector ( 0, yt ); 
     183                dt_out.set_subvector ( ytsize, ut ); 
     184        } 
     185        void write ( const vec &ut0 ) { 
     186                ut = ut0; 
     187        } 
     188        void write ( const vec &ut0, const ivec &ind ) { 
     189                set_subvector ( ut, ind, ut0 ); 
     190        } 
     191 
     192        /*! 
     193        \code 
     194        class = "PdfDS"; 
     195        pdf = {class="pdf_offspring", ...};  // pdf to simulate 
     196        --- optional --- 
     197        init_rv = {class="RV",names=...};      // define what rv to initialize - typically delayed values! 
     198        init_values = [...];                   // vector of initial values corresponding to init_rv 
     199        \endcode 
     200 
     201        If init_rv is not given, init_values are set to zero. 
     202        */ 
     203        void from_setting ( const Setting &set ) { 
     204                ipdf = UI::build<pdf> ( set, "pdf", UI::compulsory ); 
     205 
     206                Yrv = ipdf->_rv(); 
     207                // get unique rvs form rvc 
     208                RV rgrv0 = ipdf->_rvc().remove_time(); 
     209                // input is what in not in Yrv 
     210                Urv = rgrv0.subt ( Yrv ); 
     211                set_drv ( Yrv, Urv ); 
     212                // connect input and output to rvc 
     213                ut2rgr.set_connection ( ipdf->_rvc(), Urv ); 
     214                yt2rgr.set_connection ( ipdf->_rvc(), Yrv ); 
     215 
     216                //set history - if given 
     217                shared_ptr<RV> rv_ini = UI::build<RV> ( set, "init_rv", UI::optional ); 
     218                if ( rv_ini ) { // check if 
     219                        vec val; 
     220                        UI::get ( val, set, "init_values", UI::optional ); 
     221                        if ( val.length() != rv_ini->_dsize() ) { 
     222                                bdm_error ( "init_rv and init_values fields have incompatible sizes" ); 
     223                        } else { 
     224                                ut2rgr.set_history ( *rv_ini, val ); 
     225                                yt2rgr.set_history ( *rv_ini, val ); 
     226                        } 
    170227                } 
    171                 void getdata ( vec &dt_out ) const { 
    172                         bdm_assert_debug(dt_out.length()>=utsize+ytsize,"Short output vector"); 
    173                         dt_out.set_subvector(0, yt); 
    174                         dt_out.set_subvector(ytsize, ut); 
    175                 } 
    176                 void write(const vec &ut0){ut=ut0;} 
    177                 void write(const vec &ut0, const ivec &ind){set_subvector(ut,ind,ut0);} 
    178                  
    179                 /*! 
    180                 \code 
    181                 class = "PdfDS"; 
    182                 pdf = {class="pdf_offspring", ...};  // pdf to simulate 
    183                 --- optional --- 
    184                 init_rv = {class="RV",names=...};      // define what rv to initialize - typically delayed values! 
    185                 init_values = [...];                   // vector of initial values corresponding to init_rv 
    186                 \endcode 
    187  
    188                 If init_rv is not given, init_values are set to zero. 
    189                 */ 
    190                 void from_setting ( const Setting &set ) { 
    191                         ipdf=UI::build<pdf> ( set,"pdf",UI::compulsory ); 
    192                          
    193                         Yrv = ipdf->_rv(); 
    194                         // get unique rvs form rvc 
    195                         RV rgrv0=ipdf->_rvc().remove_time(); 
    196                         // input is what in not in Yrv 
    197                         Urv=rgrv0.subt(Yrv);  
    198                         set_drv(Yrv, Urv); 
    199                         // connect input and output to rvc 
    200                         ut2rgr.set_connection(ipdf->_rvc(), Urv);  
    201                         yt2rgr.set_connection(ipdf->_rvc(), Yrv);  
    202                          
    203                         //set history - if given 
    204                         shared_ptr<RV> rv_ini=UI::build<RV>(set,"init_rv",UI::optional); 
    205                         if(rv_ini){ // check if  
    206                                 vec val; 
    207                                 UI::get(val, set, "init_values", UI::optional); 
    208                                 if (val.length()!=rv_ini->_dsize()){ 
    209                                         bdm_error("init_rv and init_values fields have incompatible sizes"); 
    210                                 } else { 
    211                                         ut2rgr.set_history(*rv_ini, val); 
    212                                         yt2rgr.set_history(*rv_ini, val); 
    213                                 } 
    214                         } 
    215  
    216                         yt = zeros ( ipdf->dimension() ); 
    217                         rgr = zeros ( ipdf->dimensionc() ); 
    218                         ut = zeros(Urv._dsize()); 
    219  
    220                         ytsize=yt.length(); 
    221                         utsize=ut.length(); 
    222                         dtsize = ytsize+utsize; 
    223                         validate(); 
    224                 } 
    225                 void validate() { 
    226                         //taken from sample() - shift of history is not done here 
    227                         ut2rgr.filldown ( ut,rgr ); 
    228                         yt2rgr.filldown ( yt,rgr ); 
    229                         yt=ipdf->samplecond ( rgr ); 
    230                 } 
     228 
     229                yt = zeros ( ipdf->dimension() ); 
     230                rgr = zeros ( ipdf->dimensionc() ); 
     231                ut = zeros ( Urv._dsize() ); 
     232 
     233                ytsize = yt.length(); 
     234                utsize = ut.length(); 
     235                dtsize = ytsize + utsize; 
     236                validate(); 
     237        } 
     238        void validate() { 
     239                //taken from sample() - shift of history is not done here 
     240                ut2rgr.filldown ( ut, rgr ); 
     241                yt2rgr.filldown ( yt, rgr ); 
     242                yt = ipdf->samplecond ( rgr ); 
     243        } 
    231244}; 
    232245UIREGISTER ( PdfDS ); 
     
    237250class FileDS: public MemDS { 
    238251 
    239         public: 
    240                 void getdata ( vec &dt ) { 
    241                         dt = Data.get_col ( time ); 
    242                 } 
    243  
    244                 void getdata ( vec &dt, const ivec &indices ) { 
    245                         vec tmp = Data.get_col ( time ); 
    246                         dt = tmp ( indices ); 
    247                 } 
    248  
    249                 //! returns number of data in the file; 
    250                 int ndat() { 
    251                         return Data.cols(); 
    252                 } 
    253                 //! no sense to log this type 
    254                 void log_register(logger &L, const string &prefix){}; 
    255                 //! no sense to log this type 
    256                 void log_write ( ) const {}; 
     252public: 
     253        void getdata ( vec &dt ) { 
     254                dt = Data.get_col ( time ); 
     255        } 
     256 
     257        void getdata ( vec &dt, const ivec &indices ) { 
     258                vec tmp = Data.get_col ( time ); 
     259                dt = tmp ( indices ); 
     260        } 
     261 
     262        //! returns number of data in the file; 
     263        int ndat() { 
     264                return Data.cols(); 
     265        } 
     266        //! no sense to log this type 
     267        void log_register ( logger &L, const string &prefix ) {}; 
     268        //! no sense to log this type 
     269        void log_write ( ) const {}; 
    257270}; 
    258271 
     
    265278class ITppFileDS: public FileDS { 
    266279 
    267         public: 
    268                 //! Convenience constructor 
    269                 ITppFileDS ( const string &fname, const string &varname ) : FileDS() { 
    270                         it_file it ( fname ); 
    271                         it << Name ( varname ); 
    272                         it >> Data; 
    273                         time = 0; 
    274                         //rowid and delays are ignored 
    275                 }; 
    276  
    277                 ITppFileDS () : FileDS() { 
    278                 }; 
    279  
    280                 void from_setting ( const Setting &set ); 
    281  
    282                 // TODO dodelat void to_setting( Setting &set ) const; 
     280public: 
     281        //! Convenience constructor 
     282        ITppFileDS ( const string &fname, const string &varname ) : FileDS() { 
     283                it_file it ( fname ); 
     284                it << Name ( varname ); 
     285                it >> Data; 
     286                time = 0; 
     287                //rowid and delays are ignored 
     288        }; 
     289 
     290        ITppFileDS () : FileDS() { 
     291        }; 
     292 
     293        void from_setting ( const Setting &set ); 
     294 
     295        // TODO dodelat void to_setting( Setting &set ) const; 
    283296 
    284297}; 
     
    296309class CsvFileDS: public FileDS { 
    297310 
    298         public: 
    299                 //! Constructor - create DS from a CSV file. 
    300                 CsvFileDS ( const string& fname, const string& orientation = "BY_COL" ); 
     311public: 
     312        //! Constructor - create DS from a CSV file. 
     313        CsvFileDS ( const string& fname, const string& orientation = "BY_COL" ); 
    301314}; 
    302315 
     
    307320//! State-space data source simulating two densities 
    308321class StateDS : public DS { 
    309         protected: 
    310                 //!conditional pdf of the state evolution \f$ f(x_t|x_{t-1}) \f$ 
    311                 shared_ptr<pdf> IM; 
    312  
    313                 //!conditional pdf of the observations \f$ f(d_t|x_t) \f$ 
    314                 shared_ptr<pdf> OM; 
    315  
    316                 //! result storage 
    317                 vec dt; 
    318                 //! state storage 
    319                 vec xt; 
    320                 //! input storage 
    321                 vec ut; 
    322  
    323                 //! datalink from ut to IM.rvc 
    324                 datalink_part u2imc; 
    325                 //! datalink from ut to OM.rvc 
    326                 datalink_part u2omc; 
    327         public: 
    328                 void getdata ( vec &dt0 ) const { 
    329                         dt0 = dt; 
    330                 } 
    331                 void write (const vec &ut0 ) { 
    332                         ut = ut0; 
    333                 } 
    334                  
    335                 void getdata ( vec &dt0, const ivec &indices ) { 
    336                         dt0 = dt ( indices ); 
    337                 } 
    338  
    339                 virtual void step() { 
    340                         vec imc(IM->dimensionc()); 
    341                         imc.set_subvector(0,xt); 
    342                         u2imc.filldown(ut,imc); 
    343                         xt = IM->samplecond ( imc ); 
    344                          
    345                         vec omc(OM->dimensionc()); 
    346                         omc.set_subvector(0,xt); 
    347                         u2omc.filldown(ut,omc); 
    348                         vec yt; 
    349                         yt = OM->samplecond ( omc ); 
    350                         //fill all data 
    351                         dt.set_subvector(0,yt); 
    352                         dt.set_subvector(yt.length(),xt); 
    353                         dt.set_subvector(ytsize,ut); 
    354                 } 
    355  
    356                 //! set parameters 
    357                 void set_parameters(shared_ptr<pdf> IM0, shared_ptr<pdf> OM0){ 
    358                         IM=IM0; 
    359                         OM = OM0; 
    360                 } 
    361                 void set_initx(const vec &x0){xt=x0;} 
    362  
    363                 /*! UI for stateDS 
    364  
    365                 The DS is constructed from a structure with fields: 
    366                 \code 
    367                 class = "stateDS"; 
    368                 //Internal model 
    369                 IM = { type = "pdf-offspring"; }; 
    370                 //Observation model 
    371                 OM = { type = "pdf-offspring"; } 
    372                 //initial state 
    373                 x0 = [...]; //vector of data 
    374                 \endcode 
    375                 Both models must have defined \c rv. and \c rvc 
    376                 Random variables not found in any rv are considered to be inputs. 
    377                 */ 
    378                 void from_setting ( const Setting &set ); 
    379  
    380                 // TODO dodelat void to_setting( Setting &set ) const; 
    381  
    382                 void validate(); 
     322protected: 
     323        //!conditional pdf of the state evolution \f$ f(x_t|x_{t-1}) \f$ 
     324        shared_ptr<pdf> IM; 
     325 
     326        //!conditional pdf of the observations \f$ f(d_t|x_t) \f$ 
     327        shared_ptr<pdf> OM; 
     328 
     329        //! result storage 
     330        vec dt; 
     331        //! state storage 
     332        vec xt; 
     333        //! input storage 
     334        vec ut; 
     335 
     336        //! datalink from ut to IM.rvc 
     337        datalink_part u2imc; 
     338        //! datalink from ut to OM.rvc 
     339        datalink_part u2omc; 
     340public: 
     341        void getdata ( vec &dt0 ) const { 
     342                dt0 = dt; 
     343        } 
     344        void write ( const vec &ut0 ) { 
     345                ut = ut0; 
     346        } 
     347 
     348        void getdata ( vec &dt0, const ivec &indices ) { 
     349                dt0 = dt ( indices ); 
     350        } 
     351 
     352        virtual void step() { 
     353                vec imc ( IM->dimensionc() ); 
     354                imc.set_subvector ( 0, xt ); 
     355                u2imc.filldown ( ut, imc ); 
     356                xt = IM->samplecond ( imc ); 
     357 
     358                vec omc ( OM->dimensionc() ); 
     359                omc.set_subvector ( 0, xt ); 
     360                u2omc.filldown ( ut, omc ); 
     361                vec yt; 
     362                yt = OM->samplecond ( omc ); 
     363                //fill all data 
     364                dt.set_subvector ( 0, yt ); 
     365                dt.set_subvector ( yt.length(), xt ); 
     366                dt.set_subvector ( ytsize, ut ); 
     367        } 
     368 
     369        //! set parameters 
     370        void set_parameters ( shared_ptr<pdf> IM0, shared_ptr<pdf> OM0 ) { 
     371                IM = IM0; 
     372                OM = OM0; 
     373        } 
     374        void set_initx ( const vec &x0 ) { 
     375                xt = x0; 
     376        } 
     377 
     378        /*! UI for stateDS 
     379 
     380        The DS is constructed from a structure with fields: 
     381        \code 
     382        class = "stateDS"; 
     383        //Internal model 
     384        IM = { type = "pdf-offspring"; }; 
     385        //Observation model 
     386        OM = { type = "pdf-offspring"; } 
     387        //initial state 
     388        x0 = [...]; //vector of data 
     389        \endcode 
     390        Both models must have defined \c rv. and \c rvc 
     391        Random variables not found in any rv are considered to be inputs. 
     392        */ 
     393        void from_setting ( const Setting &set ); 
     394 
     395        // TODO dodelat void to_setting( Setting &set ) const; 
     396 
     397        void validate(); 
    383398}; 
    384399