SHOGUN v0.9.0
|
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_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 delete[] 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 delete[] m_plif_matrix; 00023 00024 delete[] 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 delete[] m_PEN; 00032 m_PEN=NULL; 00033 00034 m_num_plifs=num_plifs; 00035 m_num_limits=num_limits; 00036 m_PEN = new 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(int32_t* plif_ids, int32_t num_ids) 00042 { 00043 if (num_ids!=m_num_plifs) 00044 SG_ERROR("plif_ids size mismatch (num_ids=%d vs.num_plifs=%d)\n", num_ids, m_num_plifs); 00045 00046 m_ids.resize_array(m_num_plifs); 00047 m_ids.set_array(plif_ids, num_ids, 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(float64_t* min_values, int32_t num_values) 00057 { 00058 if (num_values!=m_num_plifs) 00059 SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, 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[i]); 00065 } 00066 } 00067 00068 void CPlifMatrix::set_plif_max_values(float64_t* max_values, int32_t num_values) 00069 { 00070 if (num_values!=m_num_plifs) 00071 SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, 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[i]); 00077 } 00078 } 00079 00080 void CPlifMatrix::set_plif_use_cache(bool* use_cache, int32_t num_values) 00081 { 00082 if (num_values!=m_num_plifs) 00083 SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, 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[i]); 00089 } 00090 } 00091 00092 void CPlifMatrix::set_plif_use_svm(int32_t* use_svm, int32_t num_values) 00093 { 00094 if (num_values!=m_num_plifs) 00095 SG_ERROR("plif_values size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, 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[i]); 00101 } 00102 } 00103 00104 void CPlifMatrix::set_plif_limits(float64_t* limits, int32_t num_plifs, int32_t num_limits) 00105 { 00106 if (num_plifs!=m_num_plifs || num_limits!=m_num_limits) 00107 { 00108 SG_ERROR("limits size mismatch expected (%d,%d) got (%d,%d)\n", 00109 m_num_plifs, m_num_limits, num_plifs, num_limits); 00110 } 00111 00112 float64_t* lim = new float64_t[m_num_limits]; 00113 for (int32_t i=0; i<m_num_plifs; i++) 00114 { 00115 00116 for (int32_t k=0; k<m_num_limits; k++) 00117 lim[k] = limits[i*m_num_limits+k]; 00118 00119 int32_t id=get_plif_id(i); 00120 m_PEN[id]->set_plif_limits(lim, m_num_limits); 00121 } 00122 delete[] lim; 00123 } 00124 00125 void CPlifMatrix::set_plif_penalties(float64_t* penalties, int32_t num_plifs, int32_t num_limits) 00126 { 00127 if (num_plifs!=m_num_plifs || num_limits!=m_num_limits) 00128 { 00129 SG_ERROR("penalties size mismatch expected (%d,%d) got (%d,%d)\n", 00130 m_num_plifs, m_num_limits, num_plifs, num_limits); 00131 } 00132 00133 float64_t* pen = new float64_t[m_num_limits]; 00134 for (int32_t i=0; i<m_num_plifs; i++) 00135 { 00136 00137 for (int32_t k=0; k<m_num_limits; k++) 00138 pen[k] = penalties[i*m_num_limits+k]; 00139 00140 int32_t id=get_plif_id(i); 00141 m_PEN[id]->set_plif_penalty(pen, m_num_limits); 00142 } 00143 delete[] pen; 00144 } 00145 00146 void CPlifMatrix::set_plif_names(TString<char>* names, int32_t num_values, int32_t maxlen) 00147 { 00148 if (num_values!=m_num_plifs) 00149 SG_ERROR("names 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* name = CStringFeatures<char>::get_zero_terminated_string_copy(names[i]); 00155 m_PEN[id]->set_plif_name(name); 00156 delete[] name; 00157 } 00158 } 00159 00160 void CPlifMatrix::set_plif_transform_type(TString<char>* transform_type, int32_t num_values, int32_t maxlen) 00161 { 00162 if (num_values!=m_num_plifs) 00163 SG_ERROR("transform_type size mismatch (num_values=%d vs.num_plifs=%d)\n", num_values, m_num_plifs); 00164 00165 for (int32_t i=0; i<m_num_plifs; i++) 00166 { 00167 int32_t id=get_plif_id(i); 00168 char* transform_str=CStringFeatures<char>::get_zero_terminated_string_copy(transform_type[i]); 00169 00170 if (!m_PEN[id]->set_transform_type(transform_str)) 00171 { 00172 delete[] m_PEN; 00173 m_PEN=NULL; 00174 m_num_plifs=0; 00175 m_num_limits=0; 00176 SG_ERROR( "transform type not recognized ('%s')\n", transform_str) ; 00177 } 00178 delete[] transform_str; 00179 } 00180 } 00181 00182 00183 bool CPlifMatrix::compute_plif_matrix( 00184 float64_t* penalties_array, int32_t* Dim, int32_t numDims) 00185 { 00186 CPlif** PEN = get_PEN(); 00187 int32_t num_states = Dim[0]; 00188 int32_t num_plifs = get_num_plifs(); 00189 00190 for (int32_t i=0; i<m_num_states*m_num_states; i++) 00191 delete m_plif_matrix[i]; 00192 delete[] m_plif_matrix ; 00193 00194 m_num_states = num_states; 00195 m_plif_matrix = new CPlifBase*[num_states*num_states] ; 00196 00197 CArray3<float64_t> penalties(penalties_array, num_states, num_states, Dim[2], true, true) ; 00198 00199 for (int32_t i=0; i<num_states; i++) 00200 { 00201 for (int32_t j=0; j<num_states; j++) 00202 { 00203 CPlifArray * plif_array = NULL; 00204 CPlif * plif = NULL ; 00205 for (int32_t k=0; k<Dim[2]; k++) 00206 { 00207 if (penalties.element(i,j,k)==0) 00208 continue ; 00209 00210 if (!plif_array) 00211 { 00212 plif_array = new CPlifArray() ; 00213 plif_array->clear() ; 00214 } 00215 00216 int32_t id = (int32_t) penalties.element(i,j,k)-1 ; 00217 00218 if ((id<0 || id>=num_plifs) && (id!=-1)) 00219 { 00220 SG_ERROR( "id out of range\n") ; 00221 CPlif::delete_penalty_struct(PEN, num_plifs) ; 00222 return false ; 00223 } 00224 plif = PEN[id] ; 00225 00226 plif_array->add_plif(plif) ; 00227 } 00228 00229 if (!plif_array) 00230 { 00231 m_plif_matrix[i+j*num_states] = NULL ; 00232 } 00233 else if (plif_array->get_num_plifs()==1) 00234 { 00235 SG_UNREF(plif_array); 00236 ASSERT(plif!=NULL) ; 00237 m_plif_matrix[i+j*num_states] = plif ; 00238 } 00239 else 00240 m_plif_matrix[i+j*num_states] = plif_array ; 00241 00242 } 00243 } 00244 return true; 00245 } 00246 00247 bool CPlifMatrix::compute_signal_plifs( 00248 int32_t* state_signals, int32_t feat_dim3, int32_t num_states) 00249 { 00250 int32_t Nplif = get_num_plifs(); 00251 CPlif** PEN = get_PEN(); 00252 00253 delete[] m_state_signals; 00254 m_feat_dim3 = feat_dim3; 00255 00256 CPlifBase **PEN_state_signal = new CPlifBase*[feat_dim3*num_states] ; 00257 for (int32_t i=0; i<num_states*feat_dim3; i++) 00258 { 00259 int32_t id = (int32_t) state_signals[i]-1 ; 00260 if ((id<0 || id>=Nplif) && (id!=-1)) 00261 { 00262 SG_ERROR( "id out of range\n") ; 00263 CPlif::delete_penalty_struct(PEN, Nplif) ; 00264 return false ; 00265 } 00266 if (id==-1) 00267 PEN_state_signal[i]=NULL ; 00268 else 00269 PEN_state_signal[i]=PEN[id] ; 00270 } 00271 m_state_signals=PEN_state_signal; 00272 return true; 00273 } 00274 00275 void CPlifMatrix::set_plif_state_signal_matrix( 00276 int32_t *plif_id_matrix, int32_t m, int32_t max_num_signals) 00277 { 00278 if (m!=m_num_plifs) 00279 SG_ERROR( "plif_state_signal_matrix size does not match previous info %i!=%i\n", m, m_num_plifs) ; 00280 00281 /*if (m_seq.get_dim3() != max_num_signals) 00282 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) ; 00283 00284 CArray2<int32_t> id_matrix(plif_id_matrix, m_num_plifs, max_num_signals, false, false) ; 00285 m_PEN_state_signals.resize_array(m_num_plifs, max_num_signals) ; 00286 for (int32_t i=0; i<m_num_plifs; i++) 00287 { 00288 for (int32_t j=0; j<max_num_signals; j++) 00289 { 00290 if (id_matrix.element(i,j)>=0) 00291 m_PEN_state_signals.element(i,j)=m_plif_list[id_matrix.element(i,j)] ; 00292 else 00293 m_PEN_state_signals.element(i,j)=NULL ; 00294 } 00295 }*/ 00296 }