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);
}
