void m_invert(matrix m,matrix &dest) { int i,j; float d; d = m_det(m); if (d == 0.0) { m_zero(dest); return; } for (i = 0;i<=3;i++) for (j = 0;j<=3;j++) dest[i][j] = m_signedsubdet(m, i, j); m_trans(dest); m_mults(dest, 1/d, dest); }
void matlib_main() { MATRIX *A, *B, *C; MATRIX *At, *Bt; long n, ni, i; double sum; random_1(-1); n = query_long("dimension of arrays", 3L); ni = query_long("number of iterations", 100L); #ifdef VAX_VMS init_stats(); #endif m_alloc(&A, n, n); m_alloc(&At, n, n); m_alloc(&B, n, n); m_alloc(&Bt, n, n); m_alloc(&C, n, n); for (i=sum=0; i<ni; i++) { m_rand(At, -1.0L, 1.0L); m_trans(A, At); m_invert(B, A); m_mult(C, A, B); sum += fabs(m_det(C)-1.0); } m_free(&A); m_free(&At); m_free(&B); m_free(&Bt); m_free(&C); printf("M.A.D.{DET{A.INV(A))}-1} = %e\n", sum/ni); #ifdef VAX_VMS report_stats(stdout, "stats: "); #endif }
long lsfn( double *xd, double *yd, double *sy, /* data */ long nd, /* number of data points */ long nf, /* y = a_0 + a_1*x ... a_nf*x^nf */ double *coef, /* place to put co-efficients */ double *s_coef, /* and their sigmas */ double *chi, /* place to put reduced chi-squared */ double *diff /* place to put difference table */ ) { long i, j, nt, unweighted; double xp, *x_i, x0; static MATRIX *X, *Y, *Yp, *C, *C_1, *Xt, *A, *Ca, *XtC, *XtCX, *T, *Tt, *TC; nt = nf + 1; if (nd<nt) { printf("error: insufficient data for requested order of fit\n"); printf("(%ld data points, %ld terms in fit)\n", nd, nt); exit(1); } unweighted = 1; if (sy) for (i=1; i<nd; i++) if (sy[i]!=sy[0]) { unweighted = 0; break; } /* allocate matrices */ m_alloc(&X, nd, nt); m_alloc(&Y, nd, 1); m_alloc(&Yp, nd, 1); m_alloc(&Xt, nt, nd); if (!unweighted) { m_alloc(&C, nd, nd); m_alloc(&C_1, nd, nd); m_zero(C); m_zero(C_1); } m_alloc(&A, nt, 1); m_alloc(&Ca, nt, nt); m_alloc(&XtC, nt, nd); m_alloc(&XtCX, nt, nt); m_alloc(&T, nt, nd); m_alloc(&Tt, nd, nt); m_alloc(&TC, nt, nd); /* Compute X, Y, C, C_1. X[i][j] = (xd[i])^j. Y[i][0] = yd[i]. * C = delta(i,j)*sy[i]^2 (covariance matrix of yd) * C_1 = INV(C) */ for (i=0; i<nd; i++) { x_i = X->a[i]; x0 = xd[i]; xp = 1.0; Y->a[i][0] = yd[i]; if (!unweighted) { C->a[i][i] = sqr(sy[i]); C_1->a[i][i] = 1/C->a[i][i]; } for (j=0; j<nt; j++) { x_i[j] = xp; xp *= x0; } } /* Compute A, the matrix of coefficients. * Weighted least-squares solution is A = INV(Xt.INV(C).X).Xt.INV(C).y * Unweighted solution is A = INV(Xt.X).Xt.y */ if (unweighted) { /* eliminating 2 matrix operations makes this much faster than a weighted fit * if there are many data points. */ if (!m_trans(Xt, X)) return(p_merror("transposing X")); if (!m_mult(XtCX, Xt, X)) return(p_merror("multiplying Xt.X")); if (!m_invert(XtCX, XtCX)) return(p_merror("inverting XtCX")); if (!m_mult(T, XtCX, Xt)) return(p_merror("multiplying XtX.Xt")); if (!m_mult(A, T, Y)) return(p_merror("multiplying T.Y")); /* Compute covariance matrix of A, Ca = (T.Tt)*C[0][0] */ if (!m_trans(Tt, T)) return(p_merror("computing transpose of T")); if (!m_mult(Ca, T, Tt)) return(p_merror("multiplying T.Tt")); if (!m_scmul(Ca, Ca, sy?sqr(sy[0]):1)) return(p_merror("multiplying T.Tt by scalar")); } else { if (!m_trans(Xt, X)) return(p_merror("transposing X")); if (!m_mult(XtC, Xt, C_1)) return(p_merror("multiplying Xt.C_1")); if (!m_mult(XtCX, XtC, X)) return(p_merror("multiplying XtC.X")); if (!m_invert(XtCX, XtCX)) return(p_merror("inverting XtCX")); if (!m_mult(T, XtCX, XtC)) return(p_merror("multiplying XtCX.XtC")); if (!m_mult(A, T, Y)) return(p_merror("multiplying T.Y")); /* Compute covariance matrix of A, Ca = T.C.Tt */ if (!m_mult(TC, T, C)) return(p_merror("multiplying T.C")); if (!m_trans(Tt, T)) return(p_merror("computing transpose of T")); if (!m_mult(Ca, TC, Tt)) return(p_merror("multiplying TC.Tt")); } for (i=0; i<nt; i++) { coef[i] = A->a[i][0]; if (s_coef) s_coef[i] = sqrt(Ca->a[i][i]); } /* Compute Yp = X.A, use to compute chi-squared */ if (chi) { if (!m_mult(Yp, X, A)) return(p_merror("multiplying X.A")); *chi = 0; for (i=0; i<nd; i++) { xp = (Yp->a[i][0] - yd[i]); if (diff!=NULL) diff[i] = xp; xp /= sy?sy[i]:1; *chi += xp*xp; } if (nd!=nt) *chi /= (nd-nt); } m_free(&X); m_free(&Y); m_free(&Yp); m_free(&Xt); if (!unweighted) { m_free(&C); m_free(&C_1); } m_free(&A); m_free(&Ca); m_free(&XtC); m_free(&XtCX); m_free(&T); m_free(&Tt); m_free(&TC); return(1); }
void computeChromCorrectionMatrix(RUN *run, LINE_LIST *beamline, CHROM_CORRECTION *chrom) { VMATRIX *M; double chromx, chromy; double chromx0, chromy0; double K2=0.0, *K2ptr; ELEMENT_LIST *context; long i, count, K2_param=0; MATRIX *C, *Ct, *CtC, *inv_CtC; m_alloc(&C, 2, chrom->n_families); m_alloc(&Ct, chrom->n_families, 2); m_alloc(&CtC, chrom->n_families, chrom->n_families); m_alloc(&inv_CtC, chrom->n_families, chrom->n_families); if (chrom->T) m_free(&(chrom->T)); if (chrom->dK2) m_free(&(chrom->dK2)); if (chrom->dchrom) m_free(&(chrom->dchrom)); m_alloc(&(chrom->T), chrom->n_families, 2); m_alloc(&(chrom->dK2), chrom->n_families, 1); m_alloc(&(chrom->dchrom), 2, 1); if (verbosityLevel>2) { fprintf(stdout, "Computing chromaticity influence matrix for all named sextupoles.\n"); fflush(stdout); } computeChromaticities(&chromx0, &chromy0, NULL, NULL, NULL, NULL, beamline->twiss0, beamline->elast->twiss, M=beamline->matrix); M = NULL; for (i=0; i<chrom->n_families; i++) { count = 0; context = NULL; while ((context=find_element(chrom->name[i], &context, beamline->elem_twiss))) { if (!count && !(K2_param=confirm_parameter("K2", context->type))) { fprintf(stdout, "error: element %s does not have K2 parameter\n", context->name); fflush(stdout); exitElegant(1); } if (!(K2ptr = (double*)(context->p_elem + entity_description[context->type].parameter[K2_param].offset))) bombElegant("K2ptr NULL in setup_chromaticity_correction", NULL); if (count==0) K2 = *K2ptr; *K2ptr = K2 + chrom->sextupole_tweek; if (context->matrix) { free_matrices(context->matrix); free(context->matrix); context->matrix = NULL; } compute_matrix(context, run, NULL); count++; } if (count==0) { fprintf(stdout, "error: element %s is not in the beamline.\n", chrom->name[i]); fflush(stdout); exitElegant(1); } if (beamline->links) { /* rebaseline_element_links(beamline->links, run, beamline); */ assert_element_links(beamline->links, run, beamline, STATIC_LINK+DYNAMIC_LINK); } if (M) { free_matrices(M); free(M); M = NULL; } M = full_matrix(beamline->elem_twiss, run, 2); computeChromaticities(&chromx, &chromy, NULL, NULL, NULL, NULL, beamline->twiss0, beamline->elast->twiss, M); C->a[0][i] = (chromx-chromx0)/chrom->sextupole_tweek; C->a[1][i] = (chromy-chromy0)/chrom->sextupole_tweek; if (C->a[0][i]==0 || C->a[1][i]==0) { fprintf(stdout, "error: element %s does not change the chromaticity!\n", chrom->name[i]); fflush(stdout); exitElegant(1); } count = 0; context = NULL; while ((context=find_element(chrom->name[i], &context, beamline->elem_twiss))) { if (!count && !(K2_param=confirm_parameter("K2", context->type))) { fprintf(stdout, "error: element %s does not have K2 parameter\n", context->name); fflush(stdout); exitElegant(1); } if (!(K2ptr = (double*)(context->p_elem + entity_description[context->type].parameter[K2_param].offset))) bombElegant("K2ptr NULL in setup_chromaticity_correction", NULL); if (!K2ptr) bombElegant("K2ptr NULL in setup_chromaticity_correction", NULL); *K2ptr = K2; if (context->matrix) { free_matrices(context->matrix); free(context->matrix); context->matrix = NULL; } compute_matrix(context, run, NULL); count++; } } if (M) { free_matrices(M); free(M); M = NULL; } if (beamline->matrix) { free_matrices(beamline->matrix); free(beamline->matrix); beamline->matrix = NULL; } beamline->matrix = full_matrix(beamline->elem_twiss, run, run->default_order); if (verbosityLevel>1) { fprintf(stdout, "\nfamily dCHROMx/dK2 dCHROMy/dK2\n"); fflush(stdout); for (i=0; i<chrom->n_families; i++) fprintf(stdout, "%10s: %14.7e %14.7e\n", chrom->name[i], C->a[0][i], C->a[1][i]); fflush(stdout); } m_trans(Ct, C); m_mult(CtC, Ct, C); m_invert(inv_CtC, CtC); m_mult(chrom->T, inv_CtC, Ct); if (verbosityLevel>1) { fprintf(stdout, "\nfamily dK2/dCHROMx dK2/dCHROMy\n"); fflush(stdout); for (i=0; i<chrom->n_families; i++) fprintf(stdout, "%10s: %14.7e %14.7e\n", chrom->name[i], chrom->T->a[i][0], chrom->T->a[i][1]); fflush(stdout); fprintf(stdout, "\n"); fflush(stdout); } m_free(&C); m_free(&Ct); m_free(&CtC); m_free(&inv_CtC); }
int main(int argc, char **argv) { SCANNED_ARG *s_arg; SDDS_DATASET inputPage, outputPage; char *inputfile, *outputfile; char **inputColumnName, **inputStringColumnName, **inputDoubleColumnName; char **outputStringColumnName, **outputDoubleColumnName, **matchColumn=NULL; long inputRows, inputDoubleColumns, inputStringColumns, indexColumn=0, matchColumns=0, noOldColumnNamesColumn=0; long outputRows, outputDoubleColumns, outputStringColumns; char **inputParameterName; int32_t inputParameters, inputColumns; char *inputDescription, *inputContents; char *outputDescription; long i, i_arg, col; char *buffer; char **columnOfStrings; long buffer_size; #define BUFFER_SIZE_INCREMENT 16384 MATRIX *R, *RInv; long OldStringColumnsDefined; char *inputStringRows, *outputStringRows; char **stringArray, *stringParameter; long token_length; long verbose; char format[32]; long digits; char *Symbol, *Root; void *parameterPointer; long ascii; unsigned long pipeFlags, majorOrderFlag; long tmpfile_used, noWarnings; long ipage=0, columnType; char *oldColumnNames, *newColumnNamesColumn; short columnMajorOrder=-1; inputColumnName = outputStringColumnName = outputDoubleColumnName = inputParameterName = NULL; outputRows = outputDoubleColumns = outputStringColumns = OldStringColumnsDefined = 0; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc==1) bomb(NULL, USAGE); inputfile = outputfile = NULL; verbose = 0; Symbol = Root = NULL; ascii = 0; digits=3; pipeFlags = 0; tmpfile_used = 0; noWarnings = 0; oldColumnNames = NULL; newColumnNamesColumn = 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], commandline_option, COMMANDLINE_OPTIONS, UNIQUE_MATCH)) { case CLO_MAJOR_ORDER: majorOrderFlag=0; s_arg[i_arg].n_items--; if (s_arg[i_arg].n_items>0 && (!scanItemList(&majorOrderFlag, s_arg[i_arg].list+1, &s_arg[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; case CLO_MATCH_COLUMN: matchColumns = s_arg[i_arg].n_items-1; matchColumn = s_arg[i_arg].list+1; break; case CLO_INDEX_COLUMN: indexColumn = 1; break; case CLO_NO_OLDCOLUMNNAMES: noOldColumnNamesColumn = 1; break; case CLO_VERBOSE: verbose=1; break; case CLO_ASCII: ascii=1; break; case CLO_DIGITS: if (!(get_long(&digits, s_arg[i_arg].list[1]))) bomb("no string given for option -digits", USAGE); break; case CLO_COLUMNROOT: if (!(Root=s_arg[i_arg].list[1])) SDDS_Bomb("No root string given"); break; case CLO_SYMBOL: if (!(Symbol=s_arg[i_arg].list[1])) SDDS_Bomb("No symbol string given"); 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_OLDCOLUMNNAMES: if (!(oldColumnNames=s_arg[i_arg].list[1])) SDDS_Bomb("No oldColumnNames string given"); break; case CLO_NEWCOLUMNNAMES: if (s_arg[i_arg].n_items!=2 || SDDS_StringIsBlank(newColumnNamesColumn = s_arg[i_arg].list[1])) SDDS_Bomb("Invalid -newColumnNames syntax/value"); break; default: bomb("unrecognized option given", USAGE); } } else { if (!inputfile) inputfile = s_arg[i_arg].list[0]; else if (!outputfile) outputfile = s_arg[i_arg].list[0]; else bomb("too many filenames given", USAGE); } } processFilenames("sddstranpose", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used); if (newColumnNamesColumn && Root) SDDS_Bomb("-root and -newColumnNames are incompatible"); if (!SDDS_InitializeInput(&inputPage, inputfile) || !(inputParameterName=(char**)SDDS_GetParameterNames(&inputPage, &inputParameters)) || !SDDS_GetDescription(&inputPage, &inputDescription, &inputContents)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); if (matchColumns) inputColumnName = getMatchingSDDSNames(&inputPage, matchColumn, matchColumns, &inputColumns, SDDS_MATCH_COLUMN); else { if (!(inputColumnName=(char**)SDDS_GetColumnNames(&inputPage, &inputColumns))) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } inputDoubleColumns=0; inputStringColumns=0; inputDoubleColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputStringColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputRows = 0; /*********** \ * read data * \***********/ while (0<SDDS_ReadTable(&inputPage)) { ipage ++; #if defined(DEBUG) fprintf(stderr, "working on page %ld\n", ipage); #endif if (ipage==1) { SDDS_DeferSavingLayout(1); if( !SDDS_SetColumnFlags(&inputPage, 0)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); /* count the string and numerical columns in the input file */ for (i=0;i<inputColumns;i++) { if ( SDDS_NUMERIC_TYPE( columnType = SDDS_GetColumnType( &inputPage, i))) { inputDoubleColumnName[inputDoubleColumns]=inputColumnName[i]; inputDoubleColumns++; } } for (i=0; i<inputPage.layout.n_columns; i++) { if (inputPage.layout.column_definition[i].type == SDDS_STRING ) { inputStringColumnName[inputStringColumns] = inputPage.layout.column_definition[i].name; inputStringColumns++; } } if( !(inputRows=SDDS_CountRowsOfInterest(&inputPage))) SDDS_Bomb("No rows in dataset."); } else { /* these statements are executed on the subsequent pages */ if (inputRows != SDDS_CountRowsOfInterest(&inputPage)) { SDDS_Bomb("Datasets don't have the same number of rows.\nProcessing stopped before reaching the end of the input file."); } } #if defined(DEBUG) fprintf(stderr, "row flags set\n"); #endif if (inputDoubleColumns == 0) SDDS_Bomb("No numerical columns in file."); if ((ipage==1) && verbose) { fprintf(stderr, "No. of double/float/integer columns: %ld.\n", inputDoubleColumns); fprintf(stderr, "No. of string columns: %ld.\n", inputStringColumns); fprintf(stderr, "No. of rows: %ld.\n", inputRows); } /****************\ * transpose data * \****************/ if (inputDoubleColumns) { if (ipage == 1) { m_alloc(&RInv, inputRows, inputDoubleColumns); m_alloc(&R, inputDoubleColumns, inputRows); } for (col=0;col<inputDoubleColumns;col++){ if (!(R->a[col]=(double*)SDDS_GetColumnInDoubles(&inputPage, inputDoubleColumnName[col]))) { SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (verbose) { m_show(R, "%9.6le ", "Transpose of input matrix:\n", stdout); } m_trans(RInv, R); } /***************************\ * determine existence of * * transposed string columns * \***************************/ if (ipage == 1) { OldStringColumnsDefined=0; switch(SDDS_CheckParameter(&inputPage, OLD_STRING_COLUMN_NAMES, NULL, SDDS_STRING, NULL)){ case SDDS_CHECK_OKAY: OldStringColumnsDefined=1; break; case SDDS_CHECK_NONEXISTENT: break; case SDDS_CHECK_WRONGTYPE: case SDDS_CHECK_WRONGUNITS: fprintf(stderr, "Something wrong with parameter OldStringColumns.\n"); exit(1); break; } if (OldStringColumnsDefined){ /* decompose OldStringColumns into names of string columns for the output file */ if (!SDDS_GetParameter(&inputPage, OLD_STRING_COLUMN_NAMES, &inputStringRows)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Parameter OldStringColumns: %s.\n", inputStringRows); } outputStringColumnName=(char**)malloc(sizeof(char*)); outputStringColumns=0; buffer_size=BUFFER_SIZE_INCREMENT; buffer=(char*)malloc(sizeof(char)*buffer_size); while ( 0 <= (token_length = SDDS_GetToken(inputStringRows, buffer, BUFFER_SIZE_INCREMENT))){ if (!token_length) SDDS_Bomb("A null string was detected in parameter OldStringColumns.\n"); if (!SDDS_CopyString(&outputStringColumnName[outputStringColumns], buffer)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Output string column: %s\n", outputStringColumnName[outputStringColumns]); } outputStringColumns++; } } } /*********************\ * define output page * \*********************/ if ( ipage == 1 ) { outputRows = inputDoubleColumns; outputDoubleColumns = inputRows; if (inputDescription){ outputDescription = (char*) malloc( sizeof(char) * (strlen("Transpose of ") + strlen(inputDescription) + 1)); strcat(strcpy(outputDescription, "Transpose of "), inputDescription); if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, outputDescription, inputContents, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, NULL, NULL, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (columnMajorOrder!=-1) outputPage.layout.data_mode.column_major = columnMajorOrder; else outputPage.layout.data_mode.column_major = inputPage.layout.data_mode.column_major; /***********************************\ * define names for double columns * \***********************************/ if (!Root && inputStringColumns ) { /* use specified string column, or first string column encountered */ if (!newColumnNamesColumn) /* first string column encountered */ outputDoubleColumnName = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[0]); else { /* use specified string column */ if (SDDS_CheckColumn(&inputPage, newColumnNamesColumn, NULL, SDDS_STRING, stderr)!=SDDS_CHECK_OKAY) SDDS_Bomb("column named with -newColumnNames does not exist in input"); outputDoubleColumnName = (char**)SDDS_GetColumn(&inputPage, newColumnNamesColumn); } for (i=1; i<inputRows; i++) { if (match_string(outputDoubleColumnName[i-1], outputDoubleColumnName+i, inputRows-i, EXACT_MATCH)>=0) { fprintf(stderr, "Error, duplicate %s found in input file string column %s, can not be used as output column names\n", outputDoubleColumnName[i-1], newColumnNamesColumn ? newColumnNamesColumn : inputStringColumnName[0]); exit(1); } } } else { /* use command line options to produce column names in the output file */ outputDoubleColumnName = (char**) malloc( outputDoubleColumns * sizeof(char*) ); digits = MAX(digits, log10(inputRows) + 1); if (!Root){ Root = (char*) malloc( sizeof(char) * (strlen("Column")+1) ); strcpy(Root, "Column"); } if (outputDoubleColumns!=1) { for ( i=0; i < outputDoubleColumns; i++){ outputDoubleColumnName[i] = (char*) malloc( sizeof(char) * (strlen(Root)+digits+1)); sprintf(format, "%s%%0%ldld", Root, digits); sprintf(outputDoubleColumnName[i], format, i); } } else {/* only one row to transpose */ outputDoubleColumnName[0] = (char*) malloc( sizeof(char) * (strlen(Root)+1)); strcpy( outputDoubleColumnName[0], Root); } } /*************************\ * define string columns * \*************************/ if (OldStringColumnsDefined) { if (!SDDS_DefineSimpleColumns(&outputPage, outputStringColumns, outputStringColumnName, NULL, SDDS_STRING)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { /* by default there should be at least one string column, that of the old column names. */ if (!noOldColumnNamesColumn) { outputStringColumns = 1; outputStringColumnName = (char**) malloc( sizeof(char*)); if (oldColumnNames) { /* commanline option specification */ outputStringColumnName[0] = oldColumnNames; } else { outputStringColumnName[0] = (char*) malloc( sizeof(char) * (strlen("OldColumnNames") + 1)); strcpy(outputStringColumnName[0], "OldColumnNames"); } if ( 0 > SDDS_DefineColumn(&outputPage, outputStringColumnName[0], NULL, NULL, NULL, NULL, SDDS_STRING, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (indexColumn && !SDDS_DefineSimpleColumn(&outputPage, "Index", NULL, SDDS_LONG)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /*************************\ * define double columns * \*************************/ for ( i=0; i < outputDoubleColumns; i++) if (Symbol){ if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], Symbol, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /********************************\ * define string parameters * * i.e. transposed string columns * \********************************/ if ( inputStringColumns>1 ) { if (0>SDDS_DefineParameter(&outputPage, OLD_STRING_COLUMN_NAMES, NULL, NULL, "Transposed string columns", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for ( i=0; i < inputStringColumns; i++){ if (0>SDDS_DefineParameter(&outputPage, inputStringColumnName[i], NULL, NULL, "Transposed string column data", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /*************************\ * transfer parameters not * * associated with old * * string columns * \*************************/ if (inputParameters) { for ( i=0; i < inputParameters; i++) { if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) if ( 0 > SDDS_TransferParameterDefinition(&outputPage, &inputPage, inputParameterName[i], NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /***************\ * write layout * \***************/ SDDS_DeferSavingLayout(0); /* if InputFile is not already transfered ot the output file, then create it. */ switch( SDDS_CheckParameter(&outputPage, "InputFile", NULL, SDDS_STRING, NULL) ) { case SDDS_CHECK_NONEXISTENT: if (0>SDDS_DefineParameter(&outputPage, "InputFile", NULL, NULL, "Original matrix file", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; default: break; } if (!SDDS_WriteLayout(&outputPage) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "table layout defined\n"); #endif if (!SDDS_StartTable(&outputPage, outputRows) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (ipage == 1) { if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "InputFile", inputfile?inputfile:"pipe", NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /***************************************\ * assign string columns from input * * to string parameters in output * \**************************************/ if ( inputStringColumns > 1) { for ( i=0; i < inputStringColumns; i++){ columnOfStrings = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[i]); stringParameter = JoinStrings(columnOfStrings, inputRows, BUFFER_SIZE_INCREMENT); if ( !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, inputStringColumnName[i], stringParameter, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(columnOfStrings); free(stringParameter); } outputStringRows = JoinStrings(inputStringColumnName, inputStringColumns, BUFFER_SIZE_INCREMENT); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, OLD_STRING_COLUMN_NAMES, outputStringRows, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string parameters assigned\n"); #endif if (inputParameters){ for ( i=0; i < inputParameters; i++){ if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) { parameterPointer = (void*) SDDS_GetParameter(&inputPage, inputParameterName[i], NULL); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputParameterName[i], parameterPointer, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(parameterPointer); } } } #if defined(DEBUG) fprintf(stderr, "input parameters assigned\n"); #endif /**********************************\ * assign data to * * output table part of data set * \**********************************/ if (outputRows) { /***************************\ * assign string column data * \***************************/ if (OldStringColumnsDefined){ for ( i=0 ; i < outputStringColumns; i++){ if (!SDDS_GetParameter(&inputPage, outputStringColumnName[i], &stringParameter)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); stringArray=TokenizeString(stringParameter, outputRows); if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, stringArray, outputRows, outputStringColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } else { if (!noOldColumnNamesColumn && !SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputDoubleColumnName, outputRows, outputStringColumnName[0])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string data columns assigned\n"); #endif /***************************\ * assign double column data * \***************************/ for ( i=0 ; i < outputDoubleColumns; i++) /* i is the row index */ if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, RInv->a[i], outputRows, outputDoubleColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (indexColumn) { for (i=0; i<outputRows; i++) if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, i, "Index", i, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "double data columns assigned\n"); #endif } #if defined(DEBUG) fprintf(stderr, "data assigned\n"); #endif if (!SDDS_WriteTable(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); #if defined(DEBUG) fprintf(stderr, "data written out\n"); #endif } if (inputDoubleColumns) { m_free(&RInv); m_free(&R); } if (inputColumnName) { SDDS_FreeStringArray(inputColumnName, inputColumns); free(inputColumnName); } if (inputStringColumns) free(inputStringColumnName); if (inputDescription) free(inputDescription); if (inputParameterName) { SDDS_FreeStringArray(inputParameterName, inputParameters); free(inputParameterName); } if (outputDoubleColumns) { SDDS_FreeStringArray(outputDoubleColumnName, outputDoubleColumns); free(outputDoubleColumnName); } if (!SDDS_Terminate(&inputPage) || !SDDS_Terminate(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile)) exit(1); return(0); }