Provided by: funtools_1.4.4-6_amd64 bug

NAME

       funcalc - Funtools calculator (for binary tables)

SYNOPSIS

       funcalc [\-n] [\-a argstr] [\-e expr] [\-f file] [\-l link] [\-p prog] <iname> [oname
       [columns]]

OPTIONS

         -a argstr    # user arguments to pass to the compiled program
         -e expr      # funcalc expression
         -f file      # file containing funcalc expression
         -l libs      # libs to add to link command
         -n           # output generated code instead of compiling and executing
         -p prog      # generate named program, no execution
         -u           # die if any variable is undeclared (don't auto-declare)

DESCRIPTION

       funcalc is a calculator program that allows arbitrary expressions to be constructed,
       compiled, and executed on columns in a Funtools table (FITS binary table or raw event
       file). It works by integrating user-supplied expression(s) into a template C program, then
       compiling and executing the program. funcalc expressions are C statements, although some
       important simplifications (such as automatic declaration of variables) are supported.

       funcalc expressions can be specified in three ways: on the command line using the \-e
       [expression] switch, in a file using the \-f [file] switch, or from stdin (if neither \-e
       nor \-f is specified). Of course a file containing funcalc expressions can be read from
       stdin.

       Each invocation of funcalc requires an input Funtools table file to be specified as the
       first command line argument.  The output Funtools table file is the second optional
       argument. It is needed only if an output FITS file is being created (i.e., in cases where
       the funcalc expression only prints values, no output file is needed). If input and output
       file are both specified, a third optional argument can specify the list of columns to
       activate (using FunColumnActivate()).  Note that funcalc determines whether or not to
       generate code for writing an output file based on the presence or absence of an output
       file argument.

       A funcalc expression executes on each row of a table and consists of one or more C
       statements that operate on the columns of that row (possibly using temporary variables).
       Within an expression, reference is made to a column of the current row using the C struct
       syntax cur-[colname]>, e.g. cur->x, cur->pha, etc.  Local scalar variables can be defined
       using C declarations at very the beginning of the expression, or else they can be defined
       automatically by funcalc (to be of type double). Thus, for example, a swap of columns x
       and y in a table can be performed using either of the following equivalent funcalc
       expressions:

         double temp;
         temp = cur->x;
         cur->x = cur->y;
         cur->y = temp;

       or:

         temp = cur->x;
         cur->x = cur->y;
         cur->y = temp;

       When this expression is executed using a command such as:

         funcalc -f swap.expr itest.ev otest.ev

       the resulting file will have values of the x and y columns swapped.

       By default, the data type of the variable for a column is the same as the data type of the
       column as stored in the file. This can be changed by appending ":[dtype]" to the first
       reference to that column. In the example above, to force x and y to be output as doubles,
       specify the type 'D' explicitly:

         temp = cur->x:D;
         cur->x = cur->y:D;
         cur->y = temp;

       Data type specifiers follow standard FITS table syntax for defining columns using TFORM:

       ·   A: ASCII characters

       ·   B: unsigned 8\-bit char

       ·   I: signed 16\-bit int

       ·   U: unsigned 16\-bit int (not standard FITS)

       ·   J: signed 32\-bit int

       ·   V: unsigned 32\-bit int (not standard FITS)

       ·   E: 32\-bit float

       ·   D: 64\-bit float

       ·   X: bits (treated as an array of chars)

       Note that only the first reference to a column should contain the explicit data type
       specifier.

       Of course, it is important to handle the data type of the columns correctly.  One of the
       most frequent cause of error in funcalc programming is the implicit use of the wrong data
       type for a column in expression.  For example, the calculation:

         dx = (cur->x - cur->y)/(cur->x + cur->y);

       usually needs to be performed using floating point arithmetic. In cases where the x and y
       columns are integers, this can be done by reading the columns as doubles using an explicit
       type specification:

         dx = (cur->x:D - cur->y:D)/(cur->x + cur->y);

       Alternatively, it can be done using C type-casting in the expression:

         dx = ((double)cur->x - (double)cur->y)/((double)cur->x + (double)cur->y);

       In addition to accessing columns in the current row, reference also can be made to the
       previous row using prev-[colname]>, and to the next row using next-[colname]>.  Note that
       if prev-[colname]> is specified in the funcalc expression, the very first row is not
       processed.  If next-[colname]> is specified in the funcalc expression, the very last row
       is not processed. In this way, prev and next are guaranteed always to point to valid rows.
       For example, to print out the values of the current x column and the previous y column,
       use the C fprintf function in a funcalc expression:

         fprintf(stdout, "%d %d\n", cur->x, prev->y);

       New columns can be specified using the same cur-[colname]> syntax by appending the column
       type (and optional tlmin/tlmax/binsiz specifiers), separated by colons. For example,
       cur->avg:D will define a new column of type double. Type specifiers are the same those
       used above to specify new data types for existing columns.

       For example, to create and output a new column that is the average value of the x and y
       columns, a new "avg" column can be defined:

         cur->avg:D = (cur->x + cur->y)/2.0

       Note that the final ';' is not required for single-line expressions.

       As with FITS TFORM data type specification, the column data type specifier can be preceded
       by a numeric count to define an array, e.g., "10I" means a vector of 10 short ints, "2E"
       means two single precision floats, etc.  A new column only needs to be defined once in a
       funcalc expression, after which it can be used without re-specifying the type. This
       includes reference to elements of a column array:

         cur->avg[0]:2D = (cur->x + cur->y)/2.0;
         cur->avg[1] = (cur->x - cur->y)/2.0;

       The 'X' (bits) data type is treated as a char array of dimension (numeric_count/8), i.e.,
       16X is processed as a 2\-byte char array. Each 8\-bit array element is accessed
       separately:

         cur->stat[0]:16X  = 1;
         cur->stat[1]      = 2;

       Here, a 16\-bit column is created with the MSB is set to 1 and the LSB set to 2.

       By default, all processed rows are written to the specified output file. If you want to
       skip writing certain rows, simply execute the C "continue" statement at the end of the
       funcalc expression, since the writing of the row is performed immediately after the
       expression is executed. For example, to skip writing rows whose average is the same as the
       current x value:

         cur->avg[0]:2D = (cur->x + cur->y)/2.0;
         cur->avg[1] = (cur->x - cur->y)/2.0;
         if( cur->avg[0] == cur->x )
           continue;

       If no output file argument is specified on the funcalc command line, no output file is
       opened and no rows are written. This is useful in expressions that simply print output
       results instead of generating a new file:

         fpv = (cur->av3:D-cur->av1:D)/(cur->av1+cur->av2:D+cur->av3);
         fbv =  cur->av2/(cur->av1+cur->av2+cur->av3);
         fpu = ((double)cur->au3-cur->au1)/((double)cur->au1+cur->au2+cur->au3);
         fbu =  cur->au2/(double)(cur->au1+cur->au2+cur->au3);
         fprintf(stdout, "%f\t%f\t%f\t%f\n", fpv, fbv, fpu, fbu);

       In the above example, we use both explicit type specification (for "av" columns) and type
       casting (for "au" columns) to ensure that all operations are performed in double
       precision.

       When an output file is specified, the selected input table is processed and output rows
       are copied to the output file.  Note that the output file can be specified as "stdout" in
       order to write the output rows to the standard output.  If the output file argument is
       passed, an optional third argument also can be passed to specify which columns to process.

       In a FITS binary table, it sometimes is desirable to copy all of the other FITS extensions
       to the output file as well. This can be done by appending a '+' sign to the name of the
       extension in the input file name. See funtable for a related example.

       funcalc works by integrating the user-specified expression into a template C program
       called tabcalc.c.  The completed program then is compiled and executed. Variable
       declarations that begin the funcalc expression are placed in the local declaration section
       of the template main program.  All other lines are placed in the template main program's
       inner processing loop. Other details of program generation are handled automatically. For
       example, column specifiers are analyzed to build a C struct for processing rows, which is
       passed to FunColumnSelect() and used in FunTableRowGet().  If an unknown variable is used
       in the expression, resulting in a compilation error, the program build is retried after
       defining the unknown variable to be of type double.

       Normally, funcalc expression code is added to funcalc row processing loop. It is possible
       to add code to other parts of the program by placing this code inside special directives
       of the form:

         [directive name]
           ... code goes here ...
         end

       The directives are:

       ·   global add code and declarations in global space, before the main routine.

       ·   local add declarations (and code) just after the local declarations in main

       ·   before add code just before entering the main row processing loop

       ·   after add code just after exiting the main row processing loop

       Thus, the following funcalc expression will declare global variables and make subroutine
       calls just before and just after the main processing loop:

         global
           double v1, v2;
           double init(void);
           double finish(double v);
         end
         before
           v1  = init();
         end
         ... process rows, with calculations using v1 ...
         after
           v2 = finish(v1);
           if( v2 < 0.0 ){
             fprintf(stderr, "processing failed %g -> %g\n", v1, v2);
             exit(1);
           }
         end

       Routines such as init() and finish() above are passed to the generated program for linking
       using the \-l [link directives ...]  switch. The string specified by this switch will be
       added to the link line used to build the program (before the funtools library). For
       example, assuming that init() and finish() are in the library libmysubs.a in the
       /opt/special/lib directory, use:

         funcalc  -l "-L/opt/special/lib -lmysubs" ...

       User arguments can be passed to a compiled funcalc program using a string argument to the
       "\-a" switch.  The string should contain all of the user arguments. For example, to pass
       the integers 1 and 2, use:

         funcalc -a "1 2" ...

       The arguments are stored in an internal array and are accessed as strings via the ARGV(n)
       macro.  For example, consider the following expression:

         local
           int pmin, pmax;
         end

         before
           pmin=atoi(ARGV(0));
           pmax=atoi(ARGV(1));
         end

         if( (cur->pha >= pmin) && (cur->pha <= pmax) )
           fprintf(stderr, "%d %d %d\n", cur->x, cur->y, cur->pha);

       This expression will print out x, y, and pha values for all rows in which the pha value is
       between the two user-input values:

         funcalc -a '1 12' -f foo snr.ev'[cir 512 512 .1]'
         512 512 6
         512 512 8
         512 512 5
         512 512 5
         512 512 8

         funcalc -a '5 6' -f foo snr.ev'[cir 512 512 .1]'
         512 512 6
         512 512 5
         512 512 5

       Note that it is the user's responsibility to ensure that the correct number of arguments
       are passed. The ARGV(n) macro returns a NULL if a requested argument is outside the limits
       of the actual number of args, usually resulting in a SEGV if processed blindly.  To check
       the argument count, use the ARGC macro:

         local
           long int seed=1;
           double limit=0.8;
         end

         before
           if( ARGC >= 1 ) seed = atol(ARGV(0));
           if( ARGC >= 2 ) limit = atof(ARGV(1));
           srand48(seed);
         end

         if ( drand48() > limit ) continue;

       The macro WRITE_ROW expands to the FunTableRowPut() call that writes the current row. It
       can be used to write the row more than once.  In addition, the macro NROW expands to the
       row number currently being processed. Use of these two macros is shown in the following
       example:

         if( cur->pha:I == cur->pi:I ) continue;
         a = cur->pha;
         cur->pha = cur->pi;
         cur->pi = a;
         cur->AVG:E  = (cur->pha+cur->pi)/2.0;
         cur->NR:I = NROW;
         if( NROW < 10 ) WRITE_ROW;

       If the \-p [prog] switch is specified, the expression is not executed. Rather, the
       generated executable is saved with the specified program name for later use.

       If the \-n switch is specified, the expression is not executed. Rather, the generated code
       is written to stdout. This is especially useful if you want to generate a skeleton file
       and add your own code, or if you need to check compilation errors. Note that the comment
       at the start of the output gives the compiler command needed to build the program on that
       platform. (The command can change from platform to platform because of the use of
       different libraries, compiler switches, etc.)

       As mentioned previously, funcalc will declare a scalar variable automatically (as a
       double) if that variable has been used but not declared.  This facility is implemented
       using a sed script named funcalc.sed, which processes the compiler output to sense an
       undeclared variable error.  This script has been seeded with the appropriate error
       information for gcc, and for cc on Solaris, DecAlpha, and SGI platforms. If you find that
       automatic declaration of scalars is not working on your platform, check this sed script;
       it might be necessary to add to or edit some of the error messages it senses.

       In order to keep the lexical analysis of funcalc expressions (reasonably) simple, we chose
       to accept some limitations on how accurately C comments, spaces, and new-lines are placed
       in the generated program. In particular, comments associated with local variables declared
       at the beginning of an expression (i.e., not in a local...end block) will usually end up
       in the inner loop, not with the local declarations:

         /* this comment will end up in the wrong place (i.e, inner loop) */
         double a; /* also in wrong place */
         /* this will be in the the right place (inner loop) */
         if( cur->x:D == cur->y:D ) continue; /* also in right place */
         a = cur->x;
         cur->x = cur->y;
         cur->y = a;
         cur->avg:E  = (cur->x+cur->y)/2.0;

       Similarly, spaces and new-lines sometimes are omitted or added in a seemingly arbitrary
       manner. Of course, none of these stylistic blemishes affect the correctness of the
       generated code.

       Because funcalc must analyze the user expression using the data file(s) passed on the
       command line, the input file(s) must be opened and read twice: once during program
       generation and once during execution. As a result, it is not possible to use stdin for the
       input file: funcalc cannot be used as a filter. We will consider removing this restriction
       at a later time.

       Along with C comments, funcalc expressions can have one-line internal comments that are
       not passed on to the generated C program. These internal comment start with the #
       character and continue up to the new\-line:

         double a; # this is not passed to the generated C file
         # nor is this
         a = cur->x;
         cur->x = cur->y;
         cur->y = a;
         /* this comment is passed to the C file */
         cur->avg:E  = (cur->x+cur->y)/2.0;

       As previously mentioned, input columns normally are identified by their being used within
       the inner event loop. There are rare cases where you might want to read a column and
       process it outside the main loop. For example, qsort might use a column in its sort
       comparison routine that is not processed inside the inner loop (and therefore not
       implicitly specified as a column to be read).  To ensure that such a column is read by the
       event loop, use the explicit keyword.  The arguments to this keyword specify columns that
       should be read into the input record structure even though they are not mentioned in the
       inner loop. For example:

         explicit pi pha

       will ensure that the pi and pha columns are read for each row, even if they are not
       processed in the inner event loop. The explicit statement can be placed anywhere.

       Finally, note that funcalc currently works on expressions involving FITS binary tables and
       raw event files. We will consider adding support for image expressions at a later point,
       if there is demand for such support from the community.

SEE ALSO

       See funtools(7) for a list of Funtools help pages