void double_slide_holder:: set_values ( value_type val , value_type min , value_type max , value_type ss // -1 means use existing value , value_type ps // -1 means use existing value ) { d_assert( ! is_setting( )); // We generate our own signals instead of relying on the inner object. while_setting_value_wrapper_type wrapper( this, false); d_assert( is_setting( )); // Remember the old values. value_type const old_val = get_value( ); value_type const old_min = get_min_value( ); value_type const old_max = get_max_value( ); value_type const old_ss = get_single_step( ); value_type const old_ps = get_page_step( ); // Must do this before the conversions that follow. setup_conversions( min, max); // Send the values to the inner holder. p_inner_holder_-> set_values ( convert_outer_to_inner( val) , convert_outer_to_inner( min) , convert_outer_to_inner( max) , convert_outer_to_inner_distance( ss) , convert_outer_to_inner_distance( ps) ); // Find the new values. These may be slightly different due to rounding etc. value_type const new_val = get_value( ); value_type const new_min = get_min_value( ); value_type const new_max = get_max_value( ); value_type const new_ss = get_single_step( ); value_type const new_ps = get_page_step( ); // Emit the value signals. if ( (new_ss != old_ss) || (new_ps != old_ps) ) { emit has_changed__steps( new_ss, new_ps); wrapper.request_signal( ); } if ( (new_min != old_min) || (new_max != old_max) ) { emit has_changed__range( new_min, new_max); wrapper.request_signal( ); } if ( new_val != old_val ) { emit has_changed( new_val); wrapper.request_signal( ); } // The wrapper dtor will signal has_changed( ) if appropriate. wrapper.done_with_no_throws( ); }
void MemoryPool::record_peak_memory_usage() { // Caller in JDK is responsible for synchronization - // acquire the lock for this memory pool before calling VM MemoryUsage usage = get_memory_usage(); size_t peak_used = get_max_value(usage.used(), _peak_usage.used()); size_t peak_committed = get_max_value(usage.committed(), _peak_usage.committed()); size_t peak_max_size = get_max_value(usage.max_size(), _peak_usage.max_size()); _peak_usage = MemoryUsage(initial_size(), peak_used, peak_committed, peak_max_size); }
static bool verify_contents(const struct fmt_test *test) { bool result = true; unsigned amount = piglit_width * piglit_height; unsigned short *pix = malloc (amount * 8); glReadPixels(0, 0, piglit_width, piglit_height, GL_RGBA, test->type, pix); /* Setup expected value, alpha is always max in the test. */ unsigned short value[4] = { 0 }; value_for_format(test, value); value[3] = get_max_value(test->type); unsigned short *p = pix; for (unsigned i = 0; i < amount; i++, p += 4) { if (memcmp(p, value, sizeof(value)) == 0) continue; piglit_report_subtest_result(PIGLIT_FAIL, "format 0x%x read fail", test->iformat); result = false; break; } free(pix); return result; }
void int_range_steps_holder:: set_min_value( value_type new_min_value) { // set_value_base( this, min_value_, new_min_value, & int_range_steps_holder::has_changed__min_value); set_values( get_value( ), new_min_value, get_max_value( )); }
float test_min_max_enhancement_old(int y,int x,int kernel_radius,IplImage * image){ vector<int> kernel_values; for(int i=y-kernel_radius;i<=y+kernel_radius;i++){ for(int j=x-kernel_radius;j<=x+kernel_radius;j++){ if(is_coordinate_inside_boundaries(i,j,image)){ int value = get_pixel(image,i,j); kernel_values.push_back(value); } } } float median = get_median(kernel_values); int max_val = get_max_value(kernel_values); int min_val = get_min_value(kernel_values); int e = .001; //float new_value = (float)(max_val - min_val)/(max_val + min_val + e); //float new_value = (float)(max_val - min_val)/(median + e); //float new_value = (float)(max_val - min_val)/(max_val + e);//seems better float new_value = (float)(max_val - min_val)/(min_val + e); //float new_value = (float)(max_val - min_val)/((max_val + min_val)/2 + e); //int rvalue = (int)ceil(new_value); //return rvalue ; return new_value; }
void int_range_steps_holder:: set_page_step( value_type new_page_step) { // set_value_base( this, page_step_, new_page_step, & int_range_steps_holder::has_changed__page_step); set_values( get_value( ), get_min_value( ), get_max_value( ), get_single_step( ), new_page_step); }
/* slot */ void double_slide_holder:: set_value( value_type new_value) { // set_value_base( this, value_, new_value); set_values( new_value, get_min_value( ), get_max_value( )); }
void int_range_steps_holder:: set_value( value_type new_value) { // set_value_base( this, value_, new_value); set_values( new_value, get_min_value( ), get_max_value( )); }
//最长路径长度 int get_max_value (PNODE n) { if (n == NULL) return 0; if (n->right == NULL) { return n->value; } else { return get_max_value(n->right); } }
void Histogram::show_histogram() { IplImage* histogram_img = cvCreateImage(cvSize(get_max_value()+1,m_height),8,1); cvZero(histogram_img); for(int i=0;i<m_height;i++) { int next_value = m_histo_values[i]; int j=m_height-1; while (CV_IMAGE_ELEM(histogram_img,uchar, j, next_value)==255) --j; CV_IMAGE_ELEM(histogram_img,uchar, j, next_value) = 255; } cvNamedWindow("Histogram",0); cvResizeWindow("Histogram",5*get_max_value(),5*m_height); cvShowImage("Histogram", histogram_img ); cvReleaseImage(&histogram_img); }
void difmap::output_info(string filename, long double max, long double min, int large_ds){ ofstream infowrite; infowrite.open(filename.c_str(), ofstream::out); infowrite << "FILE 1 MAX: " << get_max_value(1) << endl; infowrite << "FILE 1 MIN: " << get_min_value(1) << endl; infowrite << "FILE 2 MAX: " << get_max_value(2) << endl; infowrite << "FILE 2 MIN: " << get_min_value(2) << endl; infowrite << "Max Difference: " << max << endl; infowrite << "Min Difference: " << min << endl; infowrite << "Range: " << (max-min) << endl; if(large_ds != -1) infowrite << "Dataset with largest values: " << large_ds << endl; infowrite << "\n" << "Light green points: Values that could not be interpolated" << endl; infowrite << "Dark green points: Divider" << endl; }
bool int_range_steps_holder:: is_valid( ) const { return (get_min_value( ) <= get_value( )) && (get_value( ) <= get_max_value( )) && (get_single_step( ) >= 0) && (get_page_step( ) >= 0) && implies( (get_page_step( ) > 0), (get_page_step( ) >= get_single_step( ))); }
void int_range_steps_holder:: move_values_to( QAbstractSlider * p_slider) const { d_assert( p_slider); // The step values we store aren't necessarily the ones we give the sliders. int page_step_slider = get_page_step( ); int single_step_slider = get_single_step( ); if ( 0 == page_step_slider ) { page_step_slider = (0 != single_step_slider) ? (10 * single_step_slider) : calc_about_an_eighth( get_max_value( ) - get_min_value( )); } if ( 0 == single_step_slider ) { single_step_slider = calc_about_an_eighth( page_step_slider); } p_slider->setPageStep( page_step_slider); p_slider->setSingleStep( single_step_slider); p_slider->setRange( get_min_value( ), get_max_value( )); p_slider->setValue( get_value( )); }
void int_range_steps_holder:: move_values_to( QSpinBox * p_spinb) const { d_assert( p_spinb); // The single-step value we store isn't always the one we give to the spinboxes. int single_step_spinb = get_single_step( ); if ( 0 == single_step_spinb ) { single_step_spinb = 1; } p_spinb->setSingleStep( single_step_spinb); p_spinb->setRange( get_min_value( ), get_max_value( )); p_spinb->setValue( get_value( )); }
SurfaceShellDensityMap::SurfaceShellDensityMap(const ParticlesTemp &ps, float voxel_size, IMP::FloatKey mass_key, int num_shells) : SampledDensityMap() { set_kernel(); set_particles(ps, mass_key); // update the grid size to contain all of the particles determine_grid_size(header_.get_resolution(), voxel_size, 3.); // to make update_voxel_size(voxel_size); num_shells_ = num_shells; set_neighbor_mask(); IMP_LOG_TERSE("going to resample\n"); resample(); // update dmin and dmax header_.dmin = get_min_value(); header_.dmax = get_max_value(); }
static bool verify_contents_float(const struct fmt_test *test) { /* Setup expected value, alpha is always max in the test. */ unsigned short value[4] = { 0 }; unsigned short max = get_max_value(test->type); value_for_format(test, value); value[3] = max; const float expected[4] = { value[0] / max, value[1] / max, value[2] / max, value[3] / max, }; bool res = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, expected); return res; }
static void value_for_format(const struct fmt_test *test, unsigned short *value) { unsigned short val = get_max_value(test->type); /* red */ value[0] = val; /* yellow */ if (test->bpp > 2) value[1] = val; /* pink */ if (test->bpp > 4) { value[2] = val; value[1] = 0; } /* blue */ if (test->bpp > 6) { value[3] = val; value[0] = 0; } }
static bool buffer_test(const struct fmt_test *test) { GLuint tex, tbo; /* Setup expected value, alpha is always max in the test. */ unsigned short tbo_data[4] = { 0 }; value_for_format(test, tbo_data); tbo_data[3] = get_max_value(test->type); glGenBuffers(1, &tbo); glBindBuffer(GL_TEXTURE_BUFFER, tbo); glBufferData(GL_TEXTURE_BUFFER, sizeof(tbo_data), tbo_data, GL_STATIC_DRAW); glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_BUFFER, tex); glTexBuffer(GL_TEXTURE_BUFFER, test->iformat, tbo); if (!piglit_check_gl_error(GL_NO_ERROR)) return false; glUseProgram(buf_prog); glUniform1i(0 /* explicit loc */, 0); render_texture(tex, GL_TEXTURE_BUFFER, 0); if (!verify_contents_float(test)) return false; piglit_present_results(); glDeleteTextures(1, &tex); glBindBuffer(GL_TEXTURE_BUFFER, 0); return true; }
int main() { char buf[50]; int option; PNODE tree = NULL; PNODE node = NULL; while (1) { printf ("--------------------------\n"); printf ("Options are:\n\n"); printf (" 0 Exit\n"); printf (" 1 Insert node\n"); printf (" 2 Delete node\n"); printf (" 3 Find node\n"); printf (" 4 Pre order traversal\n"); printf (" 5 In order traversal\n"); printf (" 6 Post order traversal\n"); printf (" 7 Max depth\n"); printf (" 8 Min depth\n"); printf (" 9 Max value\n"); printf (" 10 Min value\n"); printf (" 11 Node Count\n\n"); printf ("--------------------------\n"); printf ("Select an option: "); fgets (buf, sizeof(buf), stdin); sscanf (buf, "%i", &option); printf ("--------------------------\n"); if (option < 0 || option > 11) { fprintf (stderr, "Invalid option"); continue; } switch (option) { case 0: exit (0); case 1: printf ("Enter number to insert: "); fgets (buf, sizeof(buf), stdin); sscanf (buf, "%i", &option); printf ("\n\n"); insert_node (&tree, option); break; case 2: printf ("Enter number to delete: "); fgets (buf, sizeof(buf), stdin); sscanf (buf, "%i", &option); printf ("\n\n"); delete_node (&tree, option); break; case 3: printf ("Enter number to find: "); fgets (buf, sizeof(buf), stdin); sscanf (buf, "%i", &option); printf ("\n\n"); node = find_node (tree, option); if (node != NULL) { printf ("Found node\n\n"); } else { printf ("Couldn't find node\n\n"); } break; case 4: printf ("Pre order traversal: "); pre_order_traversal (tree); printf ("\n\n"); break; case 5: printf ("In order traversal: "); in_order_traversal (tree); printf ("\n\n"); break; case 6: printf ("Post order traversal: "); post_order_traversal (tree); printf ("\n\n"); break; case 7: printf ("Max depth is %i\n\n", get_max_depth (tree)); break; case 8: printf ("Min depth is %i\n\n", get_min_depth (tree)); break; case 9: printf ("Max value is %i\n\n", get_max_value (tree)); break; case 10: printf ("Min value is %i\n\n", get_min_value (tree)); break; case 11: printf ("Node Count is %i\n\n", get_num_nodes (tree)); break; } } return 0; }
/* slot */ void double_slide_holder:: set_steps( value_type single_step, value_type page_step) { set_values( get_value( ), get_min_value( ), get_max_value( ), single_step, page_step); }
string colmap::compare(){ string ret(""); indexed_points *ds1_ip = dynamic_cast<indexed_points*>(dataset1); indexed_points *ds2_ip = dynamic_cast<indexed_points*>(dataset2); if(ds1_ip == NULL || ds2_ip == NULL) return string("Improper Datasets"); for(int j=1; j<=2; j++){ long double max = get_max_value(j); long double min = get_min_value(j); long double range = max - min; int x_size = 0; int y_size = 0; int z_size = 0; if(j == 1){ x_size = ds1_ip->get_dim().sizes[0]; y_size = ds1_ip->get_dim().sizes[1]; z_size = ds1_ip->get_dim().sizes[2]; } else{ x_size = ds2_ip->get_dim().sizes[0]; y_size = ds2_ip->get_dim().sizes[1]; z_size = ds2_ip->get_dim().sizes[2];; } CImg<unsigned char> imgOut(x_size, y_size, z_size, 3, 0); for(int x=0; x<x_size; x++){ for(int y=0; y<y_size; y++){ for(int z=0; z<z_size; z++){ layout loc; loc.arr_size = 3; loc.sizes = new int[3]; loc.sizes[0] = x; loc.sizes[1] = y; loc.sizes[2] = z; long double pt_val; if(j == 1) pt_val = ds1_ip->get_indexed_point(loc).vals[var_ds1]; else if(j == 2) pt_val = ds2_ip->get_indexed_point(loc).vals[var_ds2]; rgb_color col = get_color_single_sided(pt_val, range, min); imgOut(x, y_size - y - 1, z, 0) = col.r; imgOut(x, y_size - y - 1, z, 1) = col.g; imgOut(x, y_size - y - 1, z, 2) = col.b; } } } //Construct file name string output_name(outprefix); output_name += "_colmap"; if(j == 1){ output_name += "_FIRST_"; output_name += "var1_"; output_name += itoa(var_ds1); } else if(j == 2){ output_name += "_SECOND_"; output_name += "var2_"; output_name += itoa(var_ds2); } output_name += ".bmp"; ret += output_name + " "; imgOut.save_bmp(output_name.c_str()); } return ret; }
/* slot */ void double_slide_holder:: set_min_value( value_type new_min_value) { set_values( get_value( ), new_min_value, get_max_value( )); }
/* slot */ void double_slide_holder:: set_page_step( value_type new_page_step) { set_values( get_value( ), get_min_value( ), get_max_value( ), get_single_step( ), new_page_step); }
double GRN::DNASeqAlignment(std::string query, int query_size, std::string subject, int subject_size) { // Linear gap penalty when inserts a space in query sequence. double G_ = GAP_2; // Linear gap penalty when inserts a space in subject sequence. double _G = GAP_2; // Records the length of query sequence after alignment. int query_length = 0; // Records the length of subject sequence after aligment. int subject_length = 0; // The number of matches and similar matches in alignment. When it's divided // by query_length or subject_length, it means the percentage similariy. double positives = 0; query_length = query_size; subject_length = subject_size; // Records longest common subsequence. std::string common_subsequence; // Records query sequence after alignment. std::string query_sub; // Records subject sequence after alignment. std::string subject_sub; // Score matrix of dynamic planning. // // Sets query sequence to be X axis. // Sets subject sequence to be Y axis. std::vector< std::vector<double> > align_matrix (subject_size + 1, std::vector<double>(query_size + 1)); // Initialize score matrix. // // Sets (0, 0) to be 0. // (i, 0) = (i - 1, 0) + gap penalty. // (0, j) = (0, j - 1) + gap penalty. align_matrix[0][0] = 0; for (int i = 1; i != subject_size + 1; ++i) { align_matrix[i][0] = align_matrix[i - 1][0] + G_; } for (int j = 1; j != query_size + 1; ++j) { align_matrix[0][j] = align_matrix[0][j - 1] + _G; } // Dynamic planning. // // There are 3 possible paths moving to (i, j) element in score matrix: // (1) Diagonal: // (i, j) = (i - 1, j - 1) + (subject[i] vs. query[j]). // It means a match or a similar match according to BLOSUM_50. // (2) Vertical: // (i, j) = (i - 1, j) + (subject[i] vs. a space in query[j]). // It means inserting a space in query sequence. // (3) Horizontal: // (i, j) = (i, j - 1) + (a space in subject[i] vs. query[j]). // It means inserting a space in subject sequence. // Chooses the maximum of the three as the actual path. for (int i = 1; i != subject_size + 1; ++i) { for (int j = 1; j != query_size + 1; ++j) { double st = 0; double s_ = 0; double _t = 0; st = align_matrix[i - 1][j - 1] + DNASequenceAlignScore(subject[i], query[j]); _t = align_matrix[i - 1][j] + DNASequenceAlignScore(subject[i], ' '); s_ = align_matrix[i][j - 1] + DNASequenceAlignScore(' ', query[j]); align_matrix[i][j] = get_max_value(st, s_, _t); } } // Trace back. // // Finds the longest common sequence and records the length of query // sequence and the length of subject sequence after alignment. // The trace begins at the last element in the score matrix and ends at // the first element in the score matrix. for (int i = subject_size, j = query_size; (i > 0 || j > 0);) { if ((i * j > 0) && (align_matrix[i][j] == align_matrix[i - 1][j - 1] + DNASequenceAlignScore(subject[i], query[j]))) { if (query[j] == subject[i]) { common_subsequence += query[j]; query_sub += query[j]; subject_sub += subject[i]; } else { query_sub += query[j]; subject_sub += subject[i]; } i--; j--; } else if ((i > 0) && (align_matrix[i][j] == align_matrix[i - 1][j] + DNASequenceAlignScore(subject[i], ' '))) { // Insert a space in query sequence. query_length += 1; query_sub += '-'; subject_sub += subject[i]; i--; } else if ((j > 0) && (align_matrix[i][j] == align_matrix[i][j - 1] + DNASequenceAlignScore(' ', query[j]))) { // Insert a space in subject sequence. subject_length += 1; subject_sub += '-'; query_sub += query[j]; j--; } } // Calculates the percentage simialrity. positives = (double)common_subsequence.size() / query_length; return positives; }
void int_range_steps_holder:: set_values ( value_type val , value_type min , value_type max , value_type ss // = -1 , value_type ps // = -1 ) { d_assert( is_valid( )); // Use existing values if negative steps specified. if ( ss < 0 ) { ss = get_single_step( ); } if ( ps < 0 ) { ps = get_page_step( ); } // Make sure the new values are valid. Min and single-step never change here. if ( max < min ) { max = min; } if ( val < min ) { val = min; } if ( val > max ) { val = max; } if ( (0 != ps) && (ps < ss) ) { ps = ss; } // Find out what's going to change. bool const is_changed__val = (value_ != val); bool const is_changed__min = (min_value_ != min); bool const is_changed__max = (max_value_ != max); bool const is_changed__ss = (single_step_ != ss ); bool const is_changed__ps = (page_step_ != ps ); // We're done if nothing is changing. if ( is_changed__val || is_changed__min || is_changed__max || is_changed__ss || is_changed__ps ) { if ( is_setting( ) ) { d_assert( false); } else { while_setting_value_wrapper_type wrapper( this); // Set the values in this holder. if ( is_changed__val ) { value_ = val; } if ( is_changed__min ) { min_value_ = min; } if ( is_changed__max ) { max_value_ = max; } if ( is_changed__ss ) { single_step_ = ss ; } if ( is_changed__ps ) { page_step_ = ps ; } d_assert( is_valid( )); // Loop thru all the attached widgets (spinboxes and sliders). // We don't have to relay our has_changed.. signals to these ctrls because we // keep them in sync here. list_type::iterator iter = attached_widgets_.begin( ); list_type::iterator const iter_limit = attached_widgets_.end( ); while ( iter != iter_limit ) { QWidget * p_widget = *iter; d_assert( p_widget); QSpinBox * p_spinb = qobject_cast< QSpinBox * >( p_widget); if ( p_spinb ) { move_values_to( p_spinb); } else { QAbstractSlider * p_slider = qobject_cast< QAbstractSlider * >( p_widget); d_assert( p_slider); move_values_to( p_slider); } ++ iter; } // Emit the value signals. The has_changed( ) signal with no args will be emitted last. if ( is_changed__ss || is_changed__ps ) { emit has_changed__steps( get_single_step( ), get_page_step( )); } if ( is_changed__min || is_changed__max ) { emit has_changed__range( get_min_value( ), get_max_value( )); } if ( is_changed__val ) { emit has_changed( get_value( )); } // The dtor for this wrapper emits the has_changed( ) signal. wrapper.done_with_no_throws( ); } } d_assert( is_valid( )); }
void int_range_steps_holder:: set_steps( value_type single_step, value_type page_step) { set_values( get_value( ), get_min_value( ), get_max_value( ), single_step, page_step); }