int main(int argc, char *argv[]) { char *filename="test.sdds"; char outfile[256]; SDDS_DATASET SDDS_in, SDDS_out; MPI_DATASET *MPI_in, *MPI_out; int mpi_code, page=0, n_processors, myid; int32_t rows, columnOrder=0; double startTime = 0; MPI_Comm comm; filename = argv[1]; if (argc>2) sscanf(argv[2], "%d", &columnOrder); if (argc>3) sprintf(outfile, "%s", argv[3]); MPI_Init(&argc,&argv); /* 1. set the communicator for MPI IO */ comm = MPI_COMM_WORLD; if (MPI_SUCCESS != (mpi_code=MPI_Comm_rank(comm, &myid))) SDDS_MPI_GOTO_ERROR(stderr, "MPI_Comm_rank failed", mpi_code, 1); if (MPI_SUCCESS != (mpi_code=MPI_Comm_size(comm, &n_processors))) SDDS_MPI_GOTO_ERROR(stderr, "MPI_Comm_size failed", mpi_code, 1); SDDS_MPI_Setup(&SDDS_in, 1, n_processors, myid, comm, 1); SDDS_MPI_Setup(&SDDS_out, 1, n_processors, myid, comm, 1); MPI_in = SDDS_in.MPI_dataset; MPI_out = SDDS_out.MPI_dataset; startTime = MPI_Wtime(); if (MPI_in->myid==0) fprintf(stderr,"inputfile=%s, copy file=%s\n", filename, outfile); /* 2. open file (all processors) */ fprintf(stderr, "columnorder %d\n", columnOrder); if (!SDDS_MPI_InitializeInput(&SDDS_in, filename)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); fprintf(stderr, "initialized input.\n"); /*write to another file for comparison*/ if (!SDDS_MPI_InitializeCopy(&SDDS_out, &SDDS_in, outfile, columnOrder)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); return 0; } while (SDDS_ReadPage(&SDDS_in)>0) { page++; rows = SDDS_CountRowsOfInterest(&SDDS_in); if (!SDDS_CopyPage(&SDDS_out, &SDDS_in)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_WritePage(&SDDS_out)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_Terminate(&SDDS_in) || !SDDS_Terminate(&SDDS_out)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (MPI_in->myid==0) fprintf(stderr,"Time spent=%f\n", MPI_Wtime()-startTime); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { SCANNED_ARG *scanned; SDDS_TABLE inputPage, outputPage, residualPage; char *inputfile, *outputfile; char **column, **excludeColumn; int32_t columns; long excludeColumns; char *indColumnName; long verbose; long iArg, i, j, ipage; double *indVar, *indVarOrig; char *indVarUnits; char **intColumn, **slopeColumn, **slopeSigmaColumn, **interceptSigmaColumn; char *Units,*slopeUnits; double *depVar, *depVarOrig; long order; double *coef, *coefsigma, *weight, *diff, *diffOrig, chi; long iCol, iRow; long rows, rowsOrig; double rmsResidual; double slopeSigma, interceptSigma; char **sigmaColumn, **chiSquaredColumn; long *sigmaColumnExists; long doSlopeSigma, generateSigma, doPreliminaryFit; long validSigmas; double sigmaSum, averageSigma; long ascii; char *residualFile; unsigned long pipeFlags; long tmpfile_used, noWarnings; double xMin, xMax; indVar = indVarOrig = depVar = depVarOrig = coef = coefsigma = weight = diff = NULL; intColumn = slopeColumn = slopeSigmaColumn = interceptSigmaColumn = sigmaColumn = chiSquaredColumn = NULL; slopeUnits = NULL; sigmaColumnExists = NULL; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scanned, argc, argv); if (argc == 1) bomb(NULL, USAGE); inputfile = outputfile = NULL; columns = excludeColumns = 0; column = excludeColumn = NULL; indColumnName = NULL; verbose = 0; doSlopeSigma = 0; generateSigma = 0; doPreliminaryFit = 0; ascii = 0; pipeFlags = 0; tmpfile_used=0; noWarnings=0; residualFile = NULL; xMin = xMax = 0; for (iArg = 1; iArg<argc; iArg++) { if (scanned[iArg].arg_type == OPTION) { delete_chars(scanned[iArg].list[0], "_"); switch (match_string(scanned[iArg].list[0], commandline_option, COMMANDLINE_OPTIONS, UNIQUE_MATCH)) { case CLO_INDEPENDENT_COLUMN: if (!(indColumnName = scanned[iArg].list[1])) SDDS_Bomb("no string given for option -independentVariable"); break; case CLO_COLUMNS: if (columns) SDDS_Bomb("only one -columns option may be given"); if (scanned[iArg].n_items<2) SDDS_Bomb("invalid -columns syntax"); column = tmalloc(sizeof(*column)*(columns = scanned[iArg].n_items-1)); for (i = 0; i<columns; i++) column[i] = scanned[iArg].list[i+1]; break; case CLO_EXCLUDE: if (excludeColumns) SDDS_Bomb("only one -excludecolumns option may be given"); if (scanned[iArg].n_items<2) SDDS_Bomb("invalid -excludecolumns syntax"); excludeColumn = tmalloc(sizeof(*excludeColumn)*(excludeColumns = scanned[iArg].n_items-1)); for (i = 0; i<excludeColumns; i++) excludeColumn[i] = scanned[iArg].list[i+1]; break; case CLO_VERBOSE: verbose = 1; break; case CLO_ASCII: ascii = 1; break; case CLO_PIPE: if (!processPipeOption(scanned[iArg].list+1, scanned[iArg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case CLO_SIGMA: doSlopeSigma = 1; if (scanned[iArg].n_items > 1 ) { switch (match_string(scanned[iArg].list[1], sigma_option, SIGMA_OPTIONS, UNIQUE_MATCH)) { case SIGMA_GENERATE: generateSigma = 1; break; default: SDDS_Bomb("unrecognized sigma option given"); break; } } break; case CLO_RESIDUAL: if (!(residualFile=scanned[iArg].list[1])){ fprintf(stderr,"No file specified in -residual option.\n"); exit(1); } break; case CLO_RANGE: if (scanned[iArg].n_items!=3 || 1!=sscanf(scanned[iArg].list[1], "%lf", &xMin) || 1!=sscanf(scanned[iArg].list[2], "%lf", &xMax) || xMin>=xMax) SDDS_Bomb("incorrect -range syntax"); break; default: SDDS_Bomb("unrecognized option given"); break; } } else { if (!inputfile) inputfile = scanned[iArg].list[0]; else if (!outputfile) outputfile = scanned[iArg].list[0]; else SDDS_Bomb("too many filenames given"); } } if (residualFile && outputfile) { if (!strcmp( residualFile, outputfile)) { fprintf( stderr, "Residual file can't be the same as the output file.\n"); exit(1); } } processFilenames("sddsslopes", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used); if (!indColumnName) { fprintf( stderr, "independentVariable not given\n"); exit(1); } if (!excludeColumns) { excludeColumn = defaultExcludedColumn; excludeColumns = DEFAULT_EXCLUDED_COLUMNS; } if (verbose) fprintf(stderr,"Reading file %s.\n",inputfile); if ( !SDDS_InitializeInput( &inputPage, inputfile) ) SDDS_PrintErrors( stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); while (0 < (ipage=SDDS_ReadTable( &inputPage))) { if (verbose) { fprintf(stderr, "working on page %ld\n", ipage); } rows = SDDS_CountRowsOfInterest(&inputPage); rowsOrig = rows; /*************************************\ * make array of independent variable \*************************************/ if (ipage==1) { indVar = (double*) malloc( sizeof(*indVar) * rows); } else { indVar = (double*) realloc( indVar, sizeof(*indVar) * rows); } if (ipage==1) { if (!SDDS_FindColumn(&inputPage, FIND_NUMERIC_TYPE, indColumnName, NULL)){ fprintf(stderr,"Something wrong with column %s.\n", indColumnName); SDDS_CheckColumn(&inputPage, indColumnName, NULL, SDDS_ANY_NUMERIC_TYPE, stderr); exit(1); } } /* filter out the specified range in independent variable */ if (xMin!=xMax) { if (!(indVarOrig = SDDS_GetColumnInDoubles( &inputPage, indColumnName))) SDDS_PrintErrors( stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); for (i=j=0; i<rowsOrig; i++) { if (indVarOrig[i]<=xMax && indVarOrig[i]>=xMin) { indVar[j] = indVarOrig[i]; j++; } } rows = j; } else { if (!(indVar = SDDS_GetColumnInDoubles( &inputPage, indColumnName))) SDDS_PrintErrors( stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } if ( ipage == 1 ) { if (!SDDS_GetColumnInformation(&inputPage, "units", &indVarUnits, SDDS_GET_BY_NAME, indColumnName)) SDDS_PrintErrors( stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!indVarUnits) { indVarUnits = (char *) malloc(sizeof(*indVarUnits)); indVarUnits[0] = 0; } } /************************************\ * initialize residual file \************************************/ if (residualFile) { if ( ipage == 1 ) { if(!SDDS_InitializeOutput(&residualPage,ascii?SDDS_ASCII:SDDS_BINARY,1, "Residual of 2-term fit",NULL,outputfile) || !SDDS_InitializeCopy(&residualPage, &inputPage, residualFile, "w") || !SDDS_WriteLayout(&residualPage) ) SDDS_PrintErrors(stderr,SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_CopyPage(&residualPage,&inputPage)) SDDS_PrintErrors(stderr,SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /************************************\ * get columns of interest. use set_multicolumn_flags to simply * return new values for array column. \*************************************/ if (!set_multicolumn_flags(&inputPage, &column, &columns, excludeColumn, excludeColumns)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } /************************************\ * make column names for the output \*************************************/ if (ipage==1) { intColumn = (char**) malloc((sizeof(char*)*columns)); slopeColumn = (char**) malloc((sizeof(char*)*columns)); if (doSlopeSigma) { slopeSigmaColumn = (char**) malloc((sizeof(char*)*columns)); interceptSigmaColumn = (char**) malloc((sizeof(char*)*columns)); chiSquaredColumn = (char**) malloc((sizeof(char*)*columns)); } for (i=0; i<columns; i++) { intColumn[i] = (char*) malloc((sizeof(char)*(strlen(column[i])+strlen("Intercept")+1))); strcat(strcpy(intColumn[i], column[i]), "Intercept"); slopeColumn[i] = (char*) malloc((sizeof(char)*(strlen(column[i])+strlen("Slope")+1))); strcat(strcpy(slopeColumn[i], column[i]), "Slope"); if (doSlopeSigma) { slopeSigmaColumn[i] = (char*) malloc((sizeof(char)*(strlen(column[i])+strlen("SlopeSigma")+1))); strcat(strcpy(slopeSigmaColumn[i], column[i]), "SlopeSigma"); interceptSigmaColumn[i] = (char*) malloc((sizeof(char)*(strlen(column[i])+strlen("InterceptSigma")+1))); strcat(strcpy(interceptSigmaColumn[i], column[i]), "InterceptSigma"); chiSquaredColumn[i] = (char*) malloc((sizeof(char)*(strlen(column[i])+strlen("ChiSquared")+1))); strcat(strcpy(chiSquaredColumn[i], column[i]), "ChiSquared"); } } } /************************************\ * Write layout for output file \*************************************/ if (ipage==1) { if (verbose) fprintf(stderr,"Opening file %s.\n",outputfile); if(!SDDS_InitializeOutput(&outputPage,ascii?SDDS_ASCII:SDDS_BINARY,1, "2-term fit",NULL,outputfile) || 0>SDDS_DefineParameter(&outputPage, "InputFile", "InputFile", NULL, "InputFile", NULL, SDDS_STRING, 0) || 0>SDDS_DefineColumn(&outputPage, "IndependentVariable", NULL, NULL, NULL, NULL, SDDS_STRING,0) ) SDDS_PrintErrors(stderr,SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for (iCol=0; iCol<columns; iCol++) { if (!SDDS_GetColumnInformation(&inputPage, "units", &Units, SDDS_GET_BY_NAME, column[iCol])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!Units) { Units = (char*) malloc(sizeof(*Units)); Units[0] = 0; } if (0>SDDS_DefineColumn(&outputPage, intColumn[iCol], NULL, Units, NULL, NULL, SDDS_DOUBLE,0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /* units for slopes columns */ if (strlen(indVarUnits) && strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)*(strlen(Units)+strlen(indVarUnits)+2)); strcat( strcat( strcpy(slopeUnits, Units), "/"), indVarUnits); } if (strlen(indVarUnits) && !strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)*(strlen(indVarUnits)+2)); strcat( strcpy( slopeUnits, "1/"), indVarUnits); } if (!strlen(indVarUnits) && strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)*(strlen(Units)+2)); strcpy( slopeUnits, indVarUnits); } if (!strlen(indVarUnits) && !strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)); strcpy( slopeUnits, ""); } if (0>SDDS_DefineColumn(&outputPage, slopeColumn[iCol], NULL, slopeUnits, NULL, NULL, SDDS_DOUBLE,0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (doSlopeSigma) { if (0>SDDS_DefineColumn(&outputPage, interceptSigmaColumn[iCol], NULL, Units, NULL, NULL, SDDS_DOUBLE,0) || 0>SDDS_DefineColumn(&outputPage, slopeSigmaColumn[iCol], NULL, slopeUnits, NULL, NULL, SDDS_DOUBLE,0) || 0>SDDS_DefineColumn(&outputPage, chiSquaredColumn[iCol], NULL, NULL, NULL, NULL, SDDS_DOUBLE,0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } free(slopeUnits); } if ( !SDDS_WriteLayout(&outputPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if ( !SDDS_StartTable(&outputPage,1) || !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "InputFile",inputfile?inputfile:"pipe",NULL) || !SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, 0, "IndependentVariable", indColumnName, NULL) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /* determine which included columns has a Sigma column defined in the input file */ if ( ipage == 1 ) { sigmaColumn = (char **) malloc( sizeof(*sigmaColumn)*columns); sigmaColumnExists = (long *) malloc(columns*sizeof(*sigmaColumnExists)); for (iCol=0; iCol<columns; iCol++) { sigmaColumn[iCol] = (char *) malloc( sizeof(**sigmaColumn) * (strlen(column[iCol]) + strlen("Sigma") + 1) ); strcat( strcpy(sigmaColumn[iCol], column[iCol]), "Sigma"); switch(SDDS_CheckColumn(&inputPage, sigmaColumn[iCol], NULL, SDDS_DOUBLE, NULL)) { case SDDS_CHECK_WRONGUNITS: case SDDS_CHECK_OKAY: sigmaColumnExists[iCol] = 1; break; default: /* try other possible spelling */ strcat( strcpy(sigmaColumn[iCol] ,"Sigma"), column[iCol]); switch(SDDS_CheckColumn(&inputPage, sigmaColumn[iCol], NULL, SDDS_DOUBLE, NULL)) { case SDDS_CHECK_WRONGUNITS: case SDDS_CHECK_OKAY: sigmaColumnExists[iCol] = 1; break; default: sigmaColumnExists[iCol] = 0; } break; } } } if ( ipage == 1 ) { weight = (double*)malloc(sizeof(*weight)*rows); diff = (double*)malloc(sizeof(*diff)*rows); order=1; coef = (double*)malloc(sizeof(*coef)*(order+1)); coefsigma = (double*)malloc(sizeof(*coefsigma)*(order+1)); } else { weight = (double*)realloc( weight, sizeof(*weight)*rows); diff = (double*)realloc( diff, sizeof(*diff)*rows); order=1; coef = (double*)realloc( coef, sizeof(*coef)*(order+1)); coefsigma = (double*)realloc( coefsigma, sizeof(*coefsigma)*(order+1)); } if (ipage==1) { depVar = (double*) malloc( sizeof(*depVar) * rows); } else { depVar = (double*) realloc( depVar, sizeof(*depVar) * rows); } for (iCol=0; iCol<columns; iCol++) { if (verbose) fprintf(stderr,"Doing column %s.\n", column[iCol]); /* filter out the specified range in independent variable */ if (xMin!=xMax) { if (!(depVarOrig = (double*) SDDS_GetColumnInDoubles(&inputPage, column[iCol]))) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); for (i=j=0; i<rowsOrig; i++) { if ( xMin <= indVarOrig[i] && indVarOrig[i] <= xMax ) { depVar[j] = depVarOrig[i]; j++; } } } else { if (!(depVar=SDDS_GetColumnInDoubles(&inputPage, column[iCol]))) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } /********************* three possibilities: 1) don't do or write slope errors. (doSlopeSigma=0) do one lsf call with all weights = 1 2) calculated slope errors from sigma columns in the input file. (doSlopeSigma=1 && generateSigma=0 && sigmaColumnExists[iCol]=1 ) do one lsf call with weights from sigma columns 3) calculate slope errors from generated sigma from a preliminary fit. (doSlopeSigma=1 && (generateSigma=1 || sigmaColumnExists[iCol]=NULL) do preliminary fit to generate sigma *********************/ for (iRow=0; iRow<rows; iRow++) weight[iRow] = 1; if (doSlopeSigma) { /********************* check validity of sigma column values *********************/ if( !generateSigma && sigmaColumnExists[iCol]) { if (verbose) fprintf(stderr,"\tUsing column %s for sigma.\n",sigmaColumn[iCol]); if(!(weight=SDDS_GetColumnInDoubles(&inputPage, sigmaColumn[iCol]))) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); /* check for zero weight values which will give lsfn problems */ validSigmas = rows; sigmaSum = 0; for (iRow=0; iRow<rows; iRow++) { sigmaSum += weight[iRow]; if(!weight[iRow]) { validSigmas--; /* fprintf(stderr,"Warning: %s of row number %ld is zero. Using average sigma.\n",sigmaColumn[iCol],iRow); */ } } if (!validSigmas) { fprintf(stderr,"Warning: All sigmas are zero.\n"); doPreliminaryFit = 1; } else if (validSigmas!=rows) { /* fix some sigmas */ averageSigma = sigmaSum/ validSigmas; fprintf(stderr, "Warning: replacing %ld invalid sigmas with average (%e)\n", rows-validSigmas, averageSigma); for (iRow=0; iRow<rows; iRow++) { if(!weight[iRow]) { weight[iRow] = averageSigma; } } } } else { doPreliminaryFit = 1; } } if (doPreliminaryFit) { if (verbose) fprintf(stderr,"\tGenerating sigmas from rms residual of a preliminary fit.\n"); if (!(lsfn(indVar, depVar, weight, rows, order, coef, coefsigma, &chi, diff))){ fprintf(stderr,"Problem with call to lsfn\n."); exit(1); } rmsResidual = 0; /* calculate rms residual */ for (iRow=0; iRow<rows; iRow++) { rmsResidual += sqr(diff[iRow]); } rmsResidual = sqrt(rmsResidual/(rows)); for (iRow=0; iRow<rows; iRow++) { weight[iRow] = rmsResidual; } } if (!(lsfn(indVar, depVar, weight, rows, order, coef, coefsigma, &chi, diff))) { fprintf(stderr,"Problem with call to lsfn\n."); exit(1); } if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, 0, intColumn[iCol], coef[0], slopeColumn[iCol], coef[1], NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (doSlopeSigma) { interceptSigma = coefsigma[0]; slopeSigma = coefsigma[1]; if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, 0, chiSquaredColumn[iCol], chi, interceptSigmaColumn[iCol], interceptSigma, slopeSigmaColumn[iCol], slopeSigma, NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (residualFile) { if (xMin!=xMax) { /* calculate the residuals for the whole column explicitly since there are points outside the range of which the lsf call did not calculate the difference. */ diffOrig = (double*) malloc( rowsOrig * sizeof(double) ); for (i=0; i<rowsOrig; i++) { diffOrig[i] = depVarOrig[i] - coef[0] - coef[1] * indVarOrig[i]; } if( !SDDS_SetColumnFromDoubles(&residualPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, diffOrig,rowsOrig,column[iCol])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if( !SDDS_SetColumnFromDoubles(&residualPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, diff,rows,column[iCol])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } } if (residualFile) { if (!SDDS_WriteTable(&residualPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_WriteTable(&outputPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (residualFile) { if (!SDDS_Terminate(&residualPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if(!SDDS_Terminate(&inputPage) || !SDDS_Terminate(&outputPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile)) exit(1); return(0); }
int main(int argc, char **argv) { SDDS_DATASET inSet, outSet; SCANNED_ARG *s_arg; long i_arg, pageReturned, rows, row; int32_t *rowFlag; char *input, *output, *columnName, *par_thresholdName; double *data; unsigned long pipeFlags, flags; double threshold, ezoneFraction, changeThreshold; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc<2 || argc>(2+N_OPTIONS)) bomb(NULL, USAGE); flags = pipeFlags = 0; input = output = NULL; columnName = NULL; ezoneFraction = changeThreshold = 0; rowFlag = NULL; par_thresholdName=NULL; for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) { case CLO_THRESHOLD: if (s_arg[i_arg].n_items==2) { if (s_arg[i_arg].list[1][0]=='@' ) { SDDS_CopyString(&par_thresholdName, s_arg[i_arg].list[1]+1); flags |= PAR_THRESHOLD; } else { if (sscanf(s_arg[i_arg].list[1], "%lf", &threshold)!=1) SDDS_Bomb("incorrect -threshold syntax"); flags |= THRESHOLD; } } else SDDS_Bomb("incorrect -threshold syntax"); break; case CLO_FIVEPOINT: flags |= FIVEPOINT; break; case CLO_CHANGETHRESHOLD: if (s_arg[i_arg].n_items!=2 || sscanf(s_arg[i_arg].list[1], "%lf", &changeThreshold)!=1 || changeThreshold<=0) SDDS_Bomb("incorrect -changeThreshold syntax or values"); flags |= CHANGETHRES; break; case CLO_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case CLO_COLUMN: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -column syntax"); columnName = s_arg[i_arg].list[1]; break; case CLO_EXCLUSIONZONE: if (s_arg[i_arg].n_items!=2 || sscanf(s_arg[i_arg].list[1], "%lf", &ezoneFraction)!=1 || ezoneFraction<=0) SDDS_Bomb("invalid -exclusionZone syntax or value"); flags |= EZONEFRAC; break; default: fprintf(stderr, "error: unknown/ambiguous option: %s\n", s_arg[i_arg].list[0]); exit(1); break; } } else { if (input==NULL) input = s_arg[i_arg].list[0]; else if (output==NULL) output = s_arg[i_arg].list[0]; else SDDS_Bomb("too many filenames"); } } processFilenames("sddspeakfind", &input, &output, pipeFlags, 0, NULL); if (!columnName) SDDS_Bomb("-column option must be given"); if (!SDDS_InitializeInput(&inSet, input)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_FindColumn(&inSet, FIND_NUMERIC_TYPE, columnName, NULL)) SDDS_Bomb("the given column is nonexistent or nonnumeric"); if (!SDDS_InitializeCopy(&outSet, &inSet, output, "w") || !SDDS_WriteLayout(&outSet)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); while ((pageReturned=SDDS_ReadPage(&inSet))>0) { if (!SDDS_CopyPage(&outSet, &inSet)) { SDDS_SetError("Problem copying data for output file"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if ((rows=SDDS_CountRowsOfInterest(&outSet))>1) { if (!(data = SDDS_GetColumnInDoubles(&inSet, columnName))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); rowFlag = SDDS_Realloc(rowFlag, sizeof(*rowFlag)*rows); for (row=0; row<rows; row++) rowFlag[row] = 0; markPeaks(data, rowFlag, rows, flags&FIVEPOINT); if (flags&PAR_THRESHOLD) { if (!SDDS_GetParameter(&inSet,par_thresholdName,&threshold)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (flags&THRESHOLD || flags&PAR_THRESHOLD ) { for (row=0; row<rows; row++) if (rowFlag[row] && data[row]<threshold) rowFlag[row] = 0; } if (flags&CHANGETHRES) unmarkFlatPeaks(data, rowFlag, rows, changeThreshold, flags&FIVEPOINT); if (flags&EZONEFRAC) unmarkExcludedPeaks(data, rowFlag, rows, ezoneFraction); if (!SDDS_AssertRowFlags(&outSet, SDDS_FLAG_ARRAY, rowFlag, rows)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(data); } if (!SDDS_WritePage(&outSet)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_Terminate(&inSet) || !SDDS_Terminate(&outSet)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } free_scanargs(&s_arg,argc); if (par_thresholdName) free(par_thresholdName); if (rowFlag) free(rowFlag); return(0); }
int main(int argc, char **argv) { int iArg; char **outputColumn, **difColumn; char *indepColumn, **depenColumn, **exclude; long depenColumns, excludes; char *input, *output; long i, rows, readCode, optionCode; unsigned long flags, pipeFlags; SCANNED_ARG *scanned; SDDS_DATASET SDDSin, SDDSout; double *timeData, *inputData, *outputData; FILTER_STAGE *filterStage; long filterStages, totalFilters; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scanned, argc, argv); if (argc<3 || argc>(3+N_OPTIONS)) bomb(NULL, USAGE); output = input = NULL; flags = pipeFlags = 0; indepColumn = NULL; depenColumn = exclude = NULL; depenColumns = excludes = 0; if (!(filterStage = (FILTER_STAGE*)calloc(1, sizeof(*filterStage)))) SDDS_Bomb("allocation failure"); filterStage->filter = NULL; filterStage->filters = 0; filterStages = 1; totalFilters = 0; for (iArg=1; iArg<argc; iArg++) { if (scanned[iArg].arg_type==OPTION) { /* process options here */ switch (optionCode=match_string(scanned[iArg].list[0], option, N_OPTIONS, 0)) { case SET_PIPE: if (!processPipeOption(scanned[iArg].list+1, scanned[iArg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case SET_COLUMNS: if (indepColumn) SDDS_Bomb("only one -columns option may be given"); if (scanned[iArg].n_items<2) SDDS_Bomb("invalid -columns syntax"); indepColumn = scanned[iArg].list[1]; if (scanned[iArg].n_items>=2) { depenColumn = tmalloc(sizeof(*depenColumn)*(depenColumns=scanned[iArg].n_items-2)); for (i=0; i<depenColumns; i++) depenColumn[i] = scanned[iArg].list[i+2]; } break; case SET_THRESHOLD: case SET_HIGHPASS: case SET_LOWPASS: case SET_NOTCH: case SET_BANDPASS: case SET_FILTERFILE: case SET_CLIPFREQ: addFilter(filterStage+filterStages-1, optionCode, scanned+iArg); totalFilters++; break; case SET_CASCADE: if (filterStages==0) SDDS_Bomb("-cascade option precedes all filter definitions"); if (!(filterStage = SDDS_Realloc(filterStage, (filterStages+1)*sizeof(*filterStage)))) SDDS_Bomb("allocation failure"); filterStage[filterStages].filter = NULL; filterStage[filterStages].filters = 0; filterStages++; break; case SET_NEWCOLUMNS: flags |= FL_NEWCOLUMNS; break; case SET_DIFFERENCECOLUMNS: flags |= FL_DIFCOLUMNS; break; case SET_EXCLUDE: if (scanned[iArg].n_items<2) SDDS_Bomb("invalid -exclude syntax"); moveToStringArray(&exclude, &excludes, scanned[iArg].list+1, scanned[iArg].n_items-1); break; default: fprintf(stderr, "error: unknown/ambiguous option: %s (%s)\n", scanned[iArg].list[0], argv[0]); exit(1); break; } } else { if (!input) input = scanned[iArg].list[0]; else if (!output) output = scanned[iArg].list[0]; else SDDS_Bomb("too many filenames seen"); } } processFilenames("sddsfdfilter", &input, &output, pipeFlags, 0, NULL); if (!totalFilters) fputs("warning: no filters specified (sddsfdfilter)\n", stderr); if (!indepColumn) SDDS_Bomb("supply the independent column name with the -columns option"); if (!SDDS_InitializeInput(&SDDSin, input)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (SDDS_CheckColumn(&SDDSin, indepColumn, NULL, SDDS_ANY_NUMERIC_TYPE, stderr)!=SDDS_CHECK_OKAY) exit(1); excludes = appendToStringArray(&exclude, excludes, indepColumn); if (!depenColumns) depenColumns = appendToStringArray(&depenColumn, depenColumns, "*"); if ((depenColumns=expandColumnPairNames(&SDDSin, &depenColumn, NULL, depenColumns, exclude, excludes, FIND_NUMERIC_TYPE, 0))<=0) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); SDDS_Bomb("No quantities selected to filter"); } if (!SDDS_InitializeCopy(&SDDSout, &SDDSin, output, "w")) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (flags&FL_NEWCOLUMNS) { outputColumn = tmalloc(sizeof(*outputColumn)*depenColumns); for (i=0; i<depenColumns; i++) { outputColumn[i] = tmalloc(sizeof(**outputColumn)*(strlen(depenColumn[i])+1+strlen("Filtered"))); sprintf(outputColumn[i], "%sFiltered", depenColumn[i]); if (!SDDS_TransferColumnDefinition(&SDDSout, &SDDSin, depenColumn[i], outputColumn[i])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } else outputColumn=depenColumn; difColumn = NULL; if (flags&FL_DIFCOLUMNS) { difColumn = tmalloc(sizeof(*difColumn)*depenColumns); for (i=0; i<depenColumns; i++) { difColumn[i] = tmalloc(sizeof(**difColumn)*(strlen(depenColumn[i])+1+strlen("Difference"))); sprintf(difColumn[i], "%sDifference", depenColumn[i]); if (!SDDS_TransferColumnDefinition(&SDDSout, &SDDSin, depenColumn[i], difColumn[i])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (!SDDS_WriteLayout(&SDDSout)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); outputData = NULL; while ((readCode=SDDS_ReadPage(&SDDSin))>0) { if (!SDDS_CopyPage(&SDDSout, &SDDSin)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if ((rows = SDDS_CountRowsOfInterest(&SDDSin))<0) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (rows) { if (!(timeData = SDDS_GetColumnInDoubles(&SDDSin, indepColumn))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!(outputData = SDDS_Realloc(outputData, sizeof(*outputData)*rows))) SDDS_Bomb("allocation failure"); for (i=0; i<depenColumns; i++) { if (!(inputData = SDDS_GetColumnInDoubles(&SDDSin, depenColumn[i]))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!applyFilters(outputData, inputData, timeData, rows, filterStage, filterStages)) exit(1); if (!SDDS_SetColumnFromDoubles(&SDDSout, SDDS_BY_NAME, outputData, rows, outputColumn[i])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (flags&FL_DIFCOLUMNS) { long j; for (j=0; j<rows; j++) outputData[j] = inputData[j] - outputData[j]; if (!SDDS_SetColumnFromDoubles(&SDDSout, SDDS_BY_NAME, outputData, rows, difColumn[i])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } free(inputData); } free(timeData); } if (!SDDS_WritePage(&SDDSout)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } free(outputData); for(i=0;i<depenColumns;i++) { free(depenColumn[i]); if (flags&FL_NEWCOLUMNS) free(outputColumn[i]); if (flags&FL_DIFCOLUMNS) free(difColumn[i]); } for(i=0;i<excludes;i++) free(exclude[i]); free(indepColumn); if (flags&FL_NEWCOLUMNS) free(outputColumn); free(depenColumn); if (flags&FL_DIFCOLUMNS) free(difColumn); free(exclude); for(i=0;i<filterStages;i++) { long j; for(j=0;j<filterStage[i].filters;j++) { switch (filterStage[i].filter[j].filterType) { case SET_FILTERFILE : free( ((FILE_FILTER*) (filterStage[i].filter[j].filter))->freqData); free( ((FILE_FILTER*) (filterStage[i].filter[j].filter))->magData); free( ((FILE_FILTER*) (filterStage[i].filter[j].filter))->imagData); free( ((FILE_FILTER*) (filterStage[i].filter[j].filter))->realData); break; default : break; } } } if (!SDDS_Terminate(&SDDSout) || !SDDS_Terminate(&SDDSin)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); return 0; }
int main(int argc, char **argv) { POLYNOMIAL *poly; long nPoly, iPoly, row, rows, iInput; int iArg; char *input, *output; unsigned long pipeFlags; SCANNED_ARG *scanned; SDDS_DATASET SDDSin, SDDSout; double *outputData ; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scanned, argc, argv); if (argc<3) bomb(NULL, USAGE); outputData = NULL; input = output = NULL; pipeFlags = 0; poly = NULL; nPoly = 0; for (iArg=1; iArg<argc; iArg++) { if (scanned[iArg].arg_type==OPTION) { /* process options here */ switch (match_string(scanned[iArg].list[0], option, CLO_OPTIONS, 0)) { case CLO_EVALUATE: if (!(poly = SDDS_Realloc(poly, sizeof(*poly)*(nPoly+1))) || !(poly[nPoly].inputColumn =SDDS_Malloc(sizeof(*(poly[nPoly].inputColumn))*5)) || !(poly[nPoly].powerColumn =SDDS_Malloc(sizeof(*(poly[nPoly].powerColumn))*5))) SDDS_Bomb("memory allocation failure"); scanned[iArg].n_items -= 1; if (!scanItemList(&poly[nPoly].flags, scanned[iArg].list+1, &scanned[iArg].n_items, 0, "filename", SDDS_STRING, &(poly[nPoly].filename), 1, POLY_FILE_SEEN, "output", SDDS_STRING, &(poly[nPoly].outputColumn), 1, POLY_OUTPUT_SEEN, "coefficients", SDDS_STRING, &(poly[nPoly].coefColumn), 1, POLY_COEF_SEEN, "input0", SDDS_STRING, poly[nPoly].inputColumn+0, 1, POLY_IN0_SEEN, "power0", SDDS_STRING, poly[nPoly].powerColumn+0, 1, POLY_OUT0_SEEN, "input1", SDDS_STRING, poly[nPoly].inputColumn+1, 1, POLY_IN1_SEEN, "power1", SDDS_STRING, poly[nPoly].powerColumn+1, 1, POLY_OUT1_SEEN, "input2", SDDS_STRING, poly[nPoly].inputColumn+2, 1, POLY_IN2_SEEN, "power2", SDDS_STRING, poly[nPoly].powerColumn+2, 1, POLY_OUT2_SEEN, "input3", SDDS_STRING, poly[nPoly].inputColumn+3, 1, POLY_IN3_SEEN, "power3", SDDS_STRING, poly[nPoly].powerColumn+3, 1, POLY_OUT3_SEEN, "input4", SDDS_STRING, poly[nPoly].inputColumn+4, 1, POLY_IN4_SEEN, "power4", SDDS_STRING, poly[nPoly].powerColumn+4, 1, POLY_OUT4_SEEN, NULL) || !(poly[nPoly].flags&POLY_FILE_SEEN) || !(poly[nPoly].flags&POLY_OUTPUT_SEEN) || !(poly[nPoly].flags&POLY_COEF_SEEN) || !(poly[nPoly].flags&POLY_IN0_SEEN) || !(poly[nPoly].flags&POLY_OUT0_SEEN)) SDDS_Bomb("invalid -evaluate syntax"); nPoly++; break; case CLO_PIPE: if (!processPipeOption(scanned[iArg].list+1, scanned[iArg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; default: fprintf(stderr, "error: unknown/ambiguous option: %s\n", scanned[iArg].list[0]); exit(1); break; } } else { if (!input) input = scanned[iArg].list[0]; else if (!output) output = scanned[iArg].list[0]; else SDDS_Bomb("too many filenames seen"); } } processFilenames("sddspoly", &input, &output, pipeFlags, 0, NULL); if (nPoly==0) SDDS_Bomb("give at least one -evaluate option"); if (!SDDS_InitializeInput(&SDDSin, input)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_InitializeCopy(&SDDSout, &SDDSin, output, "w")) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for (iPoly=0; iPoly<nPoly; iPoly++) initializePolynomial(&poly[iPoly], &SDDSin, &SDDSout); if (!SDDS_WriteLayout(&SDDSout)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); while (SDDS_ReadPage(&SDDSin)>0) { rows = SDDS_CountRowsOfInterest(&SDDSin); if (!SDDS_CopyPage(&SDDSout, &SDDSin)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!(outputData = SDDS_Realloc(outputData, sizeof(*outputData)*rows))) SDDS_Bomb("memory allocation failure"); for (iPoly=0; iPoly<nPoly; iPoly++) { for (iInput=0; iInput<poly[iPoly].nInputs; iInput++) { if (!(poly[iPoly].inputData[iInput]= SDDS_GetColumnInDoubles(&SDDSin, poly[iPoly].inputColumn[iInput]))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } for (row=0; row<rows; row++) { for (iInput=0; iInput<poly[iPoly].nInputs; iInput++) poly[iPoly].input[iInput] = poly[iPoly].inputData[iInput][row]; outputData[row] = evaluatePoly(poly[iPoly].coef, poly[iPoly].power, poly[iPoly].nTerms, poly[iPoly].input, poly[iPoly].nInputs); } if (!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_NAME, outputData, rows, poly[iPoly].outputColumn)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_WritePage(&SDDSout)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } free(outputData); if (!SDDS_Terminate(&SDDSin)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (!SDDS_Terminate(&SDDSout)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } free_scanargs(&scanned,argc); FreePolynormialMemory(poly,nPoly); free(poly); return 0; }
int main(int argc, char **argv) { SDDS_DATASET SDDSin, SDDSout; long i_arg, tmpfileUsed; SCANNED_ARG *s_arg; char *input, *output, *description_text, *description_contents; unsigned long pipeFlags; long pageNumber, nonNative = 0; char *outputEndianess = NULL; char buffer[40]; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc<2) bomb(NULL, USAGE); input = output = description_text = description_contents = NULL; pipeFlags = 0; for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { delete_chars(s_arg[i_arg].list[0], "_"); switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) { case SET_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case NONNATIVE: nonNative = 1; break; default: fprintf(stderr, "Error (%s): unknown switch: %s\n", argv[0], s_arg[i_arg].list[0]); exit(1); break; } } else { if (input==NULL) input = s_arg[i_arg].list[0]; else if (output==NULL) output = s_arg[i_arg].list[0]; else SDDS_Bomb("too many filenames"); } } processFilenames("sddsendian", &input, &output, pipeFlags, 0, &tmpfileUsed); outputEndianess = getenv("SDDS_OUTPUT_ENDIANESS"); if (outputEndianess) { putenv("SDDS_OUTPUT_ENDIANESS="); } if (!SDDS_InitializeInput(&SDDSin, input)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (!description_text) SDDS_GetDescription(&SDDSin, &description_text, &description_contents); if (!SDDS_InitializeCopy(&SDDSout, &SDDSin, output, "w") || !SDDS_SetDataMode(&SDDSout, nonNative?SDDS_BINARY:-SDDS_BINARY) || !SDDS_WriteLayout(&SDDSout)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (nonNative) { while ((pageNumber=SDDS_ReadNonNativePage(&SDDSin))>=0) { if (!SDDS_CopyPage(&SDDSout, &SDDSin) || !SDDS_WritePage(&SDDSout)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } } } else { while ((pageNumber=SDDS_ReadPage(&SDDSin))>=0) { if (!SDDS_CopyPage(&SDDSout, &SDDSin) || !SDDS_WriteNonNativeBinaryPage(&SDDSout)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } } } if (!SDDS_Terminate(&SDDSin) || !SDDS_Terminate(&SDDSout)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (tmpfileUsed && !replaceFileAndBackUp(input, output)) exit(1); if (outputEndianess) { sprintf(buffer, "SDDS_OUTPUT_ENDIANESS=%s", outputEndianess); putenv(buffer); } return(0); }
int main(int argc, char **argv) { SDDS_DATASET SDDS_1, SDDS_2, SDDS_output; long i, j, i_arg, rows1, rows2, reuse, reusePage, i1, i2; SCANNED_ARG *s_arg; char s[200], *ptr; char **match_column, **equate_column; long match_columns, equate_columns; char *input1, *input2, *output; long tmpfile_used, retval1, retval2; long warnings, invert; unsigned long pipeFlags; KEYED_EQUIVALENT **keyGroup=NULL; long keyGroups=0; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc<3) bomb(NULL, USAGE); input1 = input2 = output = NULL; match_column = equate_column = NULL; match_columns = equate_columns = reuse = reusePage = 0; tmpfile_used = invert = 0; warnings = 1; pipeFlags = 0; for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { delete_chars(s_arg[i_arg].list[0], "_"); switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) { case SET_MATCH_COLUMN: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -match syntax"); if (match_columns!=0) SDDS_Bomb("only one -match option may be given"); match_column = tmalloc(sizeof(*match_column)*2); if ((ptr=strchr(s_arg[i_arg].list[1], '='))) *ptr++ = 0; else ptr = s_arg[i_arg].list[1]; match_column[0] = s_arg[i_arg].list[1]; match_column[1] = ptr; match_columns = 1; break; case SET_EQUATE_COLUMN: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -equate syntax"); if (equate_columns!=0) SDDS_Bomb("only one -equate option may be given"); equate_column = tmalloc(sizeof(*equate_column)*2); if ((ptr=strchr(s_arg[i_arg].list[1], '='))) *ptr++ = 0; else ptr = s_arg[i_arg].list[1]; equate_column[0] = s_arg[i_arg].list[1]; equate_column[1] = ptr; equate_columns = 1; break; case SET_REUSE: if (s_arg[i_arg].n_items==1) reuse = 1; else { char *reuseOptions[2] = {"rows", "page"}; for (i=1; i<s_arg[i_arg].n_items; i++) { switch (match_string(s_arg[i_arg].list[i], reuseOptions, 2, 0)) { case 0: reuse = 1; break; case 1: reusePage = 1; break; default: SDDS_Bomb("unknown reuse keyword"); break; } } } break; case SET_INVERT: invert = 1; break; case SET_NOWARNINGS: warnings = 0; break; case SET_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; default: fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]); SDDS_Bomb(NULL); break; } } else { if (input1==NULL) input1 = s_arg[i_arg].list[0]; else if (input2==NULL) input2 = s_arg[i_arg].list[0]; else if (output==NULL) output = s_arg[i_arg].list[0]; else SDDS_Bomb("too many filenames"); } } if (pipeFlags&USE_STDIN && input1) { if (output) SDDS_Bomb("too many filenames (sddsxref)"); output = input2; input2 = input1; input1 = NULL; } processFilenames("sddsselect", &input1, &output, pipeFlags, !warnings, &tmpfile_used); if (!input2) SDDS_Bomb("second input file not specified (sddsxref)"); if (equate_columns && match_columns) SDDS_Bomb("only one of -equate or -match may be given"); if (!equate_columns && !match_columns) SDDS_Bomb("one of -equate or -match must be given"); if (!SDDS_InitializeInput(&SDDS_1, input1)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (!SDDS_InitializeInput(&SDDS_2, input2)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (match_columns) { if ((j=SDDS_GetColumnIndex(&SDDS_1, match_column[0]))<0 || SDDS_GetColumnType(&SDDS_1, j)!=SDDS_STRING) { sprintf(s, "error: column %s not found or not string type in file %s", match_column[0], input1?input1:"stdin"); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if ((j=SDDS_GetColumnIndex(&SDDS_2, match_column[1]))<0 || SDDS_GetColumnType(&SDDS_2, j)!=SDDS_STRING) { sprintf(s, "error: column %s not found or not string type in file %s", match_column[1], input2); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (equate_columns) { if ((j=SDDS_GetColumnIndex(&SDDS_1, equate_column[0]))<0 || !SDDS_NUMERIC_TYPE(SDDS_GetColumnType(&SDDS_1, j))) { sprintf(s, "error: column %s not found or not numeric type in file %s", equate_column[0], input1?input1:"stdin"); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if ((j=SDDS_GetColumnIndex(&SDDS_2, equate_column[1]))<0 || !SDDS_NUMERIC_TYPE(SDDS_GetColumnType(&SDDS_2, j))) { sprintf(s, "error: column %s not found or not numeric type in file %s", equate_column[1], input2); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (output && pipeFlags&USE_STDOUT) SDDS_Bomb("too many filenames with -pipe option"); if (!output && !(pipeFlags&USE_STDOUT)) { if (warnings) fprintf(stderr, "warning: existing file %s will be replaced (sddsselect)\n", input1?input1:"stdin"); tmpfile_used = 1; cp_str(&output, tmpname(NULL)); } if (!SDDS_InitializeCopy(&SDDS_output, &SDDS_1, output, "w")) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (!SDDS_WriteLayout(&SDDS_output)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); while ((retval1=SDDS_ReadPage(&SDDS_1))>0) { if (!reusePage) { if ((retval2=SDDS_ReadPage(&SDDS_2))<=0) { if (warnings) fprintf(stderr, "warning: <input2> ends before <input1>\n"); if (invert) { /* nothing to match, so everything would normally be thrown out */ if (!SDDS_CopyPage(&SDDS_output, &SDDS_1) || !SDDS_WritePage(&SDDS_output)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); continue; } else /* nothing to match, so everything thrown out */ break; } } else { if (retval1==1 && (retval2=SDDS_ReadPage(&SDDS_2))<=0) SDDS_Bomb("<input2> has no data"); SDDS_SetRowFlags(&SDDS_2, 1); } rows1 = SDDS_CountRowsOfInterest(&SDDS_1); rows2 = SDDS_CountRowsOfInterest(&SDDS_2); if (!SDDS_StartPage(&SDDS_output, rows1)) { SDDS_SetError("Problem starting output page"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_CopyParameters(&SDDS_output, &SDDS_2) || !SDDS_CopyArrays(&SDDS_output, &SDDS_2)) { SDDS_SetError("Problem copying parameter or array data from second input file"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_CopyParameters(&SDDS_output, &SDDS_1) || !SDDS_CopyArrays(&SDDS_output, &SDDS_1)) { SDDS_SetError("Problem copying parameter or array data from first input file"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (match_columns) { char **string1, **string2; long matched; string2 = NULL; if (!(string1 = SDDS_GetColumn(&SDDS_1, match_column[0]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[0], input1?input1:"stdin"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2 && !(string2 = SDDS_GetColumn(&SDDS_2, match_column[1]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", match_column[1], input2); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2) keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_STRING, string2, rows2); for (i1=0; i1<rows1; i1++) { if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) { sprintf(s, "Problem copying row %ld of first data set", i1); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } matched = 0; if (rows2 &&(i2 = FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_STRING, string1+i1, reuse))>=0) { matched = 1; } if ((!matched && !invert) || (matched && invert)) { if (!SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, 0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (string1) { for (i=0;i<rows1;i++) free(string1[i]); free(string1); string1 = NULL; } if (string2) { for (i=0;i<rows2;i++) free(string2[i]); free(string2); string2 = NULL; } for (i=0;i<keyGroups;i++) { if (keyGroup[i]) { if (keyGroup[i]->equivalent) free(keyGroup[i]->equivalent); free(keyGroup[i]); keyGroup[i] = NULL; } } if (keyGroups) { free(keyGroup); keyGroup = NULL; keyGroups = 0; } } else if (equate_columns) { double *value1, *value2; long equated; value2 = NULL; if (!(value1 = SDDS_GetColumnInDoubles(&SDDS_1, equate_column[0]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[0], input1?input1:"stdin"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2 && !(value2 = SDDS_GetColumnInDoubles(&SDDS_2, equate_column[1]))) { fprintf(stderr, "Error: problem getting column %s from file %s\n", equate_column[1], input2); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (rows2) keyGroup = MakeSortedKeyGroups(&keyGroups, SDDS_DOUBLE, value2, rows2); for (i1=0; i1<rows1; i1++) { if (!SDDS_CopyRowDirect(&SDDS_output, i1, &SDDS_1, i1)) { sprintf(s, "Problem copying row %ld of first data set", i1); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } equated = 0; if (rows2 && (i2 = FindMatchingKeyGroup(keyGroup, keyGroups, SDDS_DOUBLE, value1+i1, reuse))>=0) { equated = 1; } if ((!equated && !invert) || (equated && invert)) { if (!SDDS_AssertRowFlags(&SDDS_output, SDDS_INDEX_LIMITS, i1, i1, 0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (value1) free(value1); value1 = NULL; if (rows2 && value2) free(value2); value2 = NULL; for (i=0;i<keyGroups;i++) { if (keyGroup[i]) { if (keyGroup[i]->equivalent) free(keyGroup[i]->equivalent); free(keyGroup[i]); keyGroup[i] = NULL; } } if (keyGroups) { free(keyGroup); keyGroup = NULL; keyGroups = 0; } } if (!SDDS_WritePage(&SDDS_output)) { SDDS_SetError("Problem writing data to output file"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (!SDDS_Terminate(&SDDS_1) || !SDDS_Terminate(&SDDS_2) || !SDDS_Terminate(&SDDS_output)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } if (tmpfile_used && !replaceFileAndBackUp(input1, output)) exit(1); free_scanargs(&s_arg,argc); if (match_columns) free(match_column); 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; }