/*
* inferece of HMM parameters based on variational Bayes method
*/
int TrainVBHMM::train(const Array2D<Real>& music_spec_td, const HyperparameterVBHMM& hyper_param){
const int T = music_spec_td.rows(), D = music_spec_td.cols();
Array2D<Array2D<PN> > prev_on_s_td_kj; // 4D-array for transition probability
// prev_on_s_td_kj(k,j)(t,d): probability of s_{t,d} being j where s_{t-1,d} = k and k = {0,1}
// p_on_s_td_(t,d): probability of s_{t,d} being 1. 1-p_on_s_td_(t,d) is the probability of s_{t,d}=0.
// 1. initialize
Real active_proportion;
if(is_silent_)
active_proportion = init_1st_time(music_spec_td, hyper_param.m0_, hyper_param.init_active_probability_, p_on_s_td_, prev_on_s_td_kj);
else
active_proportion = init(music_spec_td, p_on_s_td_, prev_on_s_td_kj);
if(active_proportion < hyper_param.active_proportion_){ // no inference for now
// the observation is too biased to silence
return 1;
}
is_silent_ = false;
// initialize the suffcient statistics
std::vector<Real> suff_1_j(2,0), suff_x_j(2,0), suff_xx_j(2,0);
update_suff_stat(music_spec_td, p_on_s_td_, suff_1_j, suff_x_j, suff_xx_j);
update_normal_gamma(music_spec_td, hyper_param, suff_1_j, suff_x_j, suff_xx_j); // hat_*** variables are updated
// 2. iteration
const Real convergence_threshold = 0.001;
Array2D<PN> before_p_on_s_td = p_on_s_td_;
for(int iter = 0; iter < hyper_param.max_iteration_; ++iter){
forward_backward(music_spec_td, p_on_s_td_, prev_on_s_td_kj);
update_alpha(hyper_param, prev_on_s_td_kj);
update_suff_stat(music_spec_td, p_on_s_td_, suff_1_j, suff_x_j, suff_xx_j);
update_normal_gamma(music_spec_td, hyper_param, suff_1_j, suff_x_j, suff_xx_j);
// check convergence
if(iter == 0)
continue;
Real diff_p=0;
for(int t = 0; t < T; ++t){
for(int d = 0; d < D; ++d){
const Real diff_td = static_cast<Real>(p_on_s_td_(t,d) - before_p_on_s_td(t,d));
diff_p += diff_td > 0 ? diff_td : -diff_td;
}
}
diff_p /= (T*D);
//printf("iter (%02d): diff_p = %f\n",iter,diff_p);
if(diff_p < convergence_threshold){
break; // end the iteration after converged
}
before_p_on_s_td = p_on_s_td_;
}
return 0;
}
void Tile::start_disabling(const TimeStamp& now)
{
if (not enabled)
return;
enabled = false;
in_transition = true;
initial_alpha = alpha;
alpha_start = now;
alpha_stop = now + TILE_DISABLE_DURATION;
update_alpha(now);
}
void CKLInference::update()
{
SG_DEBUG("entering\n");
CInference::update();
update_init();
update_alpha();
update_chol();
m_gradient_update=false;
update_parameter_hash();
SG_DEBUG("leaving\n");
}
//TESTVERSION av ny main
int main(void)
{
CONTROL_MODE cm = MANUAL; //Representerar aktuellt läge hos roboten
//Defaultvärden
angle = 0;
intensity = 0;
intensity_byte = 100;
angle_byte = 100;
height = 11;
delta_h = 0.1;
Kp = 0.001;
Kd = 0.001;
Init();
//KÖR CONFIGURE-FUNKTIONERNA NÄR SERVONA BEHÖVER KALIBRERAS PÅ NÅGOT SÄTT
//Configure_Servos_Delaytime();
//Configure_Servos_LED();
//Configure_Servos_No_Response();
Configure_Servos_Angle_Limit();
//
Send_Inner_P1_Velocity(0x00F0); //DESSA SEX ANROP MÅSTE ALLTID KÖRAS EFTERSOM HASTIGHETEN LIGGER I RAM!!!
Send_Middle_P1_Velocity(0x0100);//
Send_Outer_P1_Velocity(0x0100);//
Send_Inner_P2_Velocity(0x00F0);//
Send_Middle_P2_Velocity(0x0100);//
Send_Outer_P2_Velocity(0x0100);//
memset(fromKom, 0, sizeof(fromKom)); //Nollställer fromKom & fromSen (tar bort ev skräp på minnesplatserna) så koden inte ballar ur innan första avbrottet kommit. Lägg ev in i Init!
memset(fromSen, 0, sizeof(fromSen));
sei(); //Aktivera avbrott öht (MSB=1 i SREG). Anropas EFTER all konfigurering klar!
unsigned char first_kom_byte;
Walk_Half_Cycle(intensity, angle,height);
while(1)
{
first_kom_byte = fromKom[0];
//
//if (first_kom_byte & 0b00001000) //Växla läge?
//{
//unsigned char change_mode = fromKom[4];
//
//if (change_mode == 0) //Byt till MANUAL?
//{
//cm = MANUAL;
//}
//
//else if (change_mode == 1) //Byt till AUTO?
//{
//cm = AUTO;
//}
//else if (change_mode == 2) //Byt till RACE?
//{
//cm = RACE;
//}
//}
switch(cm)
{
case MANUAL: //Manuellt läge
intensity_byte = 100;
angle_byte = 100;
if (first_kom_byte & 0b00000011) //Skickas vinkel & intensitet?
{
intensity_byte = fromKom[2] - 100;
intensity = (float)(intensity_byte)*((float)6)/((float)100); //100 på kontroll -> 6 i speed
angle_byte = 0;
//memcpy(angle_byte, fromKom[1], sizeof(angle_byte));
angle_byte = fromKom[1] - 100;
angle = (float)(angle_byte)*((float)0.57)/((float)100); //128 på kontroll -> 0.57 i vinkel
Walk_Half_Cycle(intensity, angle,height);
}
if (first_kom_byte & 0b00000100) //Höj/sänk gångstil?
{
unsigned char change_height = fromKom[3];
if (change_height == 1) //Sänk?
{
height -= delta_h;
}
else if (change_height == 2) //Höj?
{
height += delta_h;
}
Walk_Half_Cycle(0, 0,height);
}
if (first_kom_byte & 0b00010000) //Nytt Kp?
{
Kp = ((float)fromKom[5])/10; //Kp skickas som 10 ggr det önskade värdet!!!
}
if (first_kom_byte & 0b00100000) //Nytt Kd?
{
Kd = ((float)fromKom[6])/10; //Kd skickas som 10 ggr det önskade värdet!!!
}
break;
case AUTO: //Autonomt läge
update_alpha();
Walk_Half_Cycle(1, alpha_d, height);
break;
case RACE:
//if (PIND3 == 0) //Har knapp tryckts ned? PIN ist. för PORT eftersom in-port ist. för ut-port???
//{
//cm = AUTO;
//}
break;
default:
break;
}
}
}
void train_once_KernelPerceptronModel(KernelPerceptron mdl, const CoNLLCorpus corpus, int max_rec) {
long match = 0, total = 0;
//size_t slen=0;
double s_initial = dsecnd();
int max_sv = 0;
log_info("Total number of training instances %d", (max_rec == -1) ? DArray_count(corpus->sentences) : max_rec);
for (int si = 0; si < ((max_rec == -1) ? DArray_count(corpus->sentences) : max_rec); si++) {
FeaturedSentence sent = (FeaturedSentence) DArray_get(corpus->sentences, si);
debug("Building feature matrix for sentence %d", si);
set_FeatureMatrix(NULL, corpus, si);
set_adjacency_matrix_fast(corpus, si, mdl, false);
max_sv += (sent->length + 1) * sent->length - sent->length;
int *model = parse(sent);
//printfarch(model, sent->length);
debug("Parsing sentence %d of length %d is done", si, sent->length);
int *empirical = get_parents(sent);
//printfarch(empirical, sent->length);
int nm = nmatch(model, empirical, sent->length);
debug("Model matches %d arcs out of %d arcs", nm, sent->length);
if (nm != sent->length) { // root has no valid parent.
log_info("Sentence %d (section %d) of length %d (%d arcs out of %d arcs are correct)", si, sent->section, sent->length, nm, sent->length);
int sentence_length = sent->length;
for (int to = 1; to <= sentence_length; to++) {
if (model[to] != empirical[to]) {
update_alpha(mdl, si, model[to], to, sent, -1);
update_alpha(mdl, si, empirical[to], to, sent, +1);
}
}
} else {
log_info("Sentence %d (section %d) of length %d (Perfect parse)", si, sent->section, sent->length);
}
size_t nsuccess;
if (budget_method == RANDOMIZED) {
if (mdl->M > budget_target) {
size_t nbefore = mdl->M;
size_t nasked = nbefore - budget_target;
nsuccess = delete_n_random_hypothesis(mdl, nasked);
log_info("%lu vectors deleted (%lu asked). Current hypothesis set size reduced from %lu to %lu", nsuccess, nasked, nbefore, mdl->M);
}
}
mdl->c++;
free_feature_matrix(corpus, si);
match += nm;
total += (sent->length);
if ((si + 1) % 1000 == 0 && si != 0) {
log_info("Running training accuracy %lf after %d sentence.", (match * 1.) / total, si + 1);
unsigned nsv = mdl->M;
log_info("%u (%f of total %d) support vectors", nsv, (nsv * 1.) / max_sv, max_sv);
}
free(model);
free(empirical);
}
unsigned nsv = mdl->M;
log_info("Running training accuracy %lf", (match * 1.) / total);
log_info("%u (%f of total %d) support vectors", nsv, (nsv * 1.) / max_sv, max_sv);
if (verbosity > 0) {
dump_support_vectors(mdl);
}
update_average_alpha(mdl);
return;
}
int main( int argc, char *argv[] )
{
// struct for parsing parameters
SimParams sim_params( argc , argv );
// init model param and sim structs
ModelParameters* modelParameters = new ModelParameters();
Int seed = sim_params.get_int_param("random_seed");
StochSimulator* stochSimulator = new StochSimulator( modelParameters , seed );
// parsing model variants
string partitioning_type = sim_params.get_string_param( "partitioning_type" );
string GE_model = sim_params.get_string_param( "GE_model" );
string alpha_model = sim_params.get_string_param( "alpha_model" );
// parsing alpha model parameters
modelParameters->mu_max = sim_params.get_double_param( "mu_max" ); // given in per hour
modelParameters->alpha_max = modelParameters->mu_max * log(2.) / 60.; // we use minutes as the time-scale
if(alpha_model == "norm_distrib" ) {
modelParameters->alpha_CV = sim_params.get_double_param( "alpha_CV" );
}
else {
modelParameters->regulation_hill = sim_params.get_double_param( "regulation_hill" );
modelParameters->regulation_conc = sim_params.get_double_param( "regulation_conc" );
}
// parsing GE model parameters
if( GE_model == "constant_rates" )
{
modelParameters->set_km( sim_params.get_double_param( "km" ) );
modelParameters->set_rm( sim_params.get_double_param( "rm" ) );
modelParameters->set_kp( sim_params.get_double_param( "kp" ) );
modelParameters->set_rp( sim_params.get_double_param( "rp" ) );
}
if( GE_model == "dependent_rates" )
{
modelParameters->km_0 = sim_params.get_double_param(("km_0") );
modelParameters->km_per_size = sim_params.get_double_param(("km_per_size") );
modelParameters->km_per_alpha = sim_params.get_double_param(("km_per_alpha") );
modelParameters->kp_0 = sim_params.get_double_param(("kp_0") );
modelParameters->kp_per_size = sim_params.get_double_param(("kp_per_size") );
modelParameters->set_rm( sim_params.get_double_param( "rm" ) );
modelParameters->set_rp( sim_params.get_double_param( "rp" ) );
}
// parsing size model parameters
modelParameters->lnm_a = sim_params.get_double_param("lnm_a");
modelParameters->lnm_b = sim_params.get_double_param("lnm_b");
modelParameters->lnm_sigma_1 = sim_params.get_double_param("lnm_sigma_1");
modelParameters->lnm_sigma_2 = sim_params.get_double_param("lnm_sigma_2");
// simulation parameters(always the same, do not depend on model variant)
Int num_lineages = sim_params.get_int_param( "num_lineages" );
Doub sim_duration = sim_params.get_double_param( "sim_duration" );
Doub update_period = sim_params.get_double_param("update_period" );
Int num_updates_per_output = sim_params.get_double_param("num_updates_per_output" );
Int num_timepoints =(Int)( sim_duration / update_period /(Doub) num_updates_per_output ) + 1;
string out_folder = sim_params.get_string_param( "out_folder" );
sim_params.display_params();
sim_params.write_params();
// for debugging
Bool verbose = false;
// Matrice storing data
MatDoub lineage_traj_mRNA_data( num_timepoints , num_lineages , 0. );
MatDoub lineage_traj_prot_data( num_timepoints , num_lineages , 0. );
MatDoub lineage_traj_size_data( num_timepoints , num_lineages , 0. );
MatDoub lineage_traj_alpha_data( num_timepoints , num_lineages , 0. );
MatDoub lineage_traj_time_data( num_timepoints , num_lineages , 0. );
Int num_timepoints_done = 0;
// iterate on cells
for(Int c=0;c<num_lineages;c++)
{
// construction of a cell(look constructor for init state)
CellState *cell = new CellState(modelParameters);
// update gene expression rates
update_gene_expression_rates( cell , modelParameters , GE_model );
// choose division size
choose_division_size(cell,modelParameters,stochSimulator);
// verbose
if(verbose)
{
cout << endl << "Lineage start." << endl;
cout << "L_birth = " << cell->Lb << " , L_div = " << cell->Ld << endl << endl;
}
// timers(all in absolute time)
Doub t_birth = 0;
Doub t = 0;
Doub next_update_t = update_period;
Doub next_div_t = t + cell->get_time_to_div();
num_timepoints_done = 0;
Int num_updates_since_last_output = 0;
while( t < sim_duration )
{
if(verbose) cout << endl << "__ t = " << t << ", next_div_t = " << next_div_t << " __" << endl;
// if next div before next update
if( next_div_t < next_update_t )
{
// simulate until div
stochSimulator->simulate( cell , next_div_t - t ); // remaining time before div
// update time
t = next_div_t;
//verbose
if(verbose) cout << "Division reached." << endl;
// if(verbose) cout << "Time average toxin conc = " << time_average_toxin_conc_previous_cycle << endl;
if(verbose) cout << "Toxin concentration just before div = " << cell->get_prot_Level() / cell->L << endl;
// choose birth size(splitting)
if(verbose) cout << "about to choose birth size from div size = " << cell->Ld << endl;
choose_birth_size(cell,modelParameters,stochSimulator);
if(verbose) cout << "L_birth chosen = " << cell->Lb << endl;
// binomial partitioning of mRNA and prot
do_partitioning( partitioning_type , cell->Lb/cell->Ld , cell , stochSimulator );
if(verbose) cout << "Toxin concentration just after div = " << cell->get_prot_Level() / cell->Lb << endl;
// update alpha(how its done depends on the alpha_model)
update_alpha( cell , modelParameters , alpha_model , stochSimulator );
if(verbose) cout << "Next alpha = " << cell->alpha * 60. << endl;
// update gene expression rates
update_gene_expression_rates( cell , modelParameters , GE_model );
// choose division size
choose_division_size( cell , modelParameters , stochSimulator );
// update timers
t_birth = t;
next_div_t = t + cell->get_time_to_div();
}
else // just simulate until next update
{
// if output needed
if((num_updates_since_last_output == num_updates_per_output) ||(t == 0) )
{
if(num_timepoints_done == num_timepoints) { cout << "error output table" << endl; exit(5); }
lineage_traj_mRNA_data[num_timepoints_done][c] = cell->get_mRNA_Level();
lineage_traj_prot_data[num_timepoints_done][c] = cell->get_prot_Level();
lineage_traj_size_data[num_timepoints_done][c] = cell->L;
lineage_traj_alpha_data[num_timepoints_done][c] = cell->alpha;
lineage_traj_time_data[num_timepoints_done][c] = t;
num_timepoints_done++;
num_updates_since_last_output = 0;
if(verbose) cout << "outputs done = " << num_timepoints_done << endl;
}
// simulate
stochSimulator->simulate( cell , next_update_t - t ); // remaining time before update
// update alpha(will be done only if required by alpha_model)
update_alpha( cell , modelParameters , alpha_model , stochSimulator );
// update gene expression rates(if needed by GE_model)
update_gene_expression_rates(cell , modelParameters , GE_model );
// update time
t = next_update_t;
// update timers
next_update_t = t + update_period;
next_div_t = t + cell->get_time_to_div();
num_updates_since_last_output++;
}
}
// free memory used by the cell if not needed
delete cell;
}
// verify all points in the tables have been filled, if needed, remove last point
if(num_timepoints_done < num_timepoints)
{
// cout << "timepoints not filled" << endl;
if( num_timepoints_done < num_timepoints - 1 )
{
cout << "error: more than one timepoint missing ?!" << endl; exit(4);
}
lineage_traj_time_data[num_timepoints-1][0] = -1; // flag that will be detected by matlab
}
// write data on file
ostringstream suffix; suffix << ".dat";
if(verbose) cout << endl << endl << "writing tables" << endl;
writeMatrixInTextFile( out_folder , "lineage_traj_mRNA_data"+suffix.str() , lineage_traj_mRNA_data );
writeMatrixInTextFile( out_folder , "lineage_traj_prot_data"+suffix.str() , lineage_traj_prot_data );
writeMatrixInTextFile( out_folder , "lineage_traj_size_data"+suffix.str() , lineage_traj_size_data );
writeMatrixInTextFile( out_folder , "lineage_traj_alpha_data"+suffix.str() , lineage_traj_alpha_data );
writeMatrixInTextFile( out_folder , "lineage_traj_time_data"+suffix.str() , lineage_traj_time_data );
return 0;
}
extern "C" void Smoke3d_CB(int var) {
int i;
char *tour_label;
char *vol_prefixptr;
updatemenu=1;
switch(var) {
float temp_min, temp_max;
case VOL_UNLOAD_ALL:
UnLoadVolSmoke3DMenu(-1);
break;
case VOL_PREFIX:
break;
case VOL_TOUR_LIST:
TOUR_CB(TOUR_LIST);
break;
case START_FRAME:
if(vol_startframe0<0) {
vol_startframe0=0;
SPINNER_startframe->set_int_val(vol_startframe0);
}
break;
case SKIP_FRAME:
if(vol_skipframe0<1) {
vol_skipframe0=1;
SPINNER_skipframe->set_int_val(vol_skipframe0);
}
break;
case CANCEL_GENERATE_IMAGES:
Script_CB(SCRIPT_CANCEL_NOW);
break;
case GENERATE_IMAGES:
if(selected_tour==NULL) {
tour_label=NULL;
}
else {
tour_label=selected_tour->label;
}
trim(vol_prefix);
vol_prefixptr=trim_front(vol_prefix);
if(strlen(vol_prefixptr)==0)vol_prefixptr=fdsprefix;
init_volrender_script(vol_prefixptr, tour_label, vol_startframe0, vol_skipframe0);
break;
case NONGPU_VOL_FACTOR:
init_volrender_surface(NOT_FIRSTCALL);
break;
case GPU_VOL_FACTOR:
break;
case COMBINE_MESHES:
define_volsmoke_textures();
break;
case SHOW_FIRECOLORMAP:
Update_Smokecolormap(smoke_render_option);
if(show_firecolormap==1) {
show_glui_colorbar();
}
else {
hide_glui_colorbar();
}
break;
case TEMP_MIN:
temp_min = 20.0;
temp_max = (float)(10.0*(int)(temperature_cutoff/10.0)-10.0);
SPINNER_temperature_min->set_float_limits(temp_min,temp_max);
Update_Smokecolormap(smoke_render_option);
break;
case TEMP_CUTOFF:
temp_min = (float)(10*(int)(temperature_min/10.0) + 10.0);
temp_max = (float)(10*(int)(temperature_max/10.0) - 10.0);
SPINNER_temperature_cutoff->set_float_limits(temp_min,temp_max);
Update_Smokecolormap(smoke_render_option);
break;
case TEMP_MAX:
temp_min = (float)(10*(int)(temperature_cutoff/10.0)+10.0);
temp_max = 1800.0;
SPINNER_temperature_max->set_float_limits(temp_min,temp_max);
Update_Smokecolormap(smoke_render_option);
break;
case LOAD_COMPRESSED_DATA:
if(load_volcompressed==1) {
CHECKBOX_compress_volsmoke->disable();
}
else {
CHECKBOX_compress_volsmoke->enable();
}
break;
case SMOKE_OPTIONS:
if(firecolormap_type!=FIRECOLORMAP_NOCONSTRAINT&&smoke_render_option==RENDER_SLICE) {
PANEL_colormap2b->enable();
SPINNER_hrrpuv_cutoff->enable();
PANEL_colormap2b->open();
}
else {
PANEL_colormap2b->disable();
PANEL_colormap2b->close();
}
if(smoke_render_option==RENDER_SLICE) {
if(PANEL_colormap2a!=NULL) {
PANEL_colormap2a->disable();
PANEL_colormap2a->close();
}
if(PANEL_absorption!=NULL)PANEL_absorption->enable();
firecolormap_type=firecolormap_type_save;
RADIO_use_colormap->set_int_val(firecolormap_type);
RADIOBUTTON_direct->enable();
SPINNER_smoke3d_fire_halfdepth->enable();
}
else {
if(PANEL_colormap2a!=NULL) {
PANEL_colormap2a->enable();
PANEL_colormap2a->open();
}
if(PANEL_absorption!=NULL)PANEL_absorption->disable();
firecolormap_type_save=firecolormap_type;
firecolormap_type=FIRECOLORMAP_CONSTRAINT;
RADIO_use_colormap->set_int_val(firecolormap_type);
RADIOBUTTON_direct->disable();
SPINNER_smoke3d_fire_halfdepth->disable();
}
Smoke3d_CB(FIRECOLORMAP_TYPE);
Update_Smoke_Type();
break;
case FIRECOLORMAP_TYPE:
if(firecolormap_type==FIRECOLORMAP_CONSTRAINT&&smoke_render_option==RENDER_VOLUME) {
PANEL_colormap2a->open();
PANEL_colormap2a->enable();
}
else {
PANEL_colormap2a->close();
PANEL_colormap2a->disable();
}
if(firecolormap_type!=FIRECOLORMAP_NOCONSTRAINT&&smoke_render_option==RENDER_SLICE) {
PANEL_colormap2b->enable();
SPINNER_hrrpuv_cutoff->enable();
PANEL_colormap2b->open();
}
else {
PANEL_colormap2b->disable();
PANEL_colormap2b->close();
}
if(firecolormap_type!=FIRECOLORMAP_DIRECT) {
LISTBOX_smoke_colorbar->enable();
ROLLOUT_colormap3->disable();
ROLLOUT_colormap3->close();
if(fire_colorbar_index_save!=-1) {
SmokeColorBarMenu(fire_colorbar_index_save);
}
else {
SmokeColorBarMenu(fire_colorbar_index);
}
}
else {
LISTBOX_smoke_colorbar->disable();
ROLLOUT_colormap3->enable();
ROLLOUT_colormap3->open();
SPINNER_smoke3d_smoke_albedo->enable();
SPINNER_smoke3d_fire_red->enable();
SPINNER_smoke3d_fire_green->enable();
SPINNER_smoke3d_fire_blue->enable();
SPINNER_smoke3d_fire_halfdepth->enable();
fire_colorbar_index_save=fire_colorbar_index;
}
if(LISTBOX_smoke_colorbar->get_int_val()!=fire_colorbar_index) {
LISTBOX_smoke_colorbar->set_int_val(fire_colorbar_index);
}
Update_Smokecolormap(smoke_render_option);
break;
case SMOKE_COLORBAR_LIST:
SmokeColorBarMenu(fire_colorbar_index);
Update_Smokecolormap(smoke_render_option);
updatemenu=1;
break;
case SMOKETEST:
update_alpha();
break;
case FRAMELOADING:
smoke3dframestep = smoke3dframeskip+1;
updatemenu=1;
break;
case SAVE_SETTINGS:
writeini(LOCAL_INI,NULL);
break;
case GLOBAL_FIRE_CUTOFF:
glutPostRedisplay();
force_redisplay=1;
Idle_CB();
Update_Smokecolormap(smoke_render_option);
break;
case FIRE_RED:
case FIRE_GREEN:
case FIRE_BLUE:
case SMOKE_SHADE:
glutPostRedisplay();
force_redisplay=1;
Update_Smokecolormap(smoke_render_option);
Idle_CB();
break;
case FIRE_HALFDEPTH:
for(i=0; i<nmeshes; i++) {
mesh *meshi;
meshi = meshinfo + i;
meshi->update_firehalfdepth=1;
}
glutPostRedisplay();
force_redisplay=1;
Update_Smokecolormap(smoke_render_option);
Idle_CB();
break;
#ifdef pp_GPU
case SMOKE_RTHICK:
smoke3d_thick = log_base2(smoke3d_rthick);
glutPostRedisplay();
force_redisplay=1;
Idle_CB();
break;
#else
case SMOKE_THICK:
glutPostRedisplay();
force_redisplay=1;
Idle_CB();
break;
#endif
#ifdef pp_CULL
case CULL_PORTSIZE:
initcull(cullsmoke);
break;
case CULL_SMOKE:
initcull(cullsmoke);
break;
#endif
case VOL_NGRID:
glutPostRedisplay();
break;
case VOL_SMOKE:
{
volrenderdata *vr;
vr = &meshinfo->volrenderinfo;
if(vr!=NULL&&vr->smokeslice!=NULL&&vr->smokeslice->slicetype==SLICE_CENTER) {
if(usegpu==1&&combine_meshes==1) {
combine_meshes=0;
update_combine_meshes();
Smoke3d_CB(COMBINE_MESHES);
}
if(usegpu==0&&combine_meshes==0) {
combine_meshes=1;
update_combine_meshes();
Smoke3d_CB(COMBINE_MESHES);
}
}
}
if(smoke_render_option==RENDER_SLICE) {
#ifdef pp_GPU
if(usegpu==1) {
RADIO_skipframes->set_int_val(0);
RADIO_skipframes->disable();
#ifdef pp_CULL
if(cullactive==1) {
CHECKBOX_smokecullflag->enable();
}
SPINNER_cull_portsize->enable();
CHECKBOX_show_cullports->enable();
#endif
}
else {
RADIO_skipframes->enable();
#ifdef pp_CULL
CHECKBOX_smokecullflag->disable();
SPINNER_cull_portsize->disable();
CHECKBOX_show_cullports->disable();
#endif
}
#else
RADIO_skipframes->enable();
#endif
}
break;
default:
#ifdef _DEBUG
abort();
#endif
break;
}
}
extern "C" void glui_3dsmoke_setup(int main_window) {
int i;
if(nsmoke3dinfo<=0&&nvolrenderinfo<=0)return;
if(CHECKBOX_meshvisptr!=NULL)FREEMEMORY(CHECKBOX_meshvisptr);
NewMemory((void **)&CHECKBOX_meshvisptr,nmeshes*sizeof(GLUI_Checkbox *));
glui_3dsmoke=glui_bounds;
if(smoketest==1) {
PANEL_testsmoke = glui_3dsmoke->add_panel_to_panel(ROLLOUT_smoke3d,_("Test smoke"));
PANEL_testsmoke->set_alignment(GLUI_ALIGN_LEFT);
CHECKBOX_show_smoketest=glui_3dsmoke->add_checkbox_to_panel(PANEL_testsmoke,_("Show test smoke"),&show_smoketest);
SPINNER_extinct=glui_3dsmoke->add_spinner_to_panel(PANEL_testsmoke,_("Mass extinction coeff (m2/g)"),GLUI_SPINNER_FLOAT,&smoke_extinct,SMOKETEST,Smoke3d_CB);
SPINNER_extinct->set_float_limits(0.0,10.0);
SPINNER_smokedens=glui_3dsmoke->add_spinner_to_panel(PANEL_testsmoke,_("Smoke density (g/m3)"),GLUI_SPINNER_FLOAT,&smoke_dens,SMOKETEST,Smoke3d_CB);
SPINNER_smokedens->set_float_limits(0.0,1.0);
SPINNER_pathlength=glui_3dsmoke->add_spinner_to_panel(PANEL_testsmoke,_("Path length (m)"),GLUI_SPINNER_FLOAT,&smoke_pathlength,SMOKETEST,Smoke3d_CB);
SPINNER_pathlength->set_float_limits(0.0,20.0);
TEXT_smokealpha=glui_3dsmoke->add_statictext_to_panel(PANEL_testsmoke,_("Alpha"));
TEXT_smokedepth=glui_3dsmoke->add_statictext_to_panel(PANEL_testsmoke,_("Depth"));
update_alpha();
}
PANEL_overall = glui_3dsmoke->add_panel_to_panel(ROLLOUT_smoke3d,"",GLUI_PANEL_NONE);
#ifdef pp_GPU
CHECKBOX_smokeGPU=glui_3dsmoke->add_checkbox_to_panel(PANEL_overall,_("Use GPU"),&usegpu,VOL_SMOKE,Smoke3d_CB);
#endif
if(active_smokesensors==1) {
PANEL_smokesensor = glui_3dsmoke->add_panel_to_panel(PANEL_overall,_("Visibility"));
RADIO_smokesensors = glui_3dsmoke->add_radiogroup_to_panel(PANEL_smokesensor,&show_smokesensors);
glui_3dsmoke->add_radiobutton_to_group(RADIO_smokesensors,_("Hidden"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_smokesensors,_("Grey (0-255)"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_smokesensors,"I/I0 (0.0-1.0)");
glui_3dsmoke->add_radiobutton_to_group(RADIO_smokesensors,_("Scaled optical depth (SCD)"));
glui_3dsmoke->add_statictext_to_panel(PANEL_smokesensor,"SCD=C/K=C*L/Ln(I/I0) (0-Inf)");
SPINNER_cvis=glui_3dsmoke->add_spinner_to_panel(PANEL_smokesensor,"C",GLUI_SPINNER_FLOAT,&smoke3d_cvis);
SPINNER_cvis->set_float_limits(1.0,20.0);
#ifdef _DEBUG
CHECKBOX_test_smokesensors=glui_3dsmoke->add_checkbox_to_panel(PANEL_smokesensor,"Test visibility sensor",&test_smokesensors);
#endif
}
PANEL_colormap = glui_3dsmoke->add_panel_to_panel(PANEL_overall,_("Color"));
glui_3dsmoke->add_checkbox_to_panel(PANEL_colormap,"Show colormap",&show_firecolormap,SHOW_FIRECOLORMAP,Smoke3d_CB);
RADIO_use_colormap = glui_3dsmoke->add_radiogroup_to_panel(PANEL_colormap,&firecolormap_type,FIRECOLORMAP_TYPE,Smoke3d_CB);
RADIOBUTTON_direct=glui_3dsmoke->add_radiobutton_to_group(RADIO_use_colormap,"Use specified color, opacity, albedo");
RADIOBUTTON_constraint=glui_3dsmoke->add_radiobutton_to_group(RADIO_use_colormap,"Use colormap with constraints");
RADIOBUTTON_noconstraint=glui_3dsmoke->add_radiobutton_to_group(RADIO_use_colormap,"Use colormap without constraints");
ROLLOUT_colormap3 = glui_3dsmoke->add_rollout_to_panel(PANEL_colormap,"fire color/opacity, smoke albedo",false);
PANEL_colormap3a = glui_3dsmoke->add_panel_to_panel(ROLLOUT_colormap3,"",GLUI_PANEL_NONE);
SPINNER_smoke3d_fire_red=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap3a,_("red"),GLUI_SPINNER_INT,&fire_red,FIRE_RED,Smoke3d_CB);
SPINNER_smoke3d_fire_red->set_int_limits(0,255);
SPINNER_smoke3d_fire_green=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap3a,_("green"),GLUI_SPINNER_INT,&fire_green,FIRE_GREEN,Smoke3d_CB);
SPINNER_smoke3d_fire_green->set_int_limits(0,255);
SPINNER_smoke3d_fire_blue=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap3a,_("blue"),GLUI_SPINNER_INT,&fire_blue,FIRE_BLUE,Smoke3d_CB);
SPINNER_smoke3d_fire_blue->set_int_limits(0,255);
PANEL_colormap3b = glui_3dsmoke->add_panel_to_panel(ROLLOUT_colormap3,"",GLUI_PANEL_NONE);
SPINNER_smoke3d_fire_halfdepth=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap3b,_("fire half depth (m)"),GLUI_SPINNER_FLOAT,&fire_halfdepth,FIRE_HALFDEPTH,Smoke3d_CB);
SPINNER_smoke3d_fire_halfdepth->set_float_limits(0.0,10.0);
SPINNER_smoke3d_smoke_albedo=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap3b,_("smoke albedo"),GLUI_SPINNER_FLOAT,&smoke_albedo,SMOKE_SHADE,Smoke3d_CB);
SPINNER_smoke3d_smoke_albedo->set_float_limits(0.0,1.0);
if(ncolorbars>0) {
LISTBOX_smoke_colorbar=glui_3dsmoke->add_listbox_to_panel(ROLLOUT_colormap3,_("colormap:"),&fire_colorbar_index,SMOKE_COLORBAR_LIST,Smoke3d_CB);
for(i=0; i<ncolorbars; i++) {
colorbardata *cbi;
cbi = colorbarinfo + i;
cbi->label_ptr=cbi->label;
LISTBOX_smoke_colorbar->add_item(i,cbi->label_ptr);
}
LISTBOX_smoke_colorbar->set_int_val(fire_colorbar_index);
}
PANEL_colormap2 = glui_3dsmoke->add_panel_to_panel(PANEL_colormap,"",GLUI_PANEL_NONE);
#define HRRPUV_CUTOFF_MAX (hrrpuv_max_smv-0.01)
PANEL_colormap2b = glui_3dsmoke->add_rollout_to_panel(PANEL_colormap2,"HRRPUV (kW/m3)");
SPINNER_hrrpuv_cutoff=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap2b,_("cutoff"),GLUI_SPINNER_FLOAT,&global_hrrpuv_cutoff,GLOBAL_FIRE_CUTOFF,Smoke3d_CB);
SPINNER_hrrpuv_cutoff->set_float_limits(0.0,HRRPUV_CUTOFF_MAX);
{
char label[256];
strcpy(label,"Temperature (");
strcat(label,degC);
strcat(label,")");
PANEL_colormap2a = glui_3dsmoke->add_rollout_to_panel(PANEL_colormap2,label);
}
SPINNER_temperature_min=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap2a,_("min"),GLUI_SPINNER_FLOAT,
&temperature_min,TEMP_MIN,Smoke3d_CB);
SPINNER_temperature_cutoff=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap2a,_("cutoff"),GLUI_SPINNER_FLOAT,
&temperature_cutoff,TEMP_CUTOFF,Smoke3d_CB);
SPINNER_temperature_max=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap2a,_("max"),GLUI_SPINNER_FLOAT,
&temperature_max,TEMP_MAX,Smoke3d_CB);
Smoke3d_CB(TEMP_MIN);
Smoke3d_CB(TEMP_CUTOFF);
Smoke3d_CB(TEMP_MAX);
if(nsmoke3dinfo>0) {
PANEL_meshvis = glui_3dsmoke->add_rollout_to_panel(PANEL_overall,"Mesh Visibility",false);
for(i=0; i<nmeshes; i++) {
mesh *meshi;
meshi = meshinfo + i;
glui_3dsmoke->add_checkbox_to_panel(PANEL_meshvis,meshi->label,meshvisptr+i);
}
}
Smoke3d_CB(FIRECOLORMAP_TYPE);
glui_3dsmoke->add_column_to_panel(PANEL_overall,false);
if(nsmoke3dinfo<=0||nvolrenderinfo<=0) {
smoke_render_option=RENDER_SLICE;
if(nsmoke3dinfo>0)smoke_render_option=RENDER_SLICE;
if(nvolrenderinfo>0)smoke_render_option=RENDER_VOLUME;
}
// slice render dialog
if(nsmoke3dinfo>0) {
ROLLOUT_slices = glui_3dsmoke->add_rollout_to_panel(PANEL_overall,_("Slice render settings"),false, SLICERENDER_ROLLOUT, Smoke_Rollout_CB);
ADDPROCINFO(smokeprocinfo, nsmokeprocinfo, ROLLOUT_slices, SLICERENDER_ROLLOUT);
ROLLOUT_slices->set_alignment(GLUI_ALIGN_LEFT);
#ifdef pp_GPU
if(gpuactive==0) {
usegpu=0;
CHECKBOX_smokeGPU->disable();
}
#endif
#ifdef pp_CULL
CHECKBOX_smokecullflag=glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_slices,_("Cull hidden slices"),&cullsmoke,CULL_SMOKE,Smoke3d_CB);
if(cullactive==0) {
cullsmoke=0;
CHECKBOX_smokecullflag->disable();
}
CHECKBOX_show_cullports=glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_slices,_("Show cull ports"),&show_cullports);
SPINNER_cull_portsize=glui_3dsmoke->add_spinner_to_panel(ROLLOUT_slices,_("Cull port size"),GLUI_SPINNER_INT,&cull_portsize,CULL_PORTSIZE,Smoke3d_CB);
{
int ijk_max=0;
for(i=0; i<nmeshes; i++) {
mesh *meshi;
meshi = meshinfo + i;
if(ijk_max<meshi->ibar+1)ijk_max=meshi->ibar+1;
if(ijk_max<meshi->jbar+1)ijk_max=meshi->jbar+1;
if(ijk_max<meshi->kbar+1)ijk_max=meshi->kbar+1;
}
SPINNER_cull_portsize->set_int_limits(3,ijk_max);
}
#else
CHECKBOX_smokecullflag=glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_slices,"Cull hidden slices",&smokecullflag);
#endif
#ifdef _DEBUG
CHECKBOX_smokedrawtest=glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_slices,"Show only back slices",&smokedrawtest);
CHECKBOX_smokedrawtest2=glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_slices,"Show only X slices",&smokedrawtest2);
SPINNER_smokedrawtest_nummin=glui_3dsmoke->add_spinner_to_panel(ROLLOUT_slices,"Back slice",GLUI_SPINNER_INT,&smokedrawtest_nummin);
SPINNER_smokedrawtest_nummin->set_int_limits(1,ijkbarmax);
SPINNER_smokedrawtest_nummax=glui_3dsmoke->add_spinner_to_panel(ROLLOUT_slices,"Front slice",GLUI_SPINNER_INT,&smokedrawtest_nummax);
SPINNER_smokedrawtest_nummax->set_int_limits(1,ijkbarmax);
#endif
RADIO_skipframes = glui_3dsmoke->add_radiogroup_to_panel(ROLLOUT_slices,&smokeskipm1);
glui_3dsmoke->add_radiobutton_to_group(RADIO_skipframes,_("Display all"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_skipframes,_(" ... Every 2nd"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_skipframes,_(" ... Every 3rd"));
#ifdef pp_GPU
SPINNER_smoke3d_rthick=glui_3dsmoke->add_spinner_to_panel(ROLLOUT_slices,_("Thickness"),
GLUI_SPINNER_FLOAT,&smoke3d_rthick,SMOKE_RTHICK,Smoke3d_CB);
SPINNER_smoke3d_rthick->set_float_limits(1.0,255.0);
smoke3d_thick = log_base2(smoke3d_rthick);
#else
SPINNER_smoke3d_thick=glui_3dsmoke->add_spinner_to_panel(PANEL_colormap,"Thickness",
GLUI_SPINNER_INT,&smoke3d_thick,SMOKE_THICK,Smoke3d_CB);
SPINNER_smoke3d_thick->set_int_limits(0,7);
#endif
PANEL_absorption = glui_3dsmoke->add_panel_to_panel(ROLLOUT_slices,_("Absorption adjustments"));
PANEL_absorption->set_alignment(GLUI_ALIGN_LEFT);
RADIO_alpha = glui_3dsmoke->add_radiogroup_to_panel(PANEL_absorption,&adjustalphaflag);
glui_3dsmoke->add_radiobutton_to_group(RADIO_alpha,_("None"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_alpha,_("adjust off-center"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_alpha,_("zero at boundaries"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_alpha,_("both"));
}
// volume render dialog
if(nvolrenderinfo > 0) {
ROLLOUT_volume = glui_3dsmoke->add_rollout_to_panel(PANEL_overall, _("Volume render settings"), false, VOLRENDER_ROLLOUT, Smoke_Rollout_CB);
ADDPROCINFO(smokeprocinfo, nsmokeprocinfo, ROLLOUT_volume, VOLRENDER_ROLLOUT);
if(have_volcompressed == 1) {
RADIO_loadvol = glui_3dsmoke->add_radiogroup_to_panel(ROLLOUT_volume, &glui_load_volcompressed, LOAD_COMPRESSED_DATA, Smoke3d_CB);
glui_3dsmoke->add_radiobutton_to_group(RADIO_loadvol, _("Load full data"));
glui_3dsmoke->add_radiobutton_to_group(RADIO_loadvol, _("Load compressed data"));
}
glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Load data in background"), &use_multi_threading);
CHECKBOX_compress_volsmoke = glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Compress data while loading"), &glui_compress_volsmoke);
if(have_volcompressed == 1) {
Smoke3d_CB(LOAD_COMPRESSED_DATA);
}
glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Display data as b/w"), &volbw);
glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Show data while moving scene"), &show_volsmoke_moving);
glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Load data only at render times"), &load_at_rendertimes);
SPINNER_fire_opacity_factor = glui_3dsmoke->add_spinner_to_panel(ROLLOUT_volume, _("Fire opacity multiplier"), GLUI_SPINNER_FLOAT, &fire_opacity_factor);
SPINNER_fire_opacity_factor->set_float_limits(1.0, 10.0);
SPINNER_mass_extinct = glui_3dsmoke->add_spinner_to_panel(ROLLOUT_volume, _("Mass extinction coeff"), GLUI_SPINNER_FLOAT, &mass_extinct);
SPINNER_mass_extinct->set_float_limits(100.0, 100000.0);
glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Freeze"), &freeze_volsmoke);
#ifdef _DEBUG
CHECKBOX_usevolrender = glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Show"), &usevolrender, VOL_SMOKE, Smoke3d_CB);
glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, "block smoke", &block_volsmoke);
glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, "debug", &smoke3dVoldebug);
#endif
CHECKBOX_combine_meshes = glui_3dsmoke->add_checkbox_to_panel(ROLLOUT_volume, _("Combine meshes"), &combine_meshes, COMBINE_MESHES, Smoke3d_CB);
SPINNER_nongpu_vol_factor = glui_3dsmoke->add_spinner_to_panel(ROLLOUT_volume, _("non-gpu grid multiplier"), GLUI_SPINNER_FLOAT, &nongpu_vol_factor, NONGPU_VOL_FACTOR, Smoke3d_CB);
SPINNER_nongpu_vol_factor->set_float_limits(1.0, 10.0);
SPINNER_gpu_vol_factor = glui_3dsmoke->add_spinner_to_panel(ROLLOUT_volume, _("gpu grid multiplier"), GLUI_SPINNER_FLOAT, &gpu_vol_factor, GPU_VOL_FACTOR, Smoke3d_CB);
SPINNER_gpu_vol_factor->set_float_limits(1.0, 10.0);
PANEL_generate_images = glui_3dsmoke->add_rollout_to_panel(ROLLOUT_volume, _("Generate images"), false);
SPINNER_startframe = glui_3dsmoke->add_spinner_to_panel(PANEL_generate_images, _("start frame"), GLUI_SPINNER_INT, &vol_startframe0, START_FRAME, Smoke3d_CB);
SPINNER_skipframe = glui_3dsmoke->add_spinner_to_panel(PANEL_generate_images, _("skip frame"), GLUI_SPINNER_INT, &vol_skipframe0, SKIP_FRAME, Smoke3d_CB);
Smoke3d_CB(START_FRAME);
Smoke3d_CB(SKIP_FRAME);
if(ntours > 0) {
selectedtour_index = -1;
selectedtour_index_old = -1;
LISTBOX_VOL_tour = glui_3dsmoke->add_listbox_to_panel(PANEL_generate_images, "Tour:", &selectedtour_index, VOL_TOUR_LIST, Smoke3d_CB);
LISTBOX_VOL_tour->add_item(-1, "Manual");
LISTBOX_VOL_tour->add_item(-999, "-");
for(i = 0; i < ntours; i++) {
tourdata *touri;
touri = tourinfo + i;
LISTBOX_VOL_tour->add_item(i, touri->label);
}
LISTBOX_VOL_tour->set_int_val(selectedtour_index);
}
strcpy(vol_prefix, fdsprefix);
EDIT_vol_prefix = glui_3dsmoke->add_edittext_to_panel(PANEL_generate_images, "image prefix:", GLUI_EDITTEXT_TEXT, vol_prefix, VOL_PREFIX, Smoke3d_CB);
EDIT_vol_prefix->set_w(200);
BUTTON_startrender = glui_3dsmoke->add_button_to_panel(PANEL_generate_images, _("Generate images"), GENERATE_IMAGES, Smoke3d_CB);
BUTTON_cancelrender = glui_3dsmoke->add_button_to_panel(PANEL_generate_images, _("Cancel"), CANCEL_GENERATE_IMAGES, Smoke3d_CB);
BUTTON_volunload = glui_3dsmoke->add_button_to_panel(PANEL_generate_images, _("Unload"), VOL_UNLOAD_ALL, Smoke3d_CB);
}
Update_Smoke_Type();
#ifdef pp_GPU
Smoke3d_CB(VOL_SMOKE);
#endif
Smoke3d_CB(SMOKE_OPTIONS);
}
int main() {
BEGIN
messager("loading training data, test data....", MEKEY);
loadTrain(trainData, l_low, l_up);
loadTest(testData);
messager("done loading", MEKEY);
END
//initialize alpha values :
//separate initialize the alpha values,
//norAlpha and attAlhpa all 1
messager("initialize optimized index table", MEKEY);
messager("initialize all alpha to 0", MEKEY);
messager("initialize all gradient to 0", MEKEY);
messager("initialize all gradient bar to 0", MEKEY);
BEGIN
for (int i = 0; i < train_num; i++)
{
b.push_back(init_p);
alpha.push_back(0.0);
optimied_index[i] = false;
if (encounter[i] == 1) {
penalty.push_back(nor_penalty);
pro.push_back(57378/62367);
}
else
{
penalty.push_back(att_penalty);
pro.push_back(4989/62367);
}
grad.push_back(b[i]);
}
for (int i = 0; i < train_num; i++)
{
grad_bar.push_back(0); //no alpha is C at first, so all for zero
}
for(int i = 0; i < train_num; i++)
{
if(!is_lowerBound(i))
{
vector<double> column_i = get_Q(i);
for(int j = 0; j < train_num; j++)
{
grad[j] += alpha[i] * column_i[j];
}
if(is_upperBound(i))
{
for(int j = 0; j < train_num; j++)
{
grad_bar[j] += penalty[i] * column_i[j];
}
}
}
}
END
/*
* iterator procedure
*/
//Values newAlpha;
messager("modeling...", MEKEY);
bool examALL = false;
Values violating_pair;
int iter = 0;
while ( iter < train_num)
{
//test select WSS1, fixed l_up but not calculate all of it, it's too expense
//test_ktt();
cout << iter << endl;
int i;
int j;
vector<double> qColu_i;
vector<double> qColu_j;
// if(iter%1000 == 0)
// {
// do_shrinking();
// }
if(selectWSS(i, j, violating_pair))
{
updateGrad();
active_size = train_num;
cout << "finished optimized" << endl;
break;
}
else
{
qColu_i = get_Q(i);
qColu_j = get_Q(j);
update_alpha(violating_pair, i, j, qColu_i, qColu_j);
updateGrad();
}
iter++;
}
int count = 0;
for(int i = 0; i < alpha.size(); i ++)
{
if(alpha[i] != 0)
{
cout << "not zero alpha " << alpha[i] << "grad : " << grad[i] << endl;
}
}
messager("alpha not zero", count, MEKEY);
return 0;
}
