PlifMatrix.cpp

Go to the documentation of this file.
00001 #include "structure/PlifMatrix.h"
00002 #include "structure/Plif.h"
00003 #include "structure/PlifArray.h"
00004 #include "structure/PlifBase.h"
00005 
00006 using namespace shogun;
00007 
00008 CPlifMatrix::CPlifMatrix() : m_PEN(NULL), m_num_plifs(0), m_num_limits(0),
00009     m_plif_matrix(NULL), m_state_signals(NULL)
00010 {
00011 }
00012 
00013 CPlifMatrix::~CPlifMatrix()
00014 {
00015 }
00016 
00017 void CPlifMatrix::create_plifs(int32_t num_plifs, int32_t num_limits)
00018 {
00019     for (int32_t i=0; i<m_num_plifs; i++)   
00020         delete m_PEN[i];
00021     delete[] m_PEN;
00022     m_PEN=NULL;
00023 
00024     m_num_plifs=num_plifs;
00025     m_num_limits=num_limits;
00026     m_PEN = new CPlif*[num_plifs] ;
00027     for (int32_t i=0; i<num_plifs; i++) 
00028         m_PEN[i]=new CPlif(num_limits) ;
00029 }
00030 
00031 void CPlifMatrix::set_plif_ids(int32_t* plif_ids, int32_t num_ids)
00032 {
00033     if (num_ids!=m_num_plifs)
00034         SG_ERROR("plif_ids size mismatch (num_ids=%d vs.num_plifs=%d)\n", num_ids, m_num_plifs);
00035 
00036     m_ids.resize_array(m_num_plifs);
00037     m_ids.set_array(plif_ids, num_ids, true, true);
00038 
00039     for (int32_t i=0; i<m_num_plifs; i++)
00040     {
00041         int32_t id=get_plif_id(i);
00042         m_PEN[id]->set_id(id);
00043     }
00044 }
00045 
00046 void CPlifMatrix::set_plif_min_values(float64_t* min_values, int32_t num_values)
00047 {
00048     if (num_values!=m_num_plifs)
00049         SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, m_num_plifs);
00050 
00051     for (int32_t i=0; i<m_num_plifs; i++)
00052     {
00053         int32_t id=get_plif_id(i);
00054         m_PEN[id]->set_min_value(min_values[i]);
00055     }
00056 }
00057 
00058 void CPlifMatrix::set_plif_max_values(float64_t* max_values, int32_t num_values)
00059 {
00060     if (num_values!=m_num_plifs)
00061         SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, m_num_plifs);
00062 
00063     for (int32_t i=0; i<m_num_plifs; i++)
00064     {
00065         int32_t id=get_plif_id(i);
00066         m_PEN[id]->set_max_value(max_values[i]);
00067     }
00068 }
00069 
00070 void CPlifMatrix::set_plif_use_cache(bool* use_cache, int32_t num_values)
00071 {
00072     if (num_values!=m_num_plifs)
00073         SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, m_num_plifs);
00074 
00075     for (int32_t i=0; i<m_num_plifs; i++)
00076     {
00077         int32_t id=get_plif_id(i);
00078         m_PEN[id]->set_use_cache(use_cache[i]);
00079     }
00080 }
00081 
00082 void CPlifMatrix::set_plif_use_svm(int32_t* use_svm, int32_t num_values)
00083 {
00084     if (num_values!=m_num_plifs)
00085         SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, m_num_plifs);
00086 
00087     for (int32_t i=0; i<m_num_plifs; i++)
00088     {
00089         int32_t id=get_plif_id(i);
00090         m_PEN[id]->set_use_svm(use_svm[i]);
00091     }
00092 }
00093 
00094 void CPlifMatrix::set_plif_limits(float64_t* limits, int32_t num_plifs, int32_t num_limits)
00095 {
00096     if (num_plifs!=m_num_plifs ||  num_limits!=m_num_limits)
00097     {
00098         SG_ERROR("limits size mismatch expected (%d,%d) got (%d,%d)\n",
00099                 m_num_plifs, m_num_limits, num_plifs, num_limits);
00100     }
00101 
00102     for (int32_t i=0; i<m_num_plifs; i++)
00103     {
00104         float64_t* lim = new float64_t[m_num_limits];
00105 
00106         for (int32_t k=0; k<m_num_limits; k++)
00107             lim[k] = limits[i*m_num_limits+k];
00108 
00109         int32_t id=get_plif_id(i);
00110         m_PEN[id]->set_plif_limits(lim, m_num_limits);
00111     }
00112 }
00113 
00114 void CPlifMatrix::set_plif_penalties(float64_t* penalties, int32_t num_plifs, int32_t num_limits)
00115 {
00116     if (num_plifs!=m_num_plifs ||  num_limits!=m_num_limits)
00117     {
00118         SG_ERROR("penalties size mismatch expected (%d,%d) got (%d,%d)\n",
00119                 m_num_plifs, m_num_limits, num_plifs, num_limits);
00120     }
00121 
00122     for (int32_t i=0; i<m_num_plifs; i++)
00123     {
00124         float64_t* pen = new float64_t[m_num_limits];
00125 
00126         for (int32_t k=0; k<m_num_limits; k++)
00127             pen[k] = penalties[i*m_num_limits+k];
00128 
00129         int32_t id=get_plif_id(i);
00130         m_PEN[id]->set_plif_penalty(pen, m_num_limits);
00131     }
00132 }
00133 
00134 void CPlifMatrix::set_plif_names(T_STRING<char>* names, int32_t num_values, int32_t maxlen)
00135 {
00136     if (num_values!=m_num_plifs)
00137         SG_ERROR("names size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, m_num_plifs);
00138 
00139     for (int32_t i=0; i<m_num_plifs; i++)
00140     {
00141         int32_t id=get_plif_id(i);
00142         m_PEN[id]->set_plif_name(CStringFeatures<char>::get_zero_terminated_string_copy(names[i]));
00143     }
00144 }
00145 
00146 void CPlifMatrix::set_plif_transform_type(T_STRING<char>* transform_type, int32_t num_values, int32_t maxlen)
00147 {
00148     if (num_values!=m_num_plifs)
00149         SG_ERROR("transform_type size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, m_num_plifs);
00150 
00151     for (int32_t i=0; i<m_num_plifs; i++)
00152     {
00153         int32_t id=get_plif_id(i);
00154         char* transform_str=CStringFeatures<char>::get_zero_terminated_string_copy(transform_type[i]);
00155 
00156         if (!m_PEN[id]->set_transform_type(transform_str))
00157         {
00158             delete[] m_PEN;
00159             m_PEN=NULL;
00160             m_num_plifs=0;
00161             m_num_limits=0;
00162             SG_ERROR( "transform type not recognized ('%s')\n", transform_str) ;
00163         }
00164     }
00165 }
00166 
00167 
00168 bool CPlifMatrix::compute_plif_matrix(
00169     float64_t* penalties_array, int32_t* Dim, int32_t numDims)
00170 {
00171     CPlif** PEN = get_PEN();
00172     int32_t num_states = Dim[0];
00173     int32_t num_plifs = get_num_plifs();
00174 
00175     delete[] m_plif_matrix ;
00176     m_plif_matrix = new CPlifBase*[num_states*num_states] ;
00177 
00178     CArray3<float64_t> penalties(penalties_array, num_states, num_states, Dim[2], true, true) ;
00179 
00180     for (int32_t i=0; i<num_states; i++)
00181     {
00182         for (int32_t j=0; j<num_states; j++)
00183         {
00184             CPlifArray * plif_array = new CPlifArray() ;
00185             CPlif * plif = NULL ;
00186             plif_array->clear() ;
00187             for (int32_t k=0; k<Dim[2]; k++)
00188             {
00189                 if (penalties.element(i,j,k)==0)
00190                     continue ;
00191                 int32_t id = (int32_t) penalties.element(i,j,k)-1 ;
00192 
00193                 if ((id<0 || id>=num_plifs) && (id!=-1))
00194                 {
00195                     SG_ERROR( "id out of range\n") ;
00196                     CPlif::delete_penalty_struct(PEN, num_plifs) ;
00197                     return false ;
00198                 }
00199                 plif = PEN[id] ;
00200 
00201                 plif_array->add_plif(plif) ;
00202             }
00203 
00204             if (plif_array->get_num_plifs()==0)
00205             {
00206                 SG_UNREF(plif_array);
00207                 m_plif_matrix[i+j*num_states] = NULL ;
00208             }
00209             else if (plif_array->get_num_plifs()==1)
00210             {
00211                 SG_UNREF(plif_array);
00212                 ASSERT(plif!=NULL) ;
00213                 m_plif_matrix[i+j*num_states] = plif ;
00214             }
00215             else
00216                 m_plif_matrix[i+j*num_states] = plif_array ;
00217 
00218         }
00219     }
00220     return true;
00221 }
00222 
00223 bool  CPlifMatrix::compute_signal_plifs(
00224     int32_t* state_signals, int32_t feat_dim3, int32_t num_states)
00225 {
00226     int32_t Nplif = get_num_plifs();
00227     CPlif** PEN = get_PEN();
00228 
00229     CPlifBase **PEN_state_signal = new CPlifBase*[feat_dim3*num_states] ;
00230     for (int32_t i=0; i<num_states*feat_dim3; i++)
00231     {
00232         int32_t id = (int32_t) state_signals[i]-1 ;
00233         if ((id<0 || id>=Nplif) && (id!=-1))
00234         {
00235             SG_ERROR( "id out of range\n") ;
00236             CPlif::delete_penalty_struct(PEN, Nplif) ;
00237             return false ;
00238         }
00239         if (id==-1)
00240             PEN_state_signal[i]=NULL ;
00241         else
00242             PEN_state_signal[i]=PEN[id] ;
00243     }
00244     m_state_signals=PEN_state_signal;
00245     return true;
00246 }
00247 
00248 void CPlifMatrix::set_plif_state_signal_matrix(
00249     int32_t *plif_id_matrix, int32_t m, int32_t max_num_signals)
00250 {
00251     if (m!=m_num_plifs)
00252         SG_ERROR( "plif_state_signal_matrix size does not match previous info %i!=%i\n", m, m_num_plifs) ;
00253 
00254     /*if (m_seq.get_dim3() != max_num_signals)
00255         SG_ERROR( "size(plif_state_signal_matrix,2) does not match with size(m_seq,3): %i!=%i\nSorry, Soeren... interface changed\n", m_seq.get_dim3(), max_num_signals) ;
00256 
00257     CArray2<int32_t> id_matrix(plif_id_matrix, m_num_plifs, max_num_signals, false, false) ;
00258     m_PEN_state_signals.resize_array(m_num_plifs, max_num_signals) ;
00259     for (int32_t i=0; i<m_num_plifs; i++)
00260     {
00261         for (int32_t j=0; j<max_num_signals; j++)
00262         {
00263             if (id_matrix.element(i,j)>=0)
00264                 m_PEN_state_signals.element(i,j)=m_plif_list[id_matrix.element(i,j)] ;
00265             else
00266                 m_PEN_state_signals.element(i,j)=NULL ;
00267         }
00268     }*/
00269 }

SHOGUN Machine Learning Toolbox - Documentation