Changeset 1064 for library/bdm/mex

Show
Ignore:
Timestamp:
06/09/10 14:00:40 (14 years ago)
Author:
mido
Message:

astyle applied all over the library

Location:
library/bdm/mex
Files:
6 modified

Legend:

Unmodified
Added
Removed

  • library/bdm/mex/mex_BM.h

    r944 r1064  
    11#include <mex/mex_parser.h> 
    22#include <mex/mex_pdf.h> 
    3 class mexBM: public BM{ 
    4         protected: 
    5                 mxArray *data; 
    6                 mexEpdf est; 
    7         public: 
    8                 mexBM() {}; 
    9                 void from_setting(const Setting &S)  { 
    10                         Setting &So=S["object"]; 
    11                         data = (mxArray*)long(So); 
    12                 }  
    13                 void validate() { 
    14                         mxArray *tmp; 
    15                         mexCallMATLAB(1, &tmp, 1, &data,  "validate"); 
    16                         // new object is in tmp 
    17                         data = tmp; 
    18                          
    19                         mexCallMATLAB(1, &tmp, 1, &data, "dimensions"); 
    20                         vec v=mxArray2vec(tmp); 
    21                         if (v.length()<3) {bdm_error("Three dimensions are expected in mexBM.dimensions");} 
    22                         set_dim(v(0)); 
    23                         dimy = v(1); 
    24                         dimc = v(2); 
    25                          
    26                         mexCallMATLAB(1, &tmp, 1, &data, "get_rv"); 
    27                         UImxArray rvtmp(tmp); 
    28                         shared_ptr<RV> r = UI::build<RV>(rvtmp); 
    29                         set_rv(*r); 
    30                          
    31                         mexCallMATLAB(1, &tmp, 1, &data, "get_rvc"); 
    32                         UImxArray rvtmpc(tmp); 
    33                         shared_ptr<RV> rc = UI::build<RV>(rvtmpc); 
    34                         rvtmpc.writeFile("tmpc.cfg"); 
    35                         rvc=*rc; 
    36                          
    37                         mexCallMATLAB(1, &tmp, 1, &data, "get_rvy"); 
    38                         UImxArray rvtmpy(tmp); 
    39                         rvtmpy.writeFile("tmpy.cfg"); 
    40                         shared_ptr<RV> ry = UI::build<RV>(rvtmpy); 
    41                         yrv = *ry; 
    42                          
    43                 } 
    44                 void bayes(const vec &dt, const vec &cond) { 
    45                         mxArray *tmp; 
    46                         mxArray *in[3]; 
    47                         in[0]=data; 
    48                         in[1]=mxCreateDoubleMatrix(dt.length(),1,mxREAL); 
    49                         vec2mxArray(dt,in[1]); 
    50                         in[2]=mxCreateDoubleMatrix(cond.length(),1,mxREAL); 
    51                         vec2mxArray(cond,in[2]); 
    52                          
    53                         mexCallMATLAB(1, &tmp, 3, in, "bayes"); 
    54                         data = tmp; 
    55                 } 
    56                 epdf* predictor(const vec &cond) const { 
    57                         mxArray *tmp; 
    58                         mxArray *in[3]; 
    59                         in[0]=data; 
    60                         in[1]=mxCreateDoubleMatrix(cond.length(),1,mxREAL); 
    61                         vec2mxArray(cond,in[1]); 
    62                          
    63                         mexCallMATLAB(1, &tmp, 3, in, "predictor"); 
    64                          
    65                         UImxArray uitmp(tmp); 
    66                         shared_ptr<epdf> pred = UI::build<epdf>(uitmp); 
    67                         return pred.get(); 
    68                         // 
    69                 } 
    70                 const epdf& posterior() const { 
    71                         mxArray *tmp; 
    72                         mexCallMATLAB(1, &tmp, 1,(mxArray **) &data,  "posterior"); 
    73                         const_cast<mexEpdf*>(&est)->set_data(tmp); 
    74                         return est; 
    75                 } 
     3class mexBM: public BM { 
     4protected: 
     5    mxArray *data; 
     6    mexEpdf est; 
     7public: 
     8    mexBM() {}; 
     9    void from_setting(const Setting &S)  { 
     10        Setting &So=S["object"]; 
     11        data = (mxArray*)long(So); 
     12    } 
     13    void validate() { 
     14        mxArray *tmp; 
     15        mexCallMATLAB(1, &tmp, 1, &data,  "validate"); 
     16        // new object is in tmp 
     17        data = tmp; 
     18 
     19        mexCallMATLAB(1, &tmp, 1, &data, "dimensions"); 
     20        vec v=mxArray2vec(tmp); 
     21        if (v.length()<3) { 
     22            bdm_error("Three dimensions are expected in mexBM.dimensions"); 
     23        } 
     24        set_dim(v(0)); 
     25        dimy = v(1); 
     26        dimc = v(2); 
     27 
     28        mexCallMATLAB(1, &tmp, 1, &data, "get_rv"); 
     29        UImxArray rvtmp(tmp); 
     30        shared_ptr<RV> r = UI::build<RV>(rvtmp); 
     31        set_rv(*r); 
     32 
     33        mexCallMATLAB(1, &tmp, 1, &data, "get_rvc"); 
     34        UImxArray rvtmpc(tmp); 
     35        shared_ptr<RV> rc = UI::build<RV>(rvtmpc); 
     36        rvtmpc.writeFile("tmpc.cfg"); 
     37        rvc=*rc; 
     38 
     39        mexCallMATLAB(1, &tmp, 1, &data, "get_rvy"); 
     40        UImxArray rvtmpy(tmp); 
     41        rvtmpy.writeFile("tmpy.cfg"); 
     42        shared_ptr<RV> ry = UI::build<RV>(rvtmpy); 
     43        yrv = *ry; 
     44 
     45    } 
     46    void bayes(const vec &dt, const vec &cond) { 
     47        mxArray *tmp; 
     48        mxArray *in[3]; 
     49        in[0]=data; 
     50        in[1]=mxCreateDoubleMatrix(dt.length(),1,mxREAL); 
     51        vec2mxArray(dt,in[1]); 
     52        in[2]=mxCreateDoubleMatrix(cond.length(),1,mxREAL); 
     53        vec2mxArray(cond,in[2]); 
     54 
     55        mexCallMATLAB(1, &tmp, 3, in, "bayes"); 
     56        data = tmp; 
     57    } 
     58    epdf* predictor(const vec &cond) const { 
     59        mxArray *tmp; 
     60        mxArray *in[3]; 
     61        in[0]=data; 
     62        in[1]=mxCreateDoubleMatrix(cond.length(),1,mxREAL); 
     63        vec2mxArray(cond,in[1]); 
     64 
     65        mexCallMATLAB(1, &tmp, 3, in, "predictor"); 
     66 
     67        UImxArray uitmp(tmp); 
     68        shared_ptr<epdf> pred = UI::build<epdf>(uitmp); 
     69        return pred.get(); 
     70        // 
     71    } 
     72    const epdf& posterior() const { 
     73        mxArray *tmp; 
     74        mexCallMATLAB(1, &tmp, 1,(mxArray **) &data,  "posterior"); 
     75        const_cast<mexEpdf*>(&est)->set_data(tmp); 
     76        return est; 
     77    } 
    7678}; 
    7779UIREGISTER(mexBM); 

  • library/bdm/mex/mex_datasource.h

    r1060 r1064  
    99namespace bdm { 
    1010/*! 
    11 * \brief DataSource reading data columns from a Matlab matrix  
     11* \brief DataSource reading data columns from a Matlab matrix 
    1212 
    13 The data are stored in a arbitrary Matlab matrix. Each column of the matrix corresponds to one discrete time observation \f$t\f$.  
     13The data are stored in a arbitrary Matlab matrix. Each column of the matrix corresponds to one discrete time observation \f$t\f$. 
    1414The DataSource needs to know the name of the matrix and possibly decription of its contents (via RV)_ 
    1515 
    1616*/ 
    1717class mxArrayDS : public DS { 
    18         protected: 
    19                 //! raw pointer to data 
    20                 double *data; 
    21                 //! maximum length of data 
    22                 int max_len; 
    23                 //! active column  
    24                 int column; 
     18protected: 
     19    //! raw pointer to data 
     20    double *data; 
     21    //! maximum length of data 
     22    int max_len; 
     23    //! active column 
     24    int column; 
    2525public: 
    26          
    27         //!Default constructor 
    28         mxArrayDS () : DS() {}; 
    2926 
    30         /*! Create object from the following structure 
     27    //!Default constructor 
     28    mxArrayDS () : DS() {}; 
    3129 
    32         \code 
    33         class   = 'mxArrayDS'; 
    34         varname = 'data_matrix';                   % name of a Matlab workspace variable 
    35         -- inherited fields --- 
    36         bdm::DS::from_setting 
    37         drv     = RV({'names',...},[sizes,...]);   % names of data redords in columns 
    38         \endcode 
    39          
    40         */ 
    41         void from_setting ( const Setting &set ) { 
    42                 string name; 
    43                 UI::get(name, set, "varname", UI::compulsory); 
    44                 mxArray *mxAr = mexGetVariable ( "base", name.c_str() ); 
    45                  
    46                 bdm_assert(mxIsNumeric(mxAr),"Matlab variable: "+name +" is not a matrix"); 
    47                  
    48                 dtsize = mxGetM(mxAr); 
    49                 max_len= mxGetN(mxAr); 
    50                 data = (double*)mxGetPr(mxAr); 
    51                 utsize = 0; 
     30    /*! Create object from the following structure 
    5231 
    53                 DS::from_setting(set); //read drv 
    54                  
    55                 if (Drv._dsize()!=dtsize){ 
    56                         Drv=RV( ( const char* ) set["varname"], dtsize ); 
    57                 } 
    58                 column = 0; 
    59          
    60                 if (max_length()>0){ 
    61                         dt = vec(&data[column*dtsize],dtsize); 
    62                 } 
    63         } 
     32    \code 
     33    class   = 'mxArrayDS'; 
     34    varname = 'data_matrix';                   % name of a Matlab workspace variable 
     35    -- inherited fields --- 
     36    bdm::DS::from_setting 
     37    drv     = RV({'names',...},[sizes,...]);   % names of data redords in columns 
     38    \endcode 
    6439 
    65         int max_length() {return max_len;} 
    66          
    67         void step(){ 
    68                 if (column<max_length()){ 
    69                         column++; 
    70                  
    71                         dt = vec(&data[column*dtsize],dtsize); 
    72                 } else { 
    73                         bdm_error("DS: trying to read after max_length()"); 
    74                 } 
    75         } 
     40    */ 
     41    void from_setting ( const Setting &set ) { 
     42        string name; 
     43        UI::get(name, set, "varname", UI::compulsory); 
     44        mxArray *mxAr = mexGetVariable ( "base", name.c_str() ); 
     45 
     46        bdm_assert(mxIsNumeric(mxAr),"Matlab variable: "+name +" is not a matrix"); 
     47 
     48        dtsize = mxGetM(mxAr); 
     49        max_len= mxGetN(mxAr); 
     50        data = (double*)mxGetPr(mxAr); 
     51        utsize = 0; 
     52 
     53        DS::from_setting(set); //read drv 
     54 
     55        if (Drv._dsize()!=dtsize) { 
     56            Drv=RV( ( const char* ) set["varname"], dtsize ); 
     57        } 
     58        column = 0; 
     59 
     60        if (max_length()>0) { 
     61            dt = vec(&data[column*dtsize],dtsize); 
     62        } 
     63    } 
     64 
     65    int max_length() { 
     66        return max_len; 
     67    } 
     68 
     69    void step() { 
     70        if (column<max_length()) { 
     71            column++; 
     72 
     73            dt = vec(&data[column*dtsize],dtsize); 
     74        } else { 
     75            bdm_error("DS: trying to read after max_length()"); 
     76        } 
     77    } 
    7678}; 
    7779 

  • library/bdm/mex/mex_function.h

    r885 r1064  
    88namespace bdm { 
    99 
    10         /*! class mapping fnc.eval to call of matlab function via mexCallMatlab 
    11         */ 
    12         class mexFnc: public fnc{ 
    13                 protected: 
    14                 string fname; 
    15                 public: 
    16                         vec eval(const vec &cond){ 
    17                                 mxArray *mxinp = mxCreateDoubleMatrix ( cond.length(), 1, mxREAL ); 
    18                                 mxArray *mxout; 
    19                                  
    20                                 vec2mxArray(cond,mxinp); 
    21                                 mexCallMATLAB ( 1, &mxout, 1, &mxinp, fname.c_str() ); 
    22                                  
    23                                 bdm_assert(int(mxGetN(mxout))==(dimension()) || int(mxGetM(mxout))==(dimension()), "vector length mismatch"); 
    24                                 vec tmp=mxArray2vec(mxout); 
    25                                 return tmp; 
    26                         } 
    27                         /*!  
    28                         \code 
    29                         function = 'matlab_function_name'; 
    30                         \endcode 
    31                         */ 
    32                         void from_setting(const Setting &set){ 
    33                                 fnc::from_setting(set); 
    34                                 UI::get(fname, set, "function", UI::compulsory); 
    35                         } 
    36                         void to_setting(Setting &set) const { 
    37                                 fnc::to_setting(set); 
    38                                 UI::save(fname, set, "function"); 
    39                         } 
    40         }; 
    41         UIREGISTER(mexFnc); 
     10/*! class mapping fnc.eval to call of matlab function via mexCallMatlab 
     11*/ 
     12class mexFnc: public fnc { 
     13protected: 
     14    string fname; 
     15public: 
     16    vec eval(const vec &cond) { 
     17        mxArray *mxinp = mxCreateDoubleMatrix ( cond.length(), 1, mxREAL ); 
     18        mxArray *mxout; 
     19 
     20        vec2mxArray(cond,mxinp); 
     21        mexCallMATLAB ( 1, &mxout, 1, &mxinp, fname.c_str() ); 
     22 
     23        bdm_assert(int(mxGetN(mxout))==(dimension()) || int(mxGetM(mxout))==(dimension()), "vector length mismatch"); 
     24        vec tmp=mxArray2vec(mxout); 
     25        return tmp; 
     26    } 
     27    /*! 
     28    \code 
     29    function = 'matlab_function_name'; 
     30    \endcode 
     31    */ 
     32    void from_setting(const Setting &set) { 
     33        fnc::from_setting(set); 
     34        UI::get(fname, set, "function", UI::compulsory); 
     35    } 
     36    void to_setting(Setting &set) const { 
     37        fnc::to_setting(set); 
     38        UI::save(fname, set, "function"); 
     39    } 
     40}; 
     41UIREGISTER(mexFnc); 
    4242} 
    4343#endif //MXFNC_H 

  • library/bdm/mex/mex_logger.h

    r900 r1064  
    66namespace bdm { 
    77int mxReplaceFieldNM ( mxArray *X, const char * fname, mxArray *X1 ) { 
    8         mxArray *Old; 
    9         int i; 
     8    mxArray *Old; 
     9    int i; 
    1010 
    11         if ( ( i = mxGetFieldNumber ( X, fname ) ) == -1 ) { 
    12                 if ( ( i = mxAddField ( X, fname ) ) == -1 ) return i; 
     11    if ( ( i = mxGetFieldNumber ( X, fname ) ) == -1 ) { 
     12        if ( ( i = mxAddField ( X, fname ) ) == -1 ) return i; 
    1313 
    14         } 
     14    } 
    1515 
    16         Old = mxGetFieldByNumber ( X, 0, i ); 
    17         if ( Old ) mxDestroyArray ( Old ); 
    18         mxSetFieldByNumber ( X, 0, i, X1 ); 
    19         return i; 
     16    Old = mxGetFieldByNumber ( X, 0, i ); 
     17    if ( Old ) mxDestroyArray ( Old ); 
     18    mxSetFieldByNumber ( X, 0, i, X1 ); 
     19    return i; 
    2020 
    2121}; 
    2222 
    2323void Arrayvec2mxArray ( const Array<vec> &in, mxArray *out ) { 
    24         int rows, cols, r, c; 
     24    int rows, cols, r, c; 
    2525 
    26         double* temp = ( double * ) mxGetPr ( out ); 
    27         if ( temp == 0 ) mexErrMsgTxt ( "mat2mxArray: Pointer to data is NULL" ); 
     26    double* temp = ( double * ) mxGetPr ( out ); 
     27    if ( temp == 0 ) mexErrMsgTxt ( "mat2mxArray: Pointer to data is NULL" ); 
    2828 
    29         cols = in.size(); 
    30         if ( cols == 0 ) mexErrMsgTxt ( "mat2mxArray: Data has zero columns" ); 
     29    cols = in.size(); 
     30    if ( cols == 0 ) mexErrMsgTxt ( "mat2mxArray: Data has zero columns" ); 
    3131 
    32         rows = in ( 0 ).length(); //length of the first vec 
    33         if ( rows == 0 ) mexErrMsgTxt ( "mat2mxArray: Data has zero rows" ); 
     32    rows = in ( 0 ).length(); //length of the first vec 
     33    if ( rows == 0 ) mexErrMsgTxt ( "mat2mxArray: Data has zero rows" ); 
    3434 
    35         for ( c = 0; c < cols; c++ ) { 
    36                 for ( r = 0; r < rows; r++ ) { 
    37                         *temp++ = in ( c ) ( r ); 
     35    for ( c = 0; c < cols; c++ ) { 
     36        for ( r = 0; r < rows; r++ ) { 
     37            *temp++ = in ( c ) ( r ); 
    3838 
    39                 } 
    40         } 
     39        } 
     40    } 
    4141 
    4242} 
    … …  
    4545class mexlog : public memlog { 
    4646public: 
    47         //! constructor 
    48         mexlog() : memlog ( 0, "" ) {}; 
    49         //! constructor 
    50         mexlog ( long maxlen0 ) : memlog ( maxlen0, "" ) {}; 
    51         //! copy internal data to output mxArray 
    52         mxArray* toCell() { 
    53                 mxArray* tmp = mxCreateStructMatrix ( 1, 1, 0, NULL ); 
     47    //! constructor 
     48    mexlog() : memlog ( 0, "" ) {}; 
     49    //! constructor 
     50    mexlog ( long maxlen0 ) : memlog ( maxlen0, "" ) {}; 
     51    //! copy internal data to output mxArray 
     52    mxArray* toCell() { 
     53        mxArray* tmp = mxCreateStructMatrix ( 1, 1, 0, NULL ); 
    5454 
    55                 //copied from itsave 
    56                 int i; 
    57                 string vec_name = ""; 
    58                 int istart, iend; 
     55        //copied from itsave 
     56        int i; 
     57        string vec_name = ""; 
     58        int istart, iend; 
    5959 
    60                 mat M; //temporary matrix 
    61                 for ( i = 0; i < entries.length(); i++ ) { 
    62                         istart = 0; 
    63                         for ( int j = 0; j < entries ( i ).length(); j++ ) { // same for as in add!!! 
    64                                 vec_name = names ( i ) + separator + entries ( i ).name ( j ); 
    65                                 iend = istart + entries ( i ).size ( j ) - 1; 
    66                                 M = vectors ( i ).get_cols ( istart, iend ); 
    67                                 istart = iend + 1; 
    68                                 // copy the selection to mx 
    69                                 mxArray* fld = mxCreateDoubleMatrix ( M.rows(), M.cols(), mxREAL ); 
    70                                 mat2mxArray ( M, fld ); 
    71                                 mxReplaceFieldNM ( tmp, vec_name.c_str(), fld ); 
    72                         } 
    73                 } 
    74                 return tmp; 
    75         } 
    76         void from_setting ( const Setting &root ) { 
    77                 maxlen = root["maxlen"]; 
    78         } 
    79         Config& _setting_conf() { 
    80                 return setting_conf; 
    81         } 
     60        mat M; //temporary matrix 
     61        for ( i = 0; i < entries.length(); i++ ) { 
     62            istart = 0; 
     63            for ( int j = 0; j < entries ( i ).length(); j++ ) { // same for as in add!!! 
     64                vec_name = names ( i ) + separator + entries ( i ).name ( j ); 
     65                iend = istart + entries ( i ).size ( j ) - 1; 
     66                M = vectors ( i ).get_cols ( istart, iend ); 
     67                istart = iend + 1; 
     68                // copy the selection to mx 
     69                mxArray* fld = mxCreateDoubleMatrix ( M.rows(), M.cols(), mxREAL ); 
     70                mat2mxArray ( M, fld ); 
     71                mxReplaceFieldNM ( tmp, vec_name.c_str(), fld ); 
     72            } 
     73        } 
     74        return tmp; 
     75    } 
     76    void from_setting ( const Setting &root ) { 
     77        maxlen = root["maxlen"]; 
     78    } 
     79    Config& _setting_conf() { 
     80        return setting_conf; 
     81    } 
    8282}; 
    8383UIREGISTER ( mexlog ); 

  • library/bdm/mex/mex_parser.h

    r969 r1064  
    1616class UImxArray : public Config { 
    1717public: 
    18         //! Build an instance of Config with fields filled from the given \a mxarray 
    19         UImxArray ( const mxArray *mxarray ) : Config() { 
    20                 Setting & setting = this->getRoot(); //setting is a group 
    21                 if ( !mxIsStruct ( mxarray ) ) { 
    22                         mexErrMsgTxt ( "Given mxArray is not a struct." ); 
    23                 }; 
    24  
    25                 //mexCallMATLAB(0, NULL, 1, (mxArray **) &mxarray, "dump"); 
    26                 fillGroup ( setting, mxarray ); 
    27                 setAutoConvert ( true ); 
    28         } 
    29         UImxArray() : Config() { 
    30                 setAutoConvert ( true ); 
    31         } 
    32         //! Add libconfig's \c list to the structure 
    33         void addList ( const mxArray *mxarray, const char* name ) { 
    34                 Setting & setting = this->getRoot(); //setting is a group 
    35                 Setting & child = setting.add ( name, Setting::TypeList ); 
    36                 fillList ( child, mxarray ); 
    37         } 
    38         //! Add libconfig's \c group to the structure 
    39         void addGroup ( const mxArray *mxarray, const char* name ) { 
    40                 Setting & setting = this->getRoot(); //setting is a group 
    41                 Setting & child = setting.add ( name, Setting::TypeGroup ); 
    42                 fillGroup ( child, mxarray ); 
    43         } 
    44         //! Operator for more convenient access to this Config 
    45         operator Setting&() { 
    46                 return getRoot(); 
    47         } 
     18    //! Build an instance of Config with fields filled from the given \a mxarray 
     19    UImxArray ( const mxArray *mxarray ) : Config() { 
     20        Setting & setting = this->getRoot(); //setting is a group 
     21        if ( !mxIsStruct ( mxarray ) ) { 
     22            mexErrMsgTxt ( "Given mxArray is not a struct." ); 
     23        }; 
     24 
     25        //mexCallMATLAB(0, NULL, 1, (mxArray **) &mxarray, "dump"); 
     26        fillGroup ( setting, mxarray ); 
     27        setAutoConvert ( true ); 
     28    } 
     29    UImxArray() : Config() { 
     30        setAutoConvert ( true ); 
     31    } 
     32    //! Add libconfig's \c list to the structure 
     33    void addList ( const mxArray *mxarray, const char* name ) { 
     34        Setting & setting = this->getRoot(); //setting is a group 
     35        Setting & child = setting.add ( name, Setting::TypeList ); 
     36        fillList ( child, mxarray ); 
     37    } 
     38    //! Add libconfig's \c group to the structure 
     39    void addGroup ( const mxArray *mxarray, const char* name ) { 
     40        Setting & setting = this->getRoot(); //setting is a group 
     41        Setting & child = setting.add ( name, Setting::TypeGroup ); 
     42        fillGroup ( child, mxarray ); 
     43    } 
     44    //! Operator for more convenient access to this Config 
     45    operator Setting&() { 
     46        return getRoot(); 
     47    } 
    4848 
    4949private: 
    50         void storeNumeric ( Setting &setting, const mxArray *value, string key = "" ) { 
    51                 //TODO: integer matrices 
    52                 if ( !mxIsNumeric ( value ) ) { 
    53                         mexErrMsgTxt ( "Given mxArray is not numeric." ); 
    54                 }; 
    55                 //treat empty matrices independently 
    56                 mat val; 
    57                 if ( mxGetM ( value ) > 0 && mxGetN(value)>0) { 
    58                         val = mxArray2mat ( value ); 
    59                 } 
    60                 if ( ( val.rows() == 1 ) && ( val.cols() == 1 ) ) { 
    61                         Setting &child = ( key == "" ) ? setting.add ( Setting::TypeFloat ) 
    62                                          : setting.add ( key, Setting::TypeFloat ); 
    63                         child = val ( 0, 0 ); 
    64                 } else { 
    65                         Setting &child = ( key == "" ) ? setting.add ( Setting::TypeList ) 
    66                                          : setting.add ( key, Setting::TypeList ); 
    67                         Setting &label = child.add ( Setting::TypeString ); 
    68                         label = "matrix"; 
    69                         Setting &rows = child.add ( Setting::TypeInt ); 
    70                         Setting &cols = child.add ( Setting::TypeInt ); 
    71                         Setting &elements = child.add ( Setting::TypeArray ); 
    72                         cols = val.cols(); 
    73                         rows = val.rows(); 
    74                         for ( int i = 0; i < val.rows(); i++ ) { 
    75                                 for ( int j = 0; j < val.cols(); j++ ) { 
    76                                         Setting &el = elements.add ( Setting::TypeFloat ); 
    77                                         el = val ( i, j ); 
    78                                 } 
    79                         } 
    80                 } 
    81         } 
    82  
    83         void fillGroup ( Setting &setting, const mxArray *mxarray ) { 
    84                 if ( !mxIsStruct ( mxarray ) ) { 
    85                         mexErrMsgTxt ( "Given mxArray is not a struct." ); 
    86                 }; 
    87                 for ( int i = 0; i < mxGetNumberOfFields ( mxarray ); i++ ) { 
    88                         const char *key = mxGetFieldNameByNumber ( mxarray, i ); 
    89                         mxArray *value = mxGetField ( mxarray, 0, key ); 
    90                         if ( mxIsChar ( value ) ) { 
    91                                 Setting &child = setting.add ( key, Setting::TypeString ); 
    92                                 child = mxArray2string ( value ); 
    93                                 } else { 
    94                         if ( mxIsLogical ( value ) ) { 
    95                                 Setting &child = setting.add ( key, Setting::TypeBoolean ); 
    96                                 child = ( bool ) mxArray2bin ( value ); 
    97                         } else { 
    98                         if ( mxIsStruct ( value ) ) { 
    99                                 Setting &child = setting.add ( key, Setting::TypeGroup ); 
    100                                 fillGroup ( child, value ); 
    101                         } else { 
    102                         if ( mxIsCell ( value ) ) { 
    103                                 Setting &child = setting.add ( key, Setting::TypeList ); 
    104                                 fillList ( child, value ); 
    105                         } else { 
    106                         if ( mxIsNumeric ( value ) ) { 
    107                                 storeNumeric ( setting, value, ( string ) key ); 
    108                         } else { 
    109                         // it is neither of above - treat it as an address 
    110                         // if (mxIsObject(value)){ <== should be tested but it is broken in matlab... 
    111                          
    112                                 Setting &child = setting.add(key, Setting::TypeInt64); 
    113                                 child = (long long)value; 
    114                         } 
    115                         } 
    116                         } 
    117                         } 
    118                                 } 
    119                 } 
    120         } 
    121  
    122         void fillList ( Setting &setting, const mxArray *mxarray ) { 
    123                 if ( !mxIsCell ( mxarray ) ) { 
    124                         mexErrMsgTxt ( "Given mxArray is not a cell." ); 
    125                 }; 
    126                 for ( unsigned int i = 0; i < ( unsigned int ) mxGetNumberOfElements ( mxarray ); i++ ) { 
    127                         mxArray *value = mxGetCell ( mxarray, i ); 
    128                         if ( mxIsChar ( value ) ) { 
    129                                 Setting &child = setting.add ( Setting::TypeString ); 
    130                                 child = mxArray2string ( value ); 
    131                         } 
    132                         if ( mxIsLogical ( value ) ) { 
    133                                 Setting &child = setting.add ( Setting::TypeBoolean ); 
    134                                 child = ( bool ) mxArray2bin ( value ); 
    135                         } 
    136                         if ( mxIsStruct ( value ) ) { 
    137                                 Setting &child = setting.add ( Setting::TypeGroup ); 
    138                                 fillGroup ( child, value ); 
    139                         } 
    140                         if ( mxIsCell ( value ) ) { 
    141                                 Setting &child = setting.add ( Setting::TypeList ); 
    142                                 fillList ( child, value ); 
    143                         } 
    144                         if ( mxIsNumeric ( value ) ) { 
    145                                 storeNumeric ( setting, value ); 
    146                         } 
    147                 } 
    148         } 
     50    void storeNumeric ( Setting &setting, const mxArray *value, string key = "" ) { 
     51        //TODO: integer matrices 
     52        if ( !mxIsNumeric ( value ) ) { 
     53            mexErrMsgTxt ( "Given mxArray is not numeric." ); 
     54        }; 
     55        //treat empty matrices independently 
     56        mat val; 
     57        if ( mxGetM ( value ) > 0 && mxGetN(value)>0) { 
     58            val = mxArray2mat ( value ); 
     59        } 
     60        if ( ( val.rows() == 1 ) && ( val.cols() == 1 ) ) { 
     61            Setting &child = ( key == "" ) ? setting.add ( Setting::TypeFloat ) 
     62                             : setting.add ( key, Setting::TypeFloat ); 
     63            child = val ( 0, 0 ); 
     64        } else { 
     65            Setting &child = ( key == "" ) ? setting.add ( Setting::TypeList ) 
     66                             : setting.add ( key, Setting::TypeList ); 
     67            Setting &label = child.add ( Setting::TypeString ); 
     68            label = "matrix"; 
     69            Setting &rows = child.add ( Setting::TypeInt ); 
     70            Setting &cols = child.add ( Setting::TypeInt ); 
     71            Setting &elements = child.add ( Setting::TypeArray ); 
     72            cols = val.cols(); 
     73            rows = val.rows(); 
     74            for ( int i = 0; i < val.rows(); i++ ) { 
     75                for ( int j = 0; j < val.cols(); j++ ) { 
     76                    Setting &el = elements.add ( Setting::TypeFloat ); 
     77                    el = val ( i, j ); 
     78                } 
     79            } 
     80        } 
     81    } 
     82 
     83    void fillGroup ( Setting &setting, const mxArray *mxarray ) { 
     84        if ( !mxIsStruct ( mxarray ) ) { 
     85            mexErrMsgTxt ( "Given mxArray is not a struct." ); 
     86        }; 
     87        for ( int i = 0; i < mxGetNumberOfFields ( mxarray ); i++ ) { 
     88            const char *key = mxGetFieldNameByNumber ( mxarray, i ); 
     89            mxArray *value = mxGetField ( mxarray, 0, key ); 
     90            if ( mxIsChar ( value ) ) { 
     91                Setting &child = setting.add ( key, Setting::TypeString ); 
     92                child = mxArray2string ( value ); 
     93            } else { 
     94                if ( mxIsLogical ( value ) ) { 
     95                    Setting &child = setting.add ( key, Setting::TypeBoolean ); 
     96                    child = ( bool ) mxArray2bin ( value ); 
     97                } else { 
     98                    if ( mxIsStruct ( value ) ) { 
     99                        Setting &child = setting.add ( key, Setting::TypeGroup ); 
     100                        fillGroup ( child, value ); 
     101                    } else { 
     102                        if ( mxIsCell ( value ) ) { 
     103                            Setting &child = setting.add ( key, Setting::TypeList ); 
     104                            fillList ( child, value ); 
     105                        } else { 
     106                            if ( mxIsNumeric ( value ) ) { 
     107                                storeNumeric ( setting, value, ( string ) key ); 
     108                            } else { 
     109                                // it is neither of above - treat it as an address 
     110                                // if (mxIsObject(value)){ <== should be tested but it is broken in matlab... 
     111 
     112                                Setting &child = setting.add(key, Setting::TypeInt64); 
     113                                child = (long long)value; 
     114                            } 
     115                        } 
     116                    } 
     117                } 
     118            } 
     119        } 
     120    } 
     121 
     122    void fillList ( Setting &setting, const mxArray *mxarray ) { 
     123        if ( !mxIsCell ( mxarray ) ) { 
     124            mexErrMsgTxt ( "Given mxArray is not a cell." ); 
     125        }; 
     126        for ( unsigned int i = 0; i < ( unsigned int ) mxGetNumberOfElements ( mxarray ); i++ ) { 
     127            mxArray *value = mxGetCell ( mxarray, i ); 
     128            if ( mxIsChar ( value ) ) { 
     129                Setting &child = setting.add ( Setting::TypeString ); 
     130                child = mxArray2string ( value ); 
     131            } 
     132            if ( mxIsLogical ( value ) ) { 
     133                Setting &child = setting.add ( Setting::TypeBoolean ); 
     134                child = ( bool ) mxArray2bin ( value ); 
     135            } 
     136            if ( mxIsStruct ( value ) ) { 
     137                Setting &child = setting.add ( Setting::TypeGroup ); 
     138                fillGroup ( child, value ); 
     139            } 
     140            if ( mxIsCell ( value ) ) { 
     141                Setting &child = setting.add ( Setting::TypeList ); 
     142                fillList ( child, value ); 
     143            } 
     144            if ( mxIsNumeric ( value ) ) { 
     145                storeNumeric ( setting, value ); 
     146            } 
     147        } 
     148    } 
    149149 
    150150public: 
    151         //! Convert existing Setting to Matlab arrays 
    152         static mxArray * create_mxArray( const Setting &setting ) 
    153         { 
    154                 return group2mxstruct ( setting ); 
    155         } 
    156  
    157         //! Convert existing Setting to Matlab arrays 
    158         mxArray * create_mxArray(  ) 
    159         { 
    160                 return group2mxstruct ( *this ); 
    161         } 
     151    //! Convert existing Setting to Matlab arrays 
     152    static mxArray * create_mxArray( const Setting &setting ) 
     153    { 
     154        return group2mxstruct ( setting ); 
     155    } 
     156 
     157    //! Convert existing Setting to Matlab arrays 
     158    mxArray * create_mxArray(  ) 
     159    { 
     160        return group2mxstruct ( *this ); 
     161    } 
    162162 
    163163private: 
    164         //! Convert libconfig's array to Matlab vector 
    165         static mxArray* array2mxvector ( const Setting &setting )  { 
    166                 if ( !setting.isArray() ) mexErrMsgTxt ( "Given setting is not an array" ); 
    167                 mxArray *result = mxCreateDoubleMatrix ( 1, setting.getLength(), mxREAL ); 
    168                 double *elements = mxGetPr ( result ); 
    169                 for ( int i = 0; i < setting.getLength(); i++ ) { 
    170                         if ( setting.getType() == Setting::TypeInt ) { //TODO: tady je chyba -- zaporna cisla nejsou TypeInt 
    171                                 elements[i] = ( int ) setting[i]; 
    172                         } else { 
    173                                 elements[i] =  setting[i]; 
    174                         } 
    175                 } 
    176                 return result; 
    177         } 
    178  
    179         //! Convert libconfig's array to Matlab matrix 
    180         static mxArray* list2mxmatrix ( const Setting &setting )  { 
    181                 if ( !setting.isList() || ( strcmp ( "matrix", setting[0] ) != 0 ) ) 
    182                         mexErrMsgTxt ( "Given setting is not a matrix" ); 
    183                 int rows = setting[1]; 
    184                 int cols = setting[2]; 
    185                 if ( setting[3].getLength() != rows*cols ) 
    186                         mexErrMsgTxt ( "Matrix elements do not fit to rows*cols" ); 
    187                 double *elements = new double[rows*cols]; 
    188                 for ( int i = 0; i < rows*cols; i++ ) { 
    189                         elements[i] = setting[3][i]; 
    190                 } 
    191                 mat &m = * ( new mat ( elements, rows, cols ) ); 
    192                 mxArray *result = mxCreateDoubleMatrix ( rows, cols, mxREAL ); 
    193                 mat2mxArray ( m, result ); 
    194                 delete &m; 
    195                 delete [] elements; 
    196                 return result; 
    197         } 
    198  
    199         //! Convert libconfig's gourp to Matlab structure 
    200         static mxArray* group2mxstruct ( const Setting &setting ) { 
    201                 if ( !setting.isGroup() ) mexErrMsgTxt ( "Given setting is not a group." ); 
    202                 const char ** keys = new const char*[setting.getLength() ]; 
    203                 for ( int i = 0; i < setting.getLength(); i++ ) { 
    204                         keys[i] = setting[i].getName(); 
    205                 } 
    206                 mxArray *result = mxCreateStructMatrix ( 1, 1, setting.getLength(), keys ); 
    207                 delete keys; 
    208                 for ( int i = 0; i < setting.getLength(); i++ ) { 
    209                         Setting &value = setting[i]; 
    210                         mxArray *old = mxGetFieldByNumber ( result, 0, i ); 
    211                         if ( old ) mxDestroyArray ( old ); 
    212                         switch ( value.getType() ) { 
    213                         case Setting::TypeString: 
    214                                 mxSetFieldByNumber ( result, 0, i, mxCreateString ( value ) ); 
    215                                 break; 
    216                         case Setting::TypeBoolean: 
    217                                 mxSetFieldByNumber ( result, 0, i, mxCreateLogicalScalar ( value ) ); 
    218                                 break; 
    219                         case Setting::TypeGroup: 
    220                                 mxSetFieldByNumber ( result, 0, i, group2mxstruct ( value ) ); 
    221                                 break; 
    222                         case Setting::TypeList: 
    223                                 mxSetFieldByNumber ( result, 0, i, list2mxcell ( value ) ); 
    224                                 break; 
    225                         case Setting::TypeArray: 
    226                                 mxSetFieldByNumber ( result, 0, i, array2mxvector ( value ) ); 
    227                                 break; 
    228                         case Setting::TypeInt: 
    229                         case Setting::TypeInt64: 
    230                                 mxSetFieldByNumber ( result, 0, i, mxCreateDoubleScalar ( ( int ) value ) ); 
    231                                 break; 
    232                         case Setting::TypeFloat: 
    233                                 mxSetFieldByNumber ( result, 0, i, mxCreateDoubleScalar ( value ) ); 
    234                                 break; 
    235                         default: 
    236                                 //this should never happen 
    237                                 mexErrMsgTxt ( "Unknown type of a setting." ); 
    238                         } 
    239                 } 
    240                 return result; 
    241  
    242         } 
    243         //! Convert libconfig's list  to Matlab cell 
    244         static mxArray* list2mxcell ( const Setting &setting )  { 
    245                 if ( !setting.isList() ) mexErrMsgTxt ( "Given setting is not a list." ); 
    246                 if ( setting.getLength() == 0 ) { 
    247                         mxArray *result = mxCreateCellMatrix ( 1, 0 ); 
    248                         return result; 
    249                 } 
    250  
    251                 if ( ( setting[0].getType() == Setting::TypeString ) ) { 
    252                         string s = ( setting[0] ); 
    253                         if ( s == "matrix" ) { 
    254                                 return list2mxmatrix ( setting ); 
    255                         } 
    256                 } 
    257                 mxArray *result = mxCreateCellMatrix ( 1, setting.getLength() ); 
    258                 for ( int i = 0; i < setting.getLength(); i++ ) { 
    259                         Setting &value = setting[i]; 
    260                         mxArray *old = mxGetCell ( result, i ); 
    261                         if ( old ) mxDestroyArray ( old ); 
    262                         switch ( value.getType() ) { 
    263                         case Setting::TypeString: 
    264                                 mxSetCell ( result, i, mxCreateString ( value ) ); 
    265                                 break; 
    266                         case Setting::TypeBoolean: 
    267                                 mxSetCell ( result, i, mxCreateLogicalScalar ( value ) ); 
    268                                 break; 
    269                         case Setting::TypeGroup: 
    270                                 mxSetCell ( result, i, group2mxstruct ( value ) ); 
    271                                 break; 
    272                         case Setting::TypeList: 
    273                                 mxSetCell ( result, i, list2mxcell ( value ) ); 
    274                                 break; 
    275                         case Setting::TypeArray: 
    276                                 mxSetCell ( result, i, array2mxvector ( value ) ); 
    277                                 break; 
    278                         case Setting::TypeInt: 
    279                         case Setting::TypeInt64: 
    280                                 mxSetCell ( result, i, mxCreateDoubleScalar ( ( int ) value ) ); 
    281                                 break; 
    282                         case Setting::TypeFloat: 
    283                                 mxSetCell ( result, i, mxCreateDoubleScalar ( value ) ); 
    284                                 break; 
    285                         default: 
    286                                 //this should never happen 
    287                                 mexErrMsgTxt ( "Unknown type of a setting." ); 
    288                         } 
    289                 } 
    290                 return result; 
    291         } 
     164    //! Convert libconfig's array to Matlab vector 
     165    static mxArray* array2mxvector ( const Setting &setting )  { 
     166        if ( !setting.isArray() ) mexErrMsgTxt ( "Given setting is not an array" ); 
     167        mxArray *result = mxCreateDoubleMatrix ( 1, setting.getLength(), mxREAL ); 
     168        double *elements = mxGetPr ( result ); 
     169        for ( int i = 0; i < setting.getLength(); i++ ) { 
     170            if ( setting.getType() == Setting::TypeInt ) { //TODO: tady je chyba -- zaporna cisla nejsou TypeInt 
     171                elements[i] = ( int ) setting[i]; 
     172            } else { 
     173                elements[i] =  setting[i]; 
     174            } 
     175        } 
     176        return result; 
     177    } 
     178 
     179    //! Convert libconfig's array to Matlab matrix 
     180    static mxArray* list2mxmatrix ( const Setting &setting )  { 
     181        if ( !setting.isList() || ( strcmp ( "matrix", setting[0] ) != 0 ) ) 
     182            mexErrMsgTxt ( "Given setting is not a matrix" ); 
     183        int rows = setting[1]; 
     184        int cols = setting[2]; 
     185        if ( setting[3].getLength() != rows*cols ) 
     186            mexErrMsgTxt ( "Matrix elements do not fit to rows*cols" ); 
     187        double *elements = new double[rows*cols]; 
     188        for ( int i = 0; i < rows*cols; i++ ) { 
     189            elements[i] = setting[3][i]; 
     190        } 
     191        mat &m = * ( new mat ( elements, rows, cols ) ); 
     192        mxArray *result = mxCreateDoubleMatrix ( rows, cols, mxREAL ); 
     193        mat2mxArray ( m, result ); 
     194        delete &m; 
     195        delete [] elements; 
     196        return result; 
     197    } 
     198 
     199    //! Convert libconfig's gourp to Matlab structure 
     200    static mxArray* group2mxstruct ( const Setting &setting ) { 
     201        if ( !setting.isGroup() ) mexErrMsgTxt ( "Given setting is not a group." ); 
     202        const char ** keys = new const char*[setting.getLength() ]; 
     203        for ( int i = 0; i < setting.getLength(); i++ ) { 
     204            keys[i] = setting[i].getName(); 
     205        } 
     206        mxArray *result = mxCreateStructMatrix ( 1, 1, setting.getLength(), keys ); 
     207        delete keys; 
     208        for ( int i = 0; i < setting.getLength(); i++ ) { 
     209            Setting &value = setting[i]; 
     210            mxArray *old = mxGetFieldByNumber ( result, 0, i ); 
     211            if ( old ) mxDestroyArray ( old ); 
     212            switch ( value.getType() ) { 
     213            case Setting::TypeString: 
     214                mxSetFieldByNumber ( result, 0, i, mxCreateString ( value ) ); 
     215                break; 
     216            case Setting::TypeBoolean: 
     217                mxSetFieldByNumber ( result, 0, i, mxCreateLogicalScalar ( value ) ); 
     218                break; 
     219            case Setting::TypeGroup: 
     220                mxSetFieldByNumber ( result, 0, i, group2mxstruct ( value ) ); 
     221                break; 
     222            case Setting::TypeList: 
     223                mxSetFieldByNumber ( result, 0, i, list2mxcell ( value ) ); 
     224                break; 
     225            case Setting::TypeArray: 
     226                mxSetFieldByNumber ( result, 0, i, array2mxvector ( value ) ); 
     227                break; 
     228            case Setting::TypeInt: 
     229            case Setting::TypeInt64: 
     230                mxSetFieldByNumber ( result, 0, i, mxCreateDoubleScalar ( ( int ) value ) ); 
     231                break; 
     232            case Setting::TypeFloat: 
     233                mxSetFieldByNumber ( result, 0, i, mxCreateDoubleScalar ( value ) ); 
     234                break; 
     235            default: 
     236                //this should never happen 
     237                mexErrMsgTxt ( "Unknown type of a setting." ); 
     238            } 
     239        } 
     240        return result; 
     241 
     242    } 
     243    //! Convert libconfig's list  to Matlab cell 
     244    static mxArray* list2mxcell ( const Setting &setting )  { 
     245        if ( !setting.isList() ) mexErrMsgTxt ( "Given setting is not a list." ); 
     246        if ( setting.getLength() == 0 ) { 
     247            mxArray *result = mxCreateCellMatrix ( 1, 0 ); 
     248            return result; 
     249        } 
     250 
     251        if ( ( setting[0].getType() == Setting::TypeString ) ) { 
     252            string s = ( setting[0] ); 
     253            if ( s == "matrix" ) { 
     254                return list2mxmatrix ( setting ); 
     255            } 
     256        } 
     257        mxArray *result = mxCreateCellMatrix ( 1, setting.getLength() ); 
     258        for ( int i = 0; i < setting.getLength(); i++ ) { 
     259            Setting &value = setting[i]; 
     260            mxArray *old = mxGetCell ( result, i ); 
     261            if ( old ) mxDestroyArray ( old ); 
     262            switch ( value.getType() ) { 
     263            case Setting::TypeString: 
     264                mxSetCell ( result, i, mxCreateString ( value ) ); 
     265                break; 
     266            case Setting::TypeBoolean: 
     267                mxSetCell ( result, i, mxCreateLogicalScalar ( value ) ); 
     268                break; 
     269            case Setting::TypeGroup: 
     270                mxSetCell ( result, i, group2mxstruct ( value ) ); 
     271                break; 
     272            case Setting::TypeList: 
     273                mxSetCell ( result, i, list2mxcell ( value ) ); 
     274                break; 
     275            case Setting::TypeArray: 
     276                mxSetCell ( result, i, array2mxvector ( value ) ); 
     277                break; 
     278            case Setting::TypeInt: 
     279            case Setting::TypeInt64: 
     280                mxSetCell ( result, i, mxCreateDoubleScalar ( ( int ) value ) ); 
     281                break; 
     282            case Setting::TypeFloat: 
     283                mxSetCell ( result, i, mxCreateDoubleScalar ( value ) ); 
     284                break; 
     285            default: 
     286                //this should never happen 
     287                mexErrMsgTxt ( "Unknown type of a setting." ); 
     288            } 
     289        } 
     290        return result; 
     291    } 
    292292}; 
    293293 

  • library/bdm/mex/mex_pdf.h

    r955 r1064  
    1 class mexEpdf: public epdf{ 
    2         protected: 
    3                 mxArray *data; 
    4         public: 
    5                 mexEpdf() {}; 
    6                 void from_setting(const Setting &S)  { 
    7                         Setting &So=S["object"]; 
    8                         data = (mxArray*)long(So); 
    9                 }  
    10                 void set_data(mxArray * tmp){ 
    11                         data=tmp; 
    12                 } 
    13                 void validate() { 
    14                         mexCallMATLAB(0, 0, 1, &data,  "validate"); 
    15                         mxArray *tmp; 
    16                         mexCallMATLAB(1, &tmp, 1, &data, "dimension"); 
    17                         dim = mxArray2double(tmp); 
    18                         mexCallMATLAB(1, &tmp, 1, &data, "get_rv"); 
    19                         UImxArray rvtmp(tmp); 
    20                         shared_ptr<RV> r=UI::build<RV>(rvtmp); 
    21                         if (r){ 
    22                                 set_rv(*r); 
    23                         } 
    24                 } 
    25                 vec mean() const { 
    26                         mxArray *tmp; 
    27                         mexCallMATLAB(1, &tmp, 1, (mxArray **) &data, "mean"); 
    28                         return mxArray2vec(tmp); 
    29                 } 
    30                 vec sample() const { 
    31                         mxArray *tmp; 
    32                         mexCallMATLAB(1, &tmp, 1, (mxArray **) &data, "sample"); 
    33                         return mxArray2vec(tmp); 
    34                 } 
    35                 double evallog(const vec &dt) const { 
    36                         mxArray *tmp; 
    37                         mxArray *in[2]; 
    38                         in[0]=data; 
    39                         in[1]=mxCreateDoubleMatrix(dimension(),1,mxREAL); 
    40                         vec2mxArray(dt,in[1]); 
    41                         mexCallMATLAB(1, &tmp, 2, in, "evallog"); 
    42                         return mxArray2double(tmp); 
    43                 } 
    44                 vec variance() const { 
    45                         mxArray *tmp; 
    46                         mexCallMATLAB(1, &tmp, 1, (mxArray **) &data, "variance"); 
    47                         return mxArray2vec(tmp); 
    48                 } 
     1class mexEpdf: public epdf { 
     2protected: 
     3    mxArray *data; 
     4public: 
     5    mexEpdf() {}; 
     6    void from_setting(const Setting &S)  { 
     7        Setting &So=S["object"]; 
     8        data = (mxArray*)long(So); 
     9    } 
     10    void set_data(mxArray * tmp) { 
     11        data=tmp; 
     12    } 
     13    void validate() { 
     14        mexCallMATLAB(0, 0, 1, &data,  "validate"); 
     15        mxArray *tmp; 
     16        mexCallMATLAB(1, &tmp, 1, &data, "dimension"); 
     17        dim = mxArray2double(tmp); 
     18        mexCallMATLAB(1, &tmp, 1, &data, "get_rv"); 
     19        UImxArray rvtmp(tmp); 
     20        shared_ptr<RV> r=UI::build<RV>(rvtmp); 
     21        if (r) { 
     22            set_rv(*r); 
     23        } 
     24    } 
     25    vec mean() const { 
     26        mxArray *tmp; 
     27        mexCallMATLAB(1, &tmp, 1, (mxArray **) &data, "mean"); 
     28        return mxArray2vec(tmp); 
     29    } 
     30    vec sample() const { 
     31        mxArray *tmp; 
     32        mexCallMATLAB(1, &tmp, 1, (mxArray **) &data, "sample"); 
     33        return mxArray2vec(tmp); 
     34    } 
     35    double evallog(const vec &dt) const { 
     36        mxArray *tmp; 
     37        mxArray *in[2]; 
     38        in[0]=data; 
     39        in[1]=mxCreateDoubleMatrix(dimension(),1,mxREAL); 
     40        vec2mxArray(dt,in[1]); 
     41        mexCallMATLAB(1, &tmp, 2, in, "evallog"); 
     42        return mxArray2double(tmp); 
     43    } 
     44    vec variance() const { 
     45        mxArray *tmp; 
     46        mexCallMATLAB(1, &tmp, 1, (mxArray **) &data, "variance"); 
     47        return mxArray2vec(tmp); 
     48    } 
    4949}; 
    5050UIREGISTER(mexEpdf);