Formato da saída de programa

removido
(usa Nenhuma)

Enviado em 19/06/2017 - 18:20h

A coisa pode ser estendida a programas em outras linguagens.

Tenho um programa em C que recebe duas entradas por linha de comando, esquema do tipo "argc/argv".

A dúvida é se a saída, que são dois números fica melhor com eles sendo impressos na mesma linha com um espaço em branco separando ou se em duas linhas. Ficando assim:

1.0000 2.0000 

ou

1.0000

2.0000 

Qual fica melhor para ser lido por outro programa, se for o caso ou em caso geral? Quando um é melhor que o outro?

paulo1205
(usa Ubuntu)

Enviado em 19/06/2017 - 22:41h

O que o programa leitor espera?

Se for um programa usando scanf() diretamente para variáveis de um tipo de ponto flutuante (ou usando std::istream::operator>>(double &)), os dois formatos vão dar exatamente o mesmo resultado.

Já se for um programa que lê linhas inteiras (como strings), e depois tenta extrair dessa string os dados relevantes, como se costuma fazer em várias linguagens de scripts, você teria de saber exatamente se o script espera um ou dois dados por linha.

removido
(usa Nenhuma)

Enviado em 19/06/2017 - 23:31h

Valeu. Vou pensar um pouco a respeito.

----------------------------------------------------------------------------------------------------------------
Nem direita, nem esquerda. Quando se trata de corrupção o Brasil é ambidestro.
(anônimo)

removido
(usa Nenhuma)

Enviado em 20/06/2017 - 18:39h

O que seria mais usual para ficar o mais parecido possível com programas de Unix?
Programa retornar float complexo em duas ou mais linhas ou retornar float complexo em uma linha com espaçamentos em branco?

----------------------------------------------------------------------------------------------------------------
Nem direita, nem esquerda. Quando se trata de corrupção o Brasil é ambidestro.
(anônimo)

paulo1205
(usa Ubuntu)

Enviado em 20/06/2017 - 23:04h

Bom, se for para chutar qual a forma mais comum pela qual programas enviariam números complexos entre si numa mesma máquina no UNIX, eu chutaria que eles passariam por pipes ou sockets em formato binário, mesmo.

Em 28 anos de C, eu nunca vi um programa fazendo uso do tipo _Complex, introduzido pelo C99. A lenta adoção do C99 (para computação científica, Fortran continua Reinaldo supremo, e a competição mais forte vem de C++, em vez de C puro; já para programação de sistemas, quem usa C geralmente ainda adere mais ao que já existia no ANSI C) e o reduzido escopo dos números complexos em Computação Numérica fora dos campos de Engenharia Elétrica e de Física Aplicada provavelmente também não ajudam a tornar comum a troca de dados complexos na forma de texto.

Também não ajuda o fato de que, mesmo introduzindo tipos complexos, o C não tenha criado nenhuma função de I/O de dados desses tipos, nem estendido as funções das famílias de printf() e scanf() com conversões próprias para eles, obrigando os programadores a fazer separadamente a escrita dos componentes do valor complexo, e a compor dados complexos a partir de duas variáveis reais, lidas separadamente.

Eu acho que, se eu estivesse na sua situação, eu tentaria não reinventar a roda. O C++ tem operadores para leitura e escrita de dados do tipo std::complex em streams. Para saída, os números têm sempre a forma “(parte_real,parte_imaginária)” (incluindo os parênteses e a vírgula). Para leitura, são aceitas, além da forma usada na escrita, as formas “valor_real” e “(valor_real)”. Eu veria também qual a forma usada pelo Fortran.

removido
(usa Nenhuma)

Enviado em 20/06/2017 - 23:27h

A entrada de dados é feita linha de comando e validada por expressões regulares.
Talvez uma ideia que você me deu seja escrever recebendo dados por pipe. Seria interessante.

Eu poderia tentar depois receber um lote de valores por pipe por linha e sair escrevendo os resultados com saídas por linha separadas por brancos.

O programa é mais para fazer uns testes de programação. Misturar coisas como números complexos e regex, que tem nada a ver. E agora usar pipe.

O tipo de dado que estou usando em C seria "double complex". Já vi escrito _Complex, mas os exemplos que vi usarem na internet estão assim.

Não tenho prática em qualquer coisa em C++, mas seria ótimo portar o programa para C++, portando para os recursos da linguagem.

Seria bom também dar uma olhada em Fortran.

No quesito expressões regulares estava quebrando a cabeça com uma coisa: saber se aquele tipo de expressão regular em avaliação é aceita, como (?(...)...|...). Revirei a internet inteira e nada. Nem sei onde dá para usar isto.

paulo1205
(usa Ubuntu)

Enviado em 21/06/2017 - 12:26h

Andei dando uma olhada em Fortran. No código, o que se costuma usar é a notação “(parte_real,part_imag)”. Na saída, por padrão, o formato é parecido com o do C++, mas com espaços entre os parênteses e a vírgula e os números.

      complex*32 z

      z=(1.1q0,2.2q0)

      write(*,*) z

      end 

Produz a seguinte saída (incluindo um espaço antes de abrir o parêntese):

 (  1.10000000000000000000000000000000008      ,  2.20000000000000000000000000000000015      ) 

Eu vi um problema com o C++: o separador entre as partes real e imaginárias é sempre uma vírgula, e isso pode dificultar o parser e causar ambiguidades se a locale selecionada usar vírgula como separador de casas decimais. Por exemplo: com a locale “pt_BR”, o valor complex<double>(1.1, 2.2) vai ser impresso como “(1,1,2,2)”, e os valores distintos complex<double>(1, 2.3) e complex<double>(1.2, 3) seriam ambos impressos como “(1,2,3)”.

Por um lado, é bom evitar o uso de locales não-padrão na hora de fazer a comunicação entre programas, pois nem sempre os eventuais receptores dos dados estarão prontos para tratar locales. Na verdade, é sempre prudente usar a locale padrão “C” quando se quer qualquer tipo deautomatização. Por outro lado, nem sempre se pode saber que a saída está ou será redirecionada para algum lugar, então como saber se se deve usar locale ou não? Eis aí um caso de caueat emptor (ou caueat usor).

Alternativamente, você poderia forçar a sempre imprimir casas decimais, mesmo quando o número for inteiro. Desse modo, seu parser poderia sempre tratar a segunda vírgula como separador entre a parte real e a parte imaginária.

#include <complex>

#include <iostream>

#include <iomanip>

#include <locale>



#include <cstdio>



using namespace std;



int main(){

    setlocale(LC_ALL, "pt_BR.UTF-8");

    cout << 1.5 << '\n';

    cout << complex<double>(1,2) << '\n';

    cout << complex<double>(1,2.3) << '\n';

    cout << complex<double>(1.2,3) << '\n';

    cout << complex<double>(1.2, 3.4) << '\n';

    locale pt_br("pt_BR.UTF-8");

    cout.imbue(pt_br);

    cout << "-----\n";

    cout << 1.5 << '\n';

    cout << complex<double>(1,2) << '\n';

    cout << complex<double>(1,2.3) << '\n';

    cout << complex<double>(1.2,3) << '\n';

    cout << complex<double>(1.2, 3.4) << '\n';

    cout << "-----\n";

    cout << setiosflags(ios::fixed) << setprecision(15);

    cout << 1.5 << '\n';

    cout << complex<double>(1,2) << '\n';

    cout << complex<double>(1,2.3) << '\n';

    cout << complex<double>(1.2,3) << '\n';

    cout << complex<double>(1.2, 3.4) << '\n';

}