int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " grades-file" << std::endl; return 1; } std::ifstream grades_str(argv[1]); if (!grades_str) { std::cerr << "Can not open the grades in file " << argv[1] << std::endl; return 1; } std::vector<int> scores; read_scores(scores, grades_str); if (scores.size() == 0) { std::cerr << "No scores entered. Please try again. " << std::endl; return 1; } double average, std_dev; compute_avg_and_std_dev(scores, average, std_dev); double median = compute_median(scores); std::cout << "Among " << scores.size() << " grades: \n" << "average = " << std::setprecision(3) << average << '\n' << "standard deviation = " << std_dev << '\n' << "median = " << median << std::endl; }
int /* O - Exit status */ main(void) { int i; /* Looping var */ int ras_fd, /* File descriptor for read process */ status; /* Exit status of read process */ double start_secs, /* Start time */ write_secs, /* Write time */ read_secs, /* Read time */ pass_secs[TEST_PASSES]; /* Total test times */ /* * Ignore SIGPIPE... */ signal(SIGPIPE, SIG_IGN); /* * Run the tests several times to get a good average... */ printf("Test read/write speed of %d pages, %dx%d pixels...\n\n", TEST_PAGES, TEST_WIDTH, TEST_HEIGHT); for (i = 0; i < TEST_PASSES; i ++) { printf("PASS %2d: ", i + 1); fflush(stdout); ras_fd = run_read_test(); start_secs = get_time(); write_test(ras_fd); write_secs = get_time(); printf(" %.3f write,", write_secs - start_secs); fflush(stdout); close(ras_fd); wait(&status); read_secs = get_time(); pass_secs[i] = read_secs - start_secs; printf(" %.3f read, %.3f total\n", read_secs - write_secs, pass_secs[i]); } printf("\nMedian Total Time: %.3f seconds per document\n", compute_median(pass_secs)); return (0); }
/******************************************************************** * This program reads a MEME PSP file and computes the binned * distribution of priors. The distribution is writen to stdout. ********************************************************************/ int main(int argc, char *argv[]) { char *usage = "compute-prior-dist <num-bins> <psp-file>"; if (argc != 3) { fprintf(stderr, "Usage: %s\n", usage); return -1; } int num_bins = atoi(argv[1]); if (num_bins <= 0) { fprintf(stderr, "Usage: %s\n", usage); return -1; } const char *filename = argv[2]; // Read each prior, find max and min of distribution. DATA_BLOCK_READER_T *psp_reader = NULL; psp_reader = new_prior_reader_from_psp(FALSE /* Don't try to parse genomic coord.*/, filename); DATA_BLOCK_T *psp_block = new_prior_block(); int prior_array_size = 100; ARRAY_T *raw_priors = allocate_array(prior_array_size); int num_priors = 0; while (psp_reader->go_to_next_sequence(psp_reader) != FALSE) { while (psp_reader->get_next_block(psp_reader, psp_block) != FALSE) { double prior = get_prior_from_data_block(psp_block); if (prior == 0.0) { // Skip priors that are exactly 0.0 continue; } if (num_priors == INT_MAX) { die("Number of priors exceeded maximum allowed value of %d", INT_MAX); } set_array_item(num_priors, prior, raw_priors); ++num_priors; if (num_priors >= prior_array_size) { resize_array(raw_priors, 2 * prior_array_size); prior_array_size = 2 * prior_array_size; } } } free_data_block(psp_block); free_data_block_reader(psp_reader); ARRAY_T *priors = extract_subarray(raw_priors, 0, num_priors); free_array(raw_priors); double median_prior = compute_median(priors); double min_prior = get_array_item(0, priors); double max_prior = get_array_item(num_priors - 1, priors); // Print min, max, and median printf("#min %6.5f\n", min_prior); printf("#max %6.5f\n", max_prior); printf("#median %6.5f\n", median_prior); // Special case if priors are exactly uniform. if (min_prior == max_prior) { printf("%6.5f\n", 1.0); return 0; } // Create the array of bins, intialized to 0. double *prior_dist = mm_calloc(num_bins, sizeof(double)); double scale = (num_bins - 1) / (max_prior - min_prior); double offset = min_prior; int dist_index = 0; int i; for (i = 0; i < num_priors; ++i) { double prior = get_array_item(i, priors); dist_index = raw_to_scaled(prior, 1, scale, offset); ++prior_dist[dist_index]; } for (dist_index = 0; dist_index < num_bins; ++dist_index) { // Print normalized bin counts prior_dist[dist_index] /= num_priors; printf("%6.5f\n", prior_dist[dist_index]); } return 0; }
int main(int argc, char **argv) { STAT_DEFINITION *stat; long stats; STAT_REQUEST *request; long requests, count; SCANNED_ARG *scanned; SDDS_DATASET inData, outData; int32_t power; long i_arg, code, iStat, rows, tmpFileUsed, iColumn, row, posColIndex; long noWarnings, maxSourceColumns; char *input, *output, *positionColumn, **posColumnName; double **inputData, *outputData, value1, value2, topLimit, bottomLimit; unsigned long pipeFlags, scanFlags, majorOrderFlag; char s[100]; double *statWorkArray; double quartilePoint[2] = {25.0, 75.0 }, quartileResult[2]; double decilePoint[2] = {10.0, 90.0 }, decileResult[2]; double percent; short columnMajorOrder=-1; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scanned, argc, argv); if (argc<2) { bomb("too few arguments", USAGE); } posColumnName = NULL; input = output = positionColumn = NULL; stat = NULL; request = NULL; stats = requests = pipeFlags = 0; noWarnings = 0; outputData = NULL; statWorkArray = NULL; for (i_arg=1; i_arg<argc; i_arg++) { scanFlags = 0; if (scanned[i_arg].arg_type==OPTION) { /* process options here */ switch (code=match_string(scanned[i_arg].list[0], option, N_OPTIONS, 0)) { case SET_MAXIMUM: case SET_MINIMUM: case SET_MEAN: case SET_MEDIAN: case SET_STANDARDDEVIATION: case SET_RMS: case SET_SIGMA: case SET_MAD: case SET_COUNT: case SET_DRANGE: case SET_QRANGE: case SET_SMALLEST: case SET_LARGEST: case SET_SPREAD: if (scanned[i_arg].n_items<3) { fprintf(stderr, "error: invalid -%s syntax\n", option[code]); exit(1); } if (!scanItemList(&scanFlags, scanned[i_arg].list, &scanned[i_arg].n_items, SCANITEMLIST_UNKNOWN_VALUE_OK|SCANITEMLIST_REMOVE_USED_ITEMS| SCANITEMLIST_IGNORE_VALUELESS, "positionColumn", SDDS_STRING, &positionColumn, 1, POSITIONCOLUMN_GIVEN, "toplimit", SDDS_DOUBLE, &topLimit, 1, TOPLIMIT_GIVEN, "bottomlimit", SDDS_DOUBLE, &bottomLimit, 1, BOTTOMLIMIT_GIVEN, NULL)) { sprintf(s, "invalid -%s syntax", scanned[i_arg].list[0]); SDDS_Bomb(s); } requests = addStatRequests(&request, requests, scanned[i_arg].list+1, scanned[i_arg].n_items-1, code, scanFlags); request[requests-1].topLimit = topLimit; request[requests-1].bottomLimit = bottomLimit; if (positionColumn) { if (code==SET_MAXIMUM || code==SET_MINIMUM || code==SET_LARGEST || code==SET_SMALLEST) SDDS_CopyString(&request[requests-1].positionColumn, positionColumn); free(positionColumn); positionColumn = NULL; } break; case SET_PERCENTILE: if (scanned[i_arg].n_items<3) { fprintf(stderr, "error: invalid -%s syntax\n", option[code]); exit(1); } if (!scanItemList(&scanFlags, scanned[i_arg].list, &scanned[i_arg].n_items, SCANITEMLIST_UNKNOWN_VALUE_OK|SCANITEMLIST_REMOVE_USED_ITEMS| SCANITEMLIST_IGNORE_VALUELESS, "value", SDDS_DOUBLE, &percent, 1, PERCENT_GIVEN, "toplimit", SDDS_DOUBLE, &topLimit, 1, TOPLIMIT_GIVEN, "bottomlimit", SDDS_DOUBLE, &bottomLimit, 1, BOTTOMLIMIT_GIVEN, NULL) || !(scanFlags&PERCENT_GIVEN) || percent<=0 || percent>=100) SDDS_Bomb("invalid -percentile syntax"); requests = addStatRequests(&request, requests, scanned[i_arg].list+1, scanned[i_arg].n_items-1, code, scanFlags); request[requests-1].percent = percent; request[requests-1].topLimit = topLimit; request[requests-1].bottomLimit = bottomLimit; break; case SET_SUM: if (scanned[i_arg].n_items<3) { fprintf(stderr, "error: invalid -%s syntax\n", option[code]); exit(1); } power = 1; if (!scanItemList(&scanFlags, scanned[i_arg].list, &scanned[i_arg].n_items, SCANITEMLIST_UNKNOWN_VALUE_OK|SCANITEMLIST_REMOVE_USED_ITEMS| SCANITEMLIST_IGNORE_VALUELESS, "power", SDDS_LONG, &power, 1, 0, "toplimit", SDDS_DOUBLE, &topLimit, 1, TOPLIMIT_GIVEN, "bottomlimit", SDDS_DOUBLE, &bottomLimit, 1, BOTTOMLIMIT_GIVEN, NULL)) SDDS_Bomb("invalid -sum syntax"); requests = addStatRequests(&request, requests, scanned[i_arg].list+1, scanned[i_arg].n_items-1, code, scanFlags); request[requests-1].sumPower = power; request[requests-1].topLimit = topLimit; request[requests-1].bottomLimit = bottomLimit; break; case SET_PIPE: if (!processPipeOption(scanned[i_arg].list+1, scanned[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case SET_NOWARNINGS: noWarnings = 1; break; case SET_MAJOR_ORDER: majorOrderFlag=0; scanned[i_arg].n_items --; if (scanned[i_arg].n_items>0 && (!scanItemList(&majorOrderFlag, scanned[i_arg].list+1, &scanned[i_arg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) SDDS_Bomb("invalid -majorOrder syntax/values"); if (majorOrderFlag&SDDS_COLUMN_MAJOR_ORDER) columnMajorOrder=1; else if (majorOrderFlag&SDDS_ROW_MAJOR_ORDER) columnMajorOrder=0; break; default: fprintf(stderr, "error: unknown option '%s' given\n", scanned[i_arg].list[0]); exit(1); break; } } else { /* argument is filename */ if (!input) input = scanned[i_arg].list[0]; else if (!output) output = scanned[i_arg].list[0]; else SDDS_Bomb("too many filenames seen"); } } processFilenames("sddsrowstats", &input, &output, pipeFlags, noWarnings, &tmpFileUsed); if (!requests) SDDS_Bomb("no statistics requested"); if (!SDDS_InitializeInput(&inData, input)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!(stat=compileStatDefinitions(&inData, request, requests, &stats, noWarnings))) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (stats<0) SDDS_Bomb("No valid statistics requests."); for (iStat=maxSourceColumns=0; iStat<stats; iStat++) { if (stat[iStat].sourceColumns>maxSourceColumns) maxSourceColumns = stat[iStat].sourceColumns; } if (!(statWorkArray=malloc(sizeof(*statWorkArray)*maxSourceColumns))) SDDS_Bomb("allocation failure (statWorkArray)"); if (!setupOutputFile(&outData, output, &inData, stat, stats)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } inputData = NULL; while ((code=SDDS_ReadPage(&inData))>0) { if (!SDDS_CopyPage(&outData, &inData)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if ((rows = SDDS_CountRowsOfInterest(&inData))) { if (!(outputData = (double*)malloc(sizeof(*outputData)*rows))) SDDS_Bomb("memory allocation failure"); if (!(posColumnName = (char**)malloc(sizeof(*posColumnName)*rows))) SDDS_Bomb("memory allocation failure"); for (iStat=0; iStat<stats; iStat++) { if (!(inputData = (double**)malloc(sizeof(*inputData)*stat[iStat].sourceColumns))) SDDS_Bomb("memory allocation failure"); for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (!(inputData[iColumn] = SDDS_GetColumnInDoubles(&inData, stat[iStat].sourceColumn[iColumn]))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } for (row=0; row<rows; row++) outputData[row] = DBL_MAX; switch (stat[iStat].optionCode) { case SET_MINIMUM: for (row=0; row<rows; row++) { value1 = DBL_MAX; posColIndex = 0; posColumnName[row] = NULL; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; if (inputData[iColumn][row]<value1) { value1 = inputData[iColumn][row]; posColIndex = iColumn; } } outputData[row] = value1; if (stat[iStat].positionColumn) posColumnName[row] = stat[iStat].sourceColumn[posColIndex]; } break; case SET_MAXIMUM: for (row=0; row<rows; row++) { posColIndex = 0; value1 = -DBL_MAX; posColumnName[row] = NULL; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; if (inputData[iColumn][row]>value1) { posColIndex = iColumn; value1 = inputData[iColumn][row]; } } outputData[row] = value1; if (stat[iStat].positionColumn) posColumnName[row] = stat[iStat].sourceColumn[posColIndex]; } break; case SET_MEAN: for (row=0; row<rows; row++) { value1 = 0; count = 0; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; value1 += inputData[iColumn][row]; count ++; } if (count) outputData[row] = value1/count; } break; case SET_MEDIAN: for (row=0; row<rows; row++) { for (iColumn=count=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; statWorkArray[count] = inputData[iColumn][row]; count++; } if (count) compute_median(outputData+row, statWorkArray, count); } break; case SET_STANDARDDEVIATION: for (row=0; row<rows; row++) { value1 = 0; value2 = 0; count = 0; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; value1 += inputData[iColumn][row]; value2 += inputData[iColumn][row]*inputData[iColumn][row]; count ++; } if (count>1) { if ((value1 = value2/count - sqr(value1/count))<=0) outputData[row] = 0; else outputData[row] = sqrt(value1*count/(count-1.0)); } } break; case SET_SIGMA: for (row=0; row<rows; row++) { value1 = 0; value2 = 0; count = 0; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; value1 += inputData[iColumn][row]; value2 += inputData[iColumn][row]*inputData[iColumn][row]; count ++; } if (count>1) { if ((value1 = value2/count - sqr(value1/count))<=0) outputData[row] = 0; else outputData[row] = sqrt(value1/(count-1.0)); } } break; case SET_RMS: for (row=0; row<rows; row++) { value1 = 0; count = 0; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; value1 += sqr(inputData[iColumn][row]); count ++; } if (count) outputData[row] = sqrt(value1/count); } break; case SET_SUM: for (row=0; row<rows; row++) { value1 = 0; count = 0; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; value1 += ipow(inputData[iColumn][row], stat[iStat].sumPower); count ++; } if (count) outputData[row] = value1; } break; case SET_COUNT: for (row=0; row<rows; row++) { count = 0; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; count++; } outputData[row] = count; } break; case SET_MAD: for (row=0; row<rows; row++) { for (iColumn=count=value1=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; statWorkArray[count] = inputData[iColumn][row]; count++; } if (count) computeMoments(NULL, NULL, NULL, &outputData[row], statWorkArray, count); } break; case SET_DRANGE: for (row=0; row<rows; row++) { for (iColumn=count=value1=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; statWorkArray[count] = inputData[iColumn][row]; count++; } if (count && compute_percentiles(decileResult, decilePoint, 2, statWorkArray, count)) outputData[row] = decileResult[1] - decileResult[0]; } break; case SET_QRANGE: for (row=0; row<rows; row++) { for (iColumn=count=value1=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; statWorkArray[count] = inputData[iColumn][row]; count++; } if (count && compute_percentiles(quartileResult, quartilePoint, 2, statWorkArray, count)) outputData[row] = quartileResult[1] - quartileResult[0]; } break; case SET_SMALLEST: for (row=0; row<rows; row++) { value1 = DBL_MAX; posColIndex = 0; posColumnName[row] = NULL; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; if ((value2=fabs(inputData[iColumn][row]))<value1) { posColIndex = iColumn; value1 = value2; } } outputData[row] = value1; if (stat[iStat].positionColumn) posColumnName[row] = stat[iStat].sourceColumn[posColIndex]; } break; case SET_LARGEST: for (row=0; row<rows; row++) { value1 = 0; posColIndex = 0; posColumnName[row] = NULL; for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; if ((value2=fabs(inputData[iColumn][row]))>value1) { posColIndex = iColumn; value1 = value2; } } outputData[row] = value1; if (stat[iStat].positionColumn) posColumnName[row] = stat[iStat].sourceColumn[posColIndex]; } break; case SET_SPREAD: for (row=0; row<rows; row++) { value1 = DBL_MAX; /* min */ value2 = -DBL_MAX; /* max */ for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; if (inputData[iColumn][row]<value1) value1 = inputData[iColumn][row]; if (inputData[iColumn][row]>value2) value2 = inputData[iColumn][row]; } outputData[row] = value2-value1; } break; case SET_PERCENTILE: for (row=0; row<rows; row++) { for (iColumn=count=value1=0; iColumn<stat[iStat].sourceColumns; iColumn++) { if (stat[iStat].flags&TOPLIMIT_GIVEN && inputData[iColumn][row]>stat[iStat].topLimit) continue; if (stat[iStat].flags&BOTTOMLIMIT_GIVEN && inputData[iColumn][row]<stat[iStat].bottomLimit) continue; statWorkArray[count] = inputData[iColumn][row]; count++; } outputData[row] = HUGE_VAL; if (count) compute_percentiles(&outputData[row], &stat[iStat].percent, 1, statWorkArray, count); } break; default: SDDS_Bomb("invalid statistic code (accumulation loop)"); break; } if (!SDDS_SetColumn(&outData, SDDS_SET_BY_INDEX, outputData, rows, stat[iStat].resultIndex)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (stat[iStat].positionColumn) { if (!SDDS_SetColumn(&outData, SDDS_SET_BY_INDEX, posColumnName, rows, stat[iStat].positionColumnIndex)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) free(inputData[iColumn]); free(inputData); inputData = NULL; } free(outputData); outputData = NULL; free(posColumnName); posColumnName = NULL; } if (!SDDS_WritePage(&outData)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } free_scanargs(&scanned, argc); for (iStat=0; iStat<stats; iStat++) { if (stat[iStat].positionColumn) free(stat[iStat].positionColumn); for (iColumn=0; iColumn<stat[iStat].sourceColumns; iColumn++) free(stat[iStat].sourceColumn[iColumn]); free(stat[iStat].sourceColumn); } free(request); free(stat); if (statWorkArray) free(statWorkArray); if (!SDDS_Terminate(&inData) || !SDDS_Terminate(&outData)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (tmpFileUsed && !replaceFileAndBackUp(input, output)) exit(1); return 0; }
int /* O - Exit status */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ int ras_fd, /* File descriptor for read process */ status; /* Exit status of read process */ double start_secs, /* Start time */ write_secs, /* Write time */ read_secs, /* Read time */ pass_secs[TEST_PASSES]; /* Total test times */ cups_mode_t mode; /* Write mode */ /* * See if we have anything on the command-line... */ if (argc > 2 || (argc == 2 && strcmp(argv[1], "-z"))) { puts("Usage: rasterbench [-z]"); return (1); } mode = argc > 1 ? CUPS_RASTER_WRITE_COMPRESSED : CUPS_RASTER_WRITE; /* * Ignore SIGPIPE... */ signal(SIGPIPE, SIG_IGN); /* * Run the tests several times to get a good average... */ printf("Test read/write speed of %d pages, %dx%d pixels...\n\n", TEST_PAGES, TEST_WIDTH, TEST_HEIGHT); for (i = 0; i < TEST_PASSES; i ++) { printf("PASS %2d: ", i + 1); fflush(stdout); ras_fd = run_read_test(); start_secs = get_time(); write_test(ras_fd, mode); write_secs = get_time(); printf(" %.3f write,", write_secs - start_secs); fflush(stdout); close(ras_fd); wait(&status); read_secs = get_time(); pass_secs[i] = read_secs - start_secs; printf(" %.3f read, %.3f total\n", read_secs - write_secs, pass_secs[i]); } printf("\nMedian Total Time: %.3f seconds per document\n", compute_median(pass_secs)); return (0); }