SHOGUN
v1.1.0
|
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 /*if (m_seq.get_dim3() != max_num_signals) 00279 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) ; 00280 00281 CArray2<int32_t> id_matrix(plif_id_matrix, m_num_plifs, max_num_signals, false, false) ; 00282 m_PEN_state_signals.resize_array(m_num_plifs, max_num_signals) ; 00283 for (int32_t i=0; i<m_num_plifs; i++) 00284 { 00285 for (int32_t j=0; j<max_num_signals; j++) 00286 { 00287 if (id_matrix.element(i,j)>=0) 00288 m_PEN_state_signals.element(i,j)=m_plif_list[id_matrix.element(i,j)] ; 00289 else 00290 m_PEN_state_signals.element(i,j)=NULL ; 00291 } 00292 }*/ 00293 }