void output_matrix_long(long diffl, long tree1, long tree2, long trees_in_1, long trees_in_2) { if ( tree1 == 1 && ((tree2 - 1) % get_num_columns() == 0 || tree2 == 1 )) { if ( (tree_pairing == ALL_IN_FIRST && tree2 + get_num_columns() - 1 < trees_in_1) || (tree_pairing == ALL_IN_1_AND_2 && tree2 + get_num_columns() - 1 < trees_in_2)) { print_matrix_heading(tree2, tree2 + get_num_columns() - 1); } else { if ( tree_pairing == ALL_IN_FIRST) print_matrix_heading(tree2, trees_in_1); else print_matrix_heading(tree2, trees_in_2); } } if ( (tree2 - 1) % get_num_columns() == 0 || tree2 == 1) { print_line_heading(tree1); } fprintf(outfile, "%4ld ", diffl); if ((tree_pairing == ALL_IN_FIRST && tree1 == trees_in_1 && tree2 == trees_in_1) || (tree_pairing == ALL_IN_1_AND_2 && tree1 == trees_in_1 && tree2 == trees_in_2)) fprintf(outfile, "\n\n\n"); } /* output_matrix_long */
void TablePrinter::PrintHeader(){ PrintHorizontalLine(); *out_stream_ << "|"; for (int i=0; i<get_num_columns(); ++i){ *out_stream_ << std::setw(column_widths_.at(i)) << column_headers_.at(i).substr(0, column_widths_.at(i)); if (i != get_num_columns()-1){ *out_stream_ << separator_; } } *out_stream_ << "|\n"; PrintHorizontalLine(); }
void table_printer::print_header() { print_horizontal_line(); *m_out_stream << "|"; for (int i=0; i < get_num_columns(); ++i) { *m_out_stream << std::setw(m_column_widths.at(i)) << m_column_headers.at(i).substr(0, m_column_widths.at(i)); if (i != get_num_columns() - 1) { *m_out_stream << m_separator; } } *m_out_stream << "|\n"; print_horizontal_line(); }
// Write the texture, using a virtual method call appropriate to the particular // camera type. NOTE: At least the first time this function is called, // we must write a complete texture, which may be larger than the actual bytes // allocated for the image. After the first time, and if we don't change the // image size to be larger, we can use the subimage call to only write the // pixels we have. bool edt_server::write_to_opengl_texture(GLuint tex_id) { // Note: Check the GLubyte or GLushort or whatever in the temporary buffer! const GLint NUM_COMPONENTS = 1; const GLenum FORMAT = GL_LUMINANCE; const GLenum TYPE = GL_UNSIGNED_BYTE; const void* BASE_BUFFER = d_buffer; const void* SUBSET_BUFFER = &d_buffer[NUM_COMPONENTS * ( _minX + get_num_columns()*_minY )]; return write_to_opengl_texture_generic(tex_id, NUM_COMPONENTS, FORMAT, TYPE, BASE_BUFFER, SUBSET_BUFFER, _minX, _minY, _maxX, _maxY); }
bool edt_server::write_opengl_texture_to_quad() { double xfrac = static_cast<double>(get_num_columns()) / _opengl_texture_size_x; double yfrac = static_cast<double>(get_num_rows()) / _opengl_texture_size_y; // Flip over while writing. // Set the texture and vertex coordinates and write the quad to OpenGL. glBegin(GL_QUADS); glTexCoord2d(0.0, yfrac); glVertex2d(-1.0, -1.0); glTexCoord2d(xfrac, yfrac); glVertex2d(1.0, -1.0); glTexCoord2d(xfrac, 0.0); glVertex2d(1.0, 1.0); glTexCoord2d(0.0, 0.0); glVertex2d(-1.0, 1.0); glEnd(); return true; }
int main(int argc, char *argv[]){ FILE *fp; char *line = NULL; size_t len = 0; ssize_t read; static int simple_flag; int c; while ((c = getopt(argc, argv, "s") ) != -1) { switch (c) { case 's': simple_flag = 1; break; default: simple_flag = 0; } } char *hor_thicc; char *hor_thinn; char *vert; if (simple_flag == 0) { hor_thicc = "="; hor_thinn = "-"; vert = "|"; } else { hor_thicc = "="; hor_thinn = " "; vert = "|"; } // printf("simple: %d %d\n", simple_flag, optind); fp = fopen(argv[optind], "r"); if (fp == NULL) exit(EXIT_FAILURE); // PASS I: Get the number of columns, the number of headers, and the number of rows int num_lines = -1; int num_headers = 0; int num_columns = 0; while ((read = getline(&line, &len, fp)) != -1) { if (num_lines == -1){ num_headers = get_num_columns(line); } int line_columns = get_num_columns(line); if( line_columns > num_columns ) num_columns = line_columns; //printf("%s", line); num_lines++; } //printf("num headers: %d\n", num_headers); //printf("num lines: %d\n", num_lines); //printf("num columns: %d\n", num_columns); // PASS II: Get the length of the longest string in each column fp = fopen(argv[optind], "r"); if (fp == NULL) exit(EXIT_FAILURE); size_t most_longest[num_columns]; for (int i = 0; i < num_columns; i++) { most_longest[i] = 0; } while ((read = getline(&line, &len, fp)) != -1) { size_t *longest; longest = get_longest(line, num_columns); // for (int i = 0; i < num_columns; i++) { // printf("%zu,", longest[i]); // } // puts(""); for(int i = 0; i < num_columns; i++) { if(longest[i] > most_longest[i]) most_longest[i] = longest[i]; } free(longest); } //for (int i = 0; i < num_columns; i++) { // printf("%zu,", most_longest[i]); //} // SECTION I: Get some more information size_t total_width = 0; for(int i = 0; i < num_columns; i++){ total_width += most_longest[i]; } total_width += (num_columns + 1); //puts(""); // PASS III: Print her!! fp = fopen(argv[optind], "r"); if (fp == NULL) exit(EXIT_FAILURE); //char* headers[num_headers]; //char* lines[num_lines][num_columns]; int index = 0; const char s = ','; int temp_var = 0; print_many(hor_thicc, total_width, vert); while ((read = getline(&line, &len, fp)) != -1) { // If the last character of the line is a newline, replace it with a NULL byte if(line[strlen(line)-1] == 10){ line[strlen(line)-1] = 0; } if (temp_var != 2 || simple_flag == 0){ printf("%s", vert); temp_var++ ; } // Print defined columns int colnum = 0; // The current column, 0 indexed unsigned int pos = 0; // The absolute position in the line for(colnum = 0; colnum < num_columns; colnum++){ // For every column unsigned int col_len = 0; // Length of data in column while (line[pos] != s && line[pos] != 0 && pos < strlen(line)){ // While the current index isn't , or 0 printf("%c", line[pos]); // Print the current character pos++; col_len++; } pos++; // For the comma //printf("%d", col_len); size_t pad_this_many = most_longest[colnum] - col_len; // Find out how much to pad for(unsigned int j = 0; j<pad_this_many; j++){ // Pad it printf(" "); } printf("%s", vert); // Close column } // Print undefined columns /* while(colnum != num_columns){ for(unsigned int l = 0; l<most_longest[colnum]; l++){ printf(" "); } printf("|"); colnum++; } */ puts(""); // Print dividing line if (index < num_lines) { printf("%s", vert); for(int i = 0; i<num_columns; i++) { for(unsigned int j = 0; j<most_longest[i];j++){ if(index==0){ printf("%s", hor_thicc); } if(index!=0&&simple_flag==0){ printf("%s", hor_thinn); } } if (index == 0 || simple_flag ==0) printf("%s", vert); } if (index == 0 || simple_flag==0) puts(""); } index++; } print_many(hor_thicc, total_width, vert); free(line); exit(EXIT_SUCCESS); }
void compute_distances(pattern_elm ***pattern_array, long trees_in_1, long trees_in_2) { /* Compute symmetric distances between arrays of trees */ long tree_index, end_tree, index1, index2, index3; group_type **treeA, **treeB; long patternsz1, patternsz2; double *length1 = NULL, *length2 = NULL; int num_columns = get_num_columns(); index1 = 0; /* Put together space for treeA and treeB */ treeA = (group_type **) Malloc (setsz * sizeof (group_type *)); treeB = (group_type **) Malloc (setsz * sizeof (group_type *)); print_header(trees_in_1, trees_in_2); switch (tree_pairing) { case ADJACENT_PAIRS: /* For every tree, compute the distance between it and the tree at the next location; do this in both directions */ end_tree = trees_in_1 - 1; for (tree_index = 0 ; tree_index < end_tree ; tree_index += 2) { assign_tree (treeA, pattern_array, tree_index, &patternsz1); assign_tree (treeB, pattern_array, tree_index + 1, &patternsz2); assign_lengths(&length1, pattern_array, tree_index); assign_lengths(&length2, pattern_array, tree_index + 1); tree_diff (treeA, treeB, length1, length2, patternsz1, patternsz2, tree_index+1, tree_index+2, trees_in_1, trees_in_2); if (tree_index + 2 == end_tree) printf("\nWARNING: extra tree at the end of input tree file.\n"); } break; case ALL_IN_FIRST: /* For every tree, compute the distance between it and every other tree in that file. */ end_tree = trees_in_1; if ( output_scheme != FULL_MATRIX ) { /* verbose or sparse output */ for (index1 = 0 ; index1 < end_tree ; index1++) { assign_tree (treeA, pattern_array, index1, &patternsz1); assign_lengths(&length1, pattern_array, index1); for (index2 = 0 ; index2 < end_tree ; index2++) { assign_tree (treeB, pattern_array, index2, &patternsz2); assign_lengths(&length2, pattern_array, index2); tree_diff (treeA, treeB, length1, length2, patternsz1, patternsz2, index1 + 1, index2 + 1, trees_in_1, trees_in_2); } } } else { /* full matrix output */ for ( index3 = 0 ; index3 < trees_in_1 ; index3 += num_columns) { for ( index1 = 0 ; index1 < trees_in_1 ; index1++) { assign_tree (treeA, pattern_array, index1, &patternsz1); assign_lengths(&length1, pattern_array, index1); for ( index2 = index3 ; index2 < index3 + num_columns && index2 < trees_in_1 ; index2++) { assign_tree (treeB, pattern_array, index2, &patternsz2); assign_lengths(&length2, pattern_array, index2); tree_diff (treeA, treeB, length1, length2, patternsz1, patternsz2, index1 + 1, index2 + 1, trees_in_1, trees_in_2); } } } } break; case CORR_IN_1_AND_2: if (trees_in_1 != trees_in_2) { /* Set end tree to the smaller of the two totals. */ end_tree = trees_in_1 > trees_in_2 ? trees_in_2 : trees_in_1; /* Print something out to the outfile and to the terminal. */ fprintf(outfile, "\n\n" "*** Warning: differing number of trees in first and second\n" "*** tree files. Only computing %ld pairs.\n" "\n", end_tree ); printf( "\n" " *** Warning: differing number of trees in first and second\n" " *** tree files. Only computing %ld pairs.\n" "\n", end_tree ); } else end_tree = trees_in_1; for (tree_index = 0 ; tree_index < end_tree ; tree_index++) { /* For every tree, compute the distance between it and the tree at the parallel location in the other file; do this in both directions */ assign_tree (treeA, pattern_array, tree_index, &patternsz1); assign_lengths(&length1, pattern_array, tree_index); /* (tree_index + trees_in_1) will be the corresponding tree in the second file. */ assign_tree (treeB, pattern_array, tree_index + trees_in_1, &patternsz2); assign_lengths(&length2, pattern_array, tree_index + trees_in_1); tree_diff (treeA, treeB, length1, length2, patternsz1, patternsz2, tree_index + 1, 0, trees_in_1, trees_in_2); } break; case ALL_IN_1_AND_2: end_tree = trees_in_1 + trees_in_2; if ( output_scheme != FULL_MATRIX ) { for (tree_index = 0 ; tree_index < trees_in_1 ; tree_index++) { /* For every tree in the first file, compute the distance between it and every tree in the second file. */ assign_tree (treeA, pattern_array, tree_index, &patternsz1); assign_lengths(&length1, pattern_array, tree_index); for (index2 = trees_in_1 ; index2 < end_tree ; index2++) { assign_tree (treeB, pattern_array, index2, &patternsz2); assign_lengths(&length2, pattern_array, index2); tree_diff(treeA, treeB, length1, length2, patternsz1, patternsz2, tree_index + 1 , index2 + 1, trees_in_1, trees_in_2); } } for ( ; tree_index < end_tree ; tree_index++) { /* For every tree in the second file, compute the distance between it and every tree in the first file. */ assign_tree (treeA, pattern_array, tree_index, &patternsz1); assign_lengths(&length1, pattern_array, tree_index); for (index2 = 0 ; index2 < trees_in_1 ; index2++) { assign_tree (treeB, pattern_array, index2, &patternsz2); assign_lengths(&length2, pattern_array, index2); tree_diff (treeA, treeB, length1, length2 , patternsz1, patternsz2, tree_index + 1, index2 + 1, trees_in_1, trees_in_2); } } } else { for ( index3 = trees_in_1 ; index3 < end_tree ; index3 += num_columns) { for ( index1 = 0 ; index1 < trees_in_1 ; index1++) { assign_tree (treeA, pattern_array, index1, &patternsz1); assign_lengths(&length1, pattern_array, index1); for ( index2 = index3 ; index2 < index3 + num_columns && index2 < end_tree ; index2++) { assign_tree (treeB, pattern_array, index2, &patternsz2); assign_lengths(&length2, pattern_array, index2); tree_diff (treeA, treeB, length1, length2, patternsz1, patternsz2, index1 + 1, index2 - trees_in_1 + 1, trees_in_1, trees_in_2); } } } } break; } /* Free up treeA and treeB */ free (treeA); free (treeB); } /* compute_distances */