funcalc - Online na nuvem

PROGRAMA:

NOME

funcalc - Calculadora Funtools (para tabelas binárias)

SINOPSE

funcalc [-n] [-a argstr] [-e expr] [-f arquivo] [-l link] [-p prog] [oname [colunas]]

OPÇÕES

-a argstr # argumentos do usuário a serem transmitidos ao programa compilado
-e expr # expressão funcalc
-f arquivo # arquivo contendo expressão funcalc
-l libs # libs para adicionar ao comando de link
-n # produz o código gerado em vez de compilar e executar
-p prog # gera programa nomeado, sem execução
-u # morre se qualquer variável não for declarada (não declara automaticamente)

DESCRIÇÃO

funcalc é um programa de calculadora que permite a construção de expressões arbitrárias,
compilado e executado em colunas em uma tabela Funtools (tabela binária FITS ou evento bruto
Arquivo). Ele funciona integrando expressão (ões) fornecida (s) pelo usuário em um programa C modelo, então
compilar e executar o programa. funcalc expressões são declarações C, embora alguns
simplificações importantes (como a declaração automática de variáveis) são suportadas.

funcalc expressões podem ser especificadas de três maneiras: na linha de comando usando o -e
[expressão] switch, em um arquivo usando o -f [Arquivo] switch, ou de stdin (se nenhum -e
nem -f é especificado). Claro, um arquivo contendo funcalc expressões podem ser lidas de
padrão

Cada invocação de funcalc requer que um arquivo de tabela Funtools de entrada seja especificado como o
primeiro argumento da linha de comando. O arquivo da tabela de saída do Funtools é o segundo opcional
argumento. É necessário apenas se um arquivo FITS de saída estiver sendo criado (ou seja, nos casos em que
que o funcalc expressão apenas imprime valores, nenhum arquivo de saída é necessário). Se entrada e saída
arquivo são especificados, um terceiro argumento opcional pode especificar a lista de colunas para
ativar (usando FunColumnActivate ()) Observe que funcalc determina se deve ou não
gerar código para escrever um arquivo de saída com base na presença ou ausência de uma saída
argumento do arquivo.

A funcalc expressão é executada em cada linha de uma tabela e consiste em um ou mais C
instruções que operam nas colunas dessa linha (possivelmente usando variáveis ​​temporárias).
Dentro de uma expressão, a referência é feita a uma coluna do atual linha usando a estrutura C
sintaxe atualmente[nomedocol]>, por exemplo, cur-> x, cur-> pha, etc. Variáveis ​​escalares locais podem ser definidas
usando declarações C no início da expressão, ou então elas podem ser definidas
automaticamente por funcalc (para ser do tipo duplo). Assim, por exemplo, uma troca de colunas x
e y em uma tabela podem ser executados usando qualquer um dos seguintes equivalentes funcalc
expressões:

temperatura dupla;
temp = curva-> x;
cur-> x = cur-> y;
cur-> y = temp;

ou:

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

Quando esta expressão é executada usando um comando como:

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

o arquivo resultante terá os valores das colunas xey trocados.

Por padrão, o tipo de dados da variável para uma coluna é o mesmo que o tipo de dados do
coluna conforme armazenado no arquivo. Isso pode ser alterado anexando ": [dtype]" ao primeiro
referência a essa coluna. No exemplo acima, para forçar x e y a serem produzidos como duplos,
especifique o tipo 'D' explicitamente:

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

Os especificadores de tipo de dados seguem a sintaxe da tabela FITS padrão para definir colunas usando TFORM:

· A: caracteres ASCII

· B: char de 8 bits sem sinal

· I: int assinado de 16 bits

· U: int de 16 bits sem sinal (não FITS padrão)

· J: int de 32 bits assinado

· V: int de 32 bits sem sinal (não FITS padrão)

· E: flutuação de 32 bits

· D: flutuação de 64 bits

· X: bits (tratado como uma matriz de caracteres)

Observe que apenas a primeira referência a uma coluna deve conter o tipo de dados explícito
especificador.

Obviamente, é importante tratar o tipo de dados das colunas corretamente. Um dos
causa mais frequente de erro em funcalc programação é o uso implícito de dados errados
digite para uma coluna na expressão. Por exemplo, o cálculo:

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

geralmente precisa ser executado usando aritmética de ponto flutuante. Nos casos em que x e y
colunas são inteiros, isso pode ser feito lendo as colunas como duplas usando um explícito
especificação de tipo:

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

Como alternativa, isso pode ser feito usando conversão de tipo C na expressão:

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

Além de acessar colunas na linha atual, também pode ser feita referência ao
anterior linha usando anterior-[colname]>, e para o Próximo linha usando próximo-[colname]>. Observe que
if anterior-[colname]> é especificado no funcalc expressão, a primeira linha não é
processado. Se próximo-[colname]> é especificado no funcalc expressão, a última linha
não é processado. Desta maneira, prev e Próximo têm a garantia de sempre apontar para linhas válidas.
Por exemplo, para imprimir os valores da coluna x atual e da coluna y anterior,
usar a função C fprintf em um funcalc expressão:

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

Novas colunas podem ser especificadas usando o mesmo atualmente[colname]> sintaxe anexando a coluna
tipo (e especificadores opcionais tlmin / tlmax / binsiz), separados por dois pontos. Por exemplo,
cur-> avg: D irá definir uma nova coluna do tipo double. Especificadores de tipo são os mesmos
usado acima para especificar novos tipos de dados para colunas existentes.

Por exemplo, para criar e gerar uma nova coluna que é o valor médio de x e y
colunas, uma nova coluna "média" pode ser definida:

cur-> média: D = (cur-> x + cur-> y) / 2.0

Observe que o ';' final não é necessário para expressões de linha única.

Tal como acontece com a especificação do tipo de dados FITS TFORM, o especificador de tipo de dados da coluna pode ser precedido
por uma contagem numérica para definir uma matriz, por exemplo, "10I" significa um vetor de 10 ints curtos, "2E"
significa dois flutuadores de precisão simples, etc. Uma nova coluna só precisa ser definida uma vez em um
funcalc expressão, após o qual pode ser usado sem especificar novamente o tipo. Esse
inclui referência a elementos de uma matriz de coluna:

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

O tipo de dados 'X' (bits) é tratado como uma matriz char de dimensão (numeric_count / 8), ou seja,
16X é processado como uma matriz de caracteres de 2 bytes. Cada elemento da matriz de 8 bits é acessado separadamente:

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

Aqui, uma coluna de 16 bits é criada com o MSB definido como 1 e o LSB definido como 2.

Por padrão, todas as linhas processadas são gravadas no arquivo de saída especificado. Se você quiser
pule a escrita de certas linhas, simplesmente execute a instrução C "continue" no final do
funcalc expressão, uma vez que a escrita da linha é realizada imediatamente após o
expressão é executada. Por exemplo, para pular a gravação de linhas cuja média seja igual à
valor x atual:

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

Se nenhum argumento de arquivo de saída for especificado no funcalc linha de comando, nenhum arquivo de saída é
aberto e nenhuma linha é gravada. Isso é útil em expressões que simplesmente imprimem a saída
resultados em vez de gerar um novo arquivo:

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 / (duplo) (cur-> au1 + cur-> au2 + cur-> au3);
fprintf (stdout, "% f \ t% f \ t% f \ t% f \ n", fpv, fbv, fpu, fbu);

No exemplo acima, usamos a especificação de tipo explícita (para colunas "av") e o tipo
fundição (para colunas "au") para garantir que todas as operações sejam realizadas em dupla
precisão.

Quando um arquivo de saída é especificado, a tabela de entrada selecionada é processada e as linhas de saída
são copiados para o arquivo de saída. Observe que o arquivo de saída pode ser especificado como "stdout" em
para gravar as linhas de saída na saída padrão. Se o argumento do arquivo de saída for
passado, um terceiro argumento opcional também pode ser passado para especificar quais colunas processar.

Em uma tabela binária FITS, às vezes é desejável copiar todas as outras extensões FITS
para o arquivo de saída também. Isso pode ser feito anexando um sinal '+' ao nome do
extensão no nome do arquivo de entrada. Ver divertida para um exemplo relacionado.

funcalc funciona integrando a expressão especificada pelo usuário em um programa modelo C
chamado tabcalc.c. O programa completo é então compilado e executado. Variável
declarações que começam a funcalc expressão são colocados na seção de declaração local
do programa principal do modelo. Todas as outras linhas são colocadas no programa principal do modelo
loop de processamento interno. Outros detalhes da geração do programa são tratados automaticamente. Para
exemplo, especificadores de coluna são analisados ​​para construir uma estrutura C para processar linhas, que é
passado para FunColumnSelect () e usado em FunTableRowGet (). Se uma variável desconhecida for usada
na expressão, resultando em um erro de compilação, a construção do programa é repetida após
definindo a variável desconhecida para ser do tipo double.

Normalmente, funcalc código de expressão é adicionado a funcalc loop de processamento de linha. É possível
adicionar código a outras partes do programa, colocando este código dentro de diretivas especiais
do formulário:

[nome da diretiva]
... o código vai aqui ...
final

As diretrizes são:

· global adicione código e declarações no espaço global, antes da rotina principal.

· local adicione declarações (e código) logo após as declarações locais no principal

· antes adicione o código antes de entrar no loop de processamento da linha principal

· depois de adicione o código logo após sair do loop de processamento da linha principal

Assim, o seguinte funcalc expressão irá declarar variáveis ​​globais e criar sub-rotina
chamadas imediatamente antes e logo após o loop de processamento principal:

global
duplo v1, v2;
inicialização dupla (vazio);
acabamento duplo (duplo v);
final
antes
v1 = init ();
final
... processar linhas, com cálculos usando v1 ...
depois de
v2 = terminar (v1);
if (v2 <0.0) {
fprintf (stderr, "processamento falhou% g ->% g \ n", v1, v2);
saída(1);
}
final

Rotinas como iniciar() e Finalizar() acima são passados ​​para o programa gerado para vinculação
usando o -l [ligação directivas ...] trocar. A string especificada por esta opção será
adicionado à linha de link usada para construir o programa (antes da biblioteca funtools). Para
exemplo, assumindo que iniciar() e Finalizar() estão na biblioteca libmysubs.a no
diretório / opt / special / lib, use:

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

Os argumentos do usuário podem ser passados ​​para um programa funcalc compilado usando um argumento de string para o
"-uma troca. A string deve conter todos os argumentos do usuário. Por exemplo, para passar
os inteiros 1 e 2, use:

funcalc -a "1 2" ...

Os argumentos são armazenados em uma matriz interna e são acessados ​​como strings por meio do ARGV (n)
macro. Por exemplo, considere a seguinte expressão:

local
int pmín, pmáx;
final

antes
pmin = atoi (ARGV(0));
pmax = atoi (ARGV(1));
final

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

Esta expressão irá imprimir os valores x, y e pha para todas as linhas em que o valor pha é
entre os dois valores de entrada do usuário:

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

Observe que é responsabilidade do usuário garantir que o número correto de argumentos
Estão passados. A macro ARGV (n) retorna um NULL se um argumento solicitado estiver fora dos limites
do número real de args, geralmente resultando em SEGV se processado às cegas. Checar
a contagem de argumentos, use a macro ARGC:

local
semente interna longa = 1;
limite duplo = 0.8;
final

antes
if (ARGC> = 1) seed = atol (ARGV(0));
if (ARGC> = 2) limit = atof (ARGV(1));
srand48 (semente);
final

if (drand48 ()> limit) continue;

A macro WRITE_ROW se expande para o FunTableRowPut () chamada que grava a linha atual. Isto
pode ser usado para escrever a linha mais de uma vez. Além disso, a macro NROW se expande para o
número da linha atualmente em processamento. O uso dessas duas macros é mostrado a seguir
exemplo:

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;

Se o -p [prog] switch for especificado, a expressão não será executada. Em vez disso, o
O executável gerado é salvo com o nome do programa especificado para uso posterior.

Se o -n switch for especificado, a expressão não será executada. Em vez disso, o código gerado
é gravado em stdout. Isso é especialmente útil se você deseja gerar um arquivo esqueleto
e adicione seu próprio código, ou se você precisar verificar erros de compilação. Observe que o comentário
no início da saída dá o comando do compilador necessário para construir o programa naquele
plataforma. (O comando pode mudar de plataforma para plataforma devido ao uso de
diferentes bibliotecas, opções de compilador, etc.)

Como dito anteriormente, funcalc irá declarar uma variável escalar automaticamente (como um
double) se essa variável foi usada, mas não declarada. Esta facilidade foi implementada
usando um script sed denominado funcalc.sed, que processa a saída do compilador para detectar um
erro de variável não declarada. Este script foi semeado com o erro apropriado
informações para gcc e para cc nas plataformas Solaris, DecAlpha e SGI. Se você encontrar isso
a declaração automática de escalares não está funcionando em sua plataforma, verifique este script sed;
pode ser necessário adicionar ou editar algumas das mensagens de erro detectadas.

A fim de manter a análise lexical de funcalc expressões (razoavelmente) simples, escolhemos
aceitar algumas limitações sobre a precisão com que comentários C, espaços e novas linhas são colocados
no programa gerado. Em particular, comentários associados a variáveis ​​locais declaradas
no início de uma expressão (ou seja, não em um local ... fim bloco) geralmente acabará
no loop interno, não com as declarações locais:

/ * este comentário terminará no lugar errado (ou seja, loop interno) * /
duplo a; / * também no lugar errado * /
/ * estará no lugar certo (loop interno) * /
if (cur-> x: D == cur-> y: D) continue; / * também no lugar certo * /
a = cur-> x;
cur-> x = cur-> y;
cur-> y = a;
cur-> média: E = (cur-> x + cur-> y) /2.0;

Da mesma forma, espaços e novas linhas às vezes são omitidos ou adicionados de uma forma aparentemente arbitrária
maneiras. Claro, nenhuma dessas manchas estilísticas afetam a exatidão do
código gerado.

Porque funcalc deve analisar a expressão do usuário usando o (s) arquivo (s) de dados passado (s) no
linha de comando, os arquivos de entrada devem ser abertos e lidos duas vezes: uma vez durante o programa
geração e uma vez durante a execução. Como resultado, não é possível usar stdin para o
Arquivo de entrada: funcalc não pode ser usado como filtro. Vamos considerar a remoção dessa restrição
Mais tarde.

Junto com os comentários C, funcalc expressões podem ter comentários internos de uma linha que são
não repassado para o programa C gerado. Esses comentários internos começam com o #
personagem e continue até a nova linha:

duplo a; # isso não é passado para o arquivo C gerado
# nem é isso
a = cur-> x;
cur-> x = cur-> y;
cur-> y = a;
/ * este comentário é passado para o arquivo C * /
cur-> média: E = (cur-> x + cur-> y) /2.0;

Como mencionado anteriormente, as colunas de entrada normalmente são identificadas por serem usadas dentro
o loop de evento interno. Existem casos raros em que você pode querer ler uma coluna e
processá-lo fora do loop principal. Por exemplo, qsort pode usar uma coluna em sua classificação
rotina de comparação que não é processada dentro do loop interno (e, portanto, não
especificado implicitamente como uma coluna a ser lida). Para garantir que tal coluna seja lida pelo
loop de eventos, use o explícito palavra-chave. Os argumentos para esta palavra-chave especificam colunas que
devem ser lidos na estrutura do registro de entrada, mesmo que não sejam mencionados no
laço interno. Por exemplo:

pi pha explícito

irá garantir que as colunas pi e pha sejam lidas para cada linha, mesmo que não sejam
processado no loop de evento interno. o explícito declaração pode ser colocada em qualquer lugar.

Finalmente, observe que funcalc atualmente trabalha em expressões envolvendo tabelas binárias FITS e
arquivos de eventos brutos. Consideraremos a adição de suporte para expressões de imagem posteriormente,
se houver demanda para tal apoio por parte da comunidade.

Use funcalc online usando serviços onworks.net