funcalc - 云端在线

程序：

您的姓名

funcalc - Funtools 计算器（用于二进制表）

概要

函数计算 [-n] [-a argstr] [-e expr] [-f 文件] [-l 链接] [-p prog] [oname [列]]

配置

-a argstr # 传递给编译程序的用户参数
-e expr # 函数表达式
-f file # 包含 funcalc 表达式的文件
-l libs # 要添加到链接命令的库
-n # 输出生成的代码而不是编译执行
-p prog # 生成命名程序，不执行
-u # 如果任何变量未声明，则死亡（不要自动声明）

商品描述

函数计算 是一个允许构造任意表达式的计算器程序，
在 Funtools 表（FITS 二进制表或原始事件）中的列上编译和执行
文件）。 它的工作原理是将用户提供的表达式集成到模板 C 程序中，然后
编译和执行程序。 函数计算 表达式是 C 语句，尽管有些
支持重要的简化（例如变量的自动声明）。

函数计算 可以通过三种方式指定表达式：在命令行上使用 -e
[表达] 开关，在一个文件中使用 -f [文件] 切换，或从标准输入（如果两者都不是 -e
也不 -f 指定）。 当然一个文件包含 函数计算 表达式可以从
标准输入。

每次调用 函数计算 需要将输入 Funtools 表文件指定为
第一个命令行参数。 输出的 Funtools 表文件是第二个可选的
争论。 仅当正在创建输出 FITS 文件时才需要它（即，在
此 函数计算 表达式只打印值，不需要输出文件）。 如果输入输出
文件都被指定，第三个可选参数可以指定列的列表
激活（使用 FunColumnActivate()）。 注意 函数计算 决定是否
根据输出的存在与否生成用于编写输出文件的代码
文件参数。

A 函数计算 表达式在表的每一行上执行，由一个或多个 C 组成
对该行的列进行操作的语句（可能使用临时变量）。
在表达式中，引用的是 当前 使用 C 结构的行
句法 当前-[colname]>，例如cur->x、cur->pha等，可以定义局部标量变量
在表达式的最开始使用 C 声明，否则它们可以被定义
自动由 函数计算 （为双精度型）。 因此，例如，交换列 x
表中的 y 可以使用以下等效项之一执行 函数计算
表达式：

双温；
温度 = 当前-> x;
当前-> x = 当前-> y;
Cur-> y = 温度；

要么：

温度 = 当前-> x;
当前-> x = 当前-> y;
Cur-> y = 温度；

当使用以下命令执行此表达式时：

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

生成的文件将交换 x 和 y 列的值。

默认情况下，列的变量的数据类型与列的数据类型相同。
列存储在文件中。 这可以通过将“：[dtype]”附加到第一个来更改
对该列的引用。 在上面的示例中，要强制 x 和 y 输出为双精度值，
明确指定类型“D”：

温度 = 当前-> x:D;
当前-> x = 当前-> y:D;
Cur-> y = 温度；

数据类型说明符遵循使用 TFORM 定义列的标准 FITS 表语法：

·A：ASCII字符

· B：无符号8位字符

· I：有符号的 16 位整数

· U: unsigned 16-bit int (非标准FITS)

· J：有符号的 32 位整数

· V：无符号 32 位整数（非标准 FITS）

· E：32位浮点数

· D：64位浮点数

· X：位（视为字符数组）

请注意，只有对列的第一次引用才应包含显式数据类型
说明符。

当然，正确处理列的数据类型很重要。 其中一个
最常见的错误原因 函数计算 编程是对错误数据的隐式使用
表达式中的列的类型。 例如计算：

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

通常需要使用浮点运算来执行。 在 x 和 y 的情况下
列是整数，这可以通过使用显式将列读取为双精度来完成
型号规格：

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

或者，可以在表达式中使用 C 类型转换来完成：

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

除了访问当前行中的列，还可以参考
以前 行使用 上一个[colname]> 和 下页 行使用 下一个-[名称]>。 注意
if 上一个[colname]> 在 函数计算 表达式，第一行不是
处理。 如果 下一个-[colname]> 在 函数计算 表达式，最后一行
未处理。 通过这种方式， 上一页 和 下页 保证总是指向有效的行。
例如，要打印出当前 x 列和前一个 y 列的值，
在 a 中使用 C fprintf 函数 函数计算 表达：

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

可以使用相同的方法指定新列 当前-[colname]> 附加列的语法
类型（和可选的 tlmin/tlmax/binsiz 说明符），以冒号分隔。 例如，
cur->avg:D 将定义一个新的 double 类型的列。 类型说明符与那些相同
上面用于为现有列指定新数据类型。

例如，创建并输出一个新列，该列是 x 和 y 的平均值
列，可以定义一个新的“avg”列：

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

注意最后的';' 单行表达式不需要。

与 FITS TFORM 数据类型规范一样，列数据类型说明符可以放在前面
通过数字计数来定义数组，例如，“10I”表示 10 个短整数的向量，“2E”
意味着两个单精度浮点数等。一个新列只需要在一个
函数计算 表达式，之后无需重新指定类型即可使用。 这个
包括对列数组元素的引用：

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

'X'（位）数据类型被视为维数 (numeric_count/8) 的字符数组，即，
16X 作为 2 字节字符数组处理。 每个 8 位数组元素都被单独访问：

当前->统计[0]：16X = 1；
当前->统计[1] = 2;

这里创建了一个 16 位列，其中 MSB 设置为 1，LSB 设置为 2。

默认情况下，所有处理的行都写入指定的输出文件。 如果你想
跳过写入某些行，只需在末尾执行 C 的“continue”语句
函数计算 表达式，因为行的写入是在
表达式被执行。 例如，跳过写入平均值与
当前 x 值：

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)
继续;

如果没有指定输出文件参数 函数计算 命令行，没有输出文件
打开并且没有写入任何行。 这在仅打印输出的表达式中很有用
结果而不是生成新文件：

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

在上面的例子中，我们使用显式类型规范（对于“av”列）和类型
强制转换（对于“au”列）以确保所有操作都以双精度执行
精确。

指定输出文件时，处理选定的输入表并输出行
被复制到输出文件。 请注意，输出文件可以指定为“stdout”
为了将输出行写入标准输出。 如果输出文件参数是
通过，还可以传递可选的第三个参数来指定要处理的列。

在 FITS 二进制表中，有时需要复制所有其他 FITS 扩展
到输出文件也是如此。 这可以通过在名称后附加“+”号来完成
输入文件名中的扩展名。 看 有趣的 一个相关的例子。

函数计算 通过将用户指定的表达式集成到模板 C 程序中来工作
称为 tabcalc.c。 然后编译并执行完成的程序。 多变的
开始的声明 函数计算 表达式放在本地声明部分
模板主程序。 所有其他行都放在模板主程序的
内部处理循环。 程序生成的其他细节是自动处理的。 为了
例如，分析列说明符以构建用于处理行的 C 结构，即
传递给 FunColumnSelect() 并用于 FunTableRowGet(). 如果使用未知变量
在表达式中，导致编译错误，程序构建后重试
将未知变量定义为 double 类型。

通常情况下， 函数计算 表达式代码被添加到 函数计算 行处理循环。 有可能的
通过将此代码放在特殊指令中来将代码添加到程序的其他部分
形式：

[指令名称]
...代码在这里...
结束

指令是：

· 全球化 在主程序之前在全局空间中添加代码和声明。

· 本地 在 main 中的局部声明之后添加声明（和代码）

· before 在进入主行处理循环之前添加代码

· after 在退出主行处理循环后添加代码

因此，以下 函数计算 表达式将声明全局变量并生成子程序
在主处理循环之前和之后调用：

全球化
双 v1, v2;
双初始化（无效）；
双完成（双 v）；
结束
before
v1 = 初始化（）；
结束
... 处理行，使用 v1 进行计算 ...
after
v2 = 完成（v1）；
如果（ v2 < 0.0 ）{
fprintf(stderr, "处理失败 %g -> %g\n", v1, v2);
出口（1）;
}
结束

例程如 在里面（） 和 结束（） 以上传递给生成的程序进行链接
使用 -l [关联 指令 ...] 转变。 此开关指定的字符串将是
添加到用于构建程序的链接行（在 funtools 库之前）。 为了
例如，假设 在里面（） 和 结束（） 在库 libmysubs.a 中
/opt/special/lib 目录，使用：

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

可以使用字符串参数将用户参数传递给已编译的 funcalc 程序
“-a”开关。 该字符串应包含所有用户参数。 例如，要通过
整数 1 和 2，使用：

funcalc -a "1 2" ...

参数存储在内部数组中，并通过 ARGV(n) 作为字符串访问
宏。 例如，考虑以下表达式：

本地
整数 pmin, pmax;
结束

before
pmin=atoi(无人驾驶汽车(0))；
pmax=atoi(无人驾驶汽车(1))；
结束

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

此表达式将打印出所有 pha 值所在行的 x、y 和 pha 值
在两个用户输入值之间：

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

请注意，确保参数的正确数量是用户的责任
通过。 如果请求的参数超出限制，则 ARGV(n) 宏返回 NULL
args 的实际数量，如果盲目处理，通常会导致 SEGV。 去检查
参数计数，使用 ARGC 宏：

本地
长整数种子=1；
双限=0.8；
结束

before
if( ARGC >= 1 ) 种子 = atol(无人驾驶汽车(0))；
if( ARGC >= 2 ) limit = atof(无人驾驶汽车(1))；
srand48（种子）；
结束

如果（drand48（）> 限制）继续；

宏 WRITE_ROW 扩展为 FunTableRowPut() 写入当前行的调用。 它
可用于多次写入该行。 此外，宏 NROW 扩展为
当前正在处理的行号。 这两个宏的使用如下所示
例：

if( cur->pha:I == cur->pi:I ) 继续；
a = cur->pha;
cur->pha = cur->pi;
当前-> pi = a;
cur->AVG:E = (cur->pha+cur->pi)/2.0;
当前-> NR:I = NROW;
如果( NROW < 10 ) WRITE_ROW;

如果 -p [编] 指定开关，则不执行表达式。 而是，
生成的可执行文件以指定的程序名称保存以备后用。

如果 -n 指定开关，则不执行表达式。 相反，生成的代码
写入标准输出。 如果您想生成骨架文件，这尤其有用
并添加您自己的代码，或者如果您需要检查编译错误。 注意评论
在输出的开头给出了在其上构建程序所需的编译器命令
平台。 （该命令可能因平台而异，因为使用
不同的库、编译器开关等）

如前所述， 函数计算 将自动声明一个标量变量（作为
double) 如果该变量已被使用但未声明。 该设施已实施
使用名为 funcalc.sed 的 sed 脚本，该脚本处理编译器输出以感知
未声明的变量错误。 此脚本已植入适当的错误
gcc 和 cc 在 Solaris、DecAlpha 和 SGI 平台上的信息。 如果你发现
标量的自动声明在您的平台上不起作用，请检查此 sed 脚本；
可能需要添加或编辑它检测到的一些错误消息。

为了保持词法分析 函数计算 表达（相当）简单，我们选择
接受一些关于 C 注释、空格和换行的准确度的限制
在生成的程序中。 特别是，与声明的局部变量相关的注释
在表达式的开头（即，不在 本地...结束 块）通常会结束
在内部循环中，而不是局部声明：

/* 这个注释会在错误的地方结束（即内循环）*/
双一; /* 也在错误的地方 */
/* 这将在正确的位置（内循环） */
if( cur->x:D == cur->y:D ) 继续； /* 也在正确的位置 */
a = 当前-> x;
当前-> x = 当前-> y;
cur->y = a;
cur->avg:E = (cur->x+cur->y)/2.0;

同样，有时会以看似随意的方式省略或添加空格和换行符
方式。 当然，这些风格上的瑕疵都不会影响
生成的代码。

计划 函数计算 必须使用传递的数据文件分析用户表达式
命令行，输入文件必须打开并读取两次：在程序中一次
生成和执行期间一次。 因此，不可能将 stdin 用于
输入文件： 函数计算 不能用作过滤器。 我们会考虑取消这个限制
晚些时候。

连同 C 注释， 函数计算 表达式可以有一行内部注释
不会传递给生成的 C 程序。 这些内部注释以 #
字符并继续到新行：

双一; # 这不会传递给生成的 C 文件
# 这也不是
a = 当前-> x;
当前-> x = 当前-> y;
cur->y = a;
/* 这个注释被传递到 C 文件 */
cur->avg:E = (cur->x+cur->y)/2.0;

如前所述，输入列通常通过它们在
内部事件循环。 在极少数情况下，您可能想要阅读一列并
在主循环之外处理它。 例如，qsort 可能在其排序中使用一列
在内循环内未处理的比较例程（因此不
隐式指定为要读取的列）。 为了确保这样的列被读取
事件循环，使用 明确的 关键词。 此关键字的参数指定列
应该被读入输入记录结构，即使它们没有在
内循环。 例如：

显式 pi pha

将确保为每一行读取 pi 和 pha 列，即使它们不是
在内部事件循环中处理。 这 明确的 语句可以放在任何地方。

最后，请注意 函数计算 目前正在处理涉及 FITS 二进制表的表达式和
原始事件文件。 我们稍后会考虑添加对图像表达式的支持，
如果社区需要此类支持。

使用 onworks.net 服务在线使用 funcalc