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