numericalio (Manual do Maxima)

## 63, numericalio

### 63.1, Introdução a numericalio

`numericalio` é uma coleção de funções para ler e escrever arquivos de dados. O arquivo é lido completamente para construir um objeto; leituras parciais não são suportadas.

É assumido que cada item a ler ou escrever é atômico: um número inteiro, número em ponto flutuante, grande número em ponto flutuante, seqüência de caracteres, ou símbolo, e não um número racional ou um número complexo ou qualquer outro tipo de expressão não atômica. Essas funções podem tentar fazer alguma coisa levemente parecida com expressões não atômicas, mas os resultados não são especificados aqui e são sujeitos a mudanças.

Átomos em ambos os arquivos de entrada e saída possuem o mesmo formato que em arquivos de lote do Maxima ou no console interativo. Em particular, seqüência de caracteres são contidas dentro de aspas duplas, contrabarra `\` evita qualquer interpretação especial do caractere seguinte, e o ponto de interrogação `?` é reconhecido no início de um símbolo para significar um símbolo do Lisp (em oposição a um símbolo do Maxima). Nenhum caractere de continuação (para continuar linhas quebradas) é reconhecido.

separator_flag diz que caracteres separa elementos. separator_flag é um argumento opcional para todas as funções de leitura e escrita.

Para entrada, os valores de separator_flag reconhecidos são: `comma` para valores separados por vírgula, `pipe` para valores separados pelo caractere barra vertical `|`, `semicolon` para valores separados por ponto e vírgula `;`, e `space` para valores separados pelos caracteres de espaço e de tabulação. Se o nome do arquivo a ser lido/escrito termina em `.csv` e separator_flag não for especificado, `comma` é assumido. Se o nome do arquivo termina em alguma outra coisa que não `.csv` e `separator_flag` não for especificado, `space` é assumido.

Para saída, os mesmos quatro sinalizadores são reconhecidos como na entrada, e também `tab`, para valores separados pelo caractere de tabulaçao.

Em entrada, múltiplos espaços e multiplas tabulações sucessivas contam como um separador simples. Todavia, múltiplas vírgulas, barras verticais, ou ponto-e-vírgulas são significativos. Sucessivas vírgulas, barras verticais, ou ponto-e-vírgulas (com ou sem intercalação de espaços ou tabulações) são considerados como tendo `false` entre os separadores. Por exemplo, `1234,,Foo` é tratado da mesma forma que `1234,false,Foo`. Em saídas, os átomos `false` são escritos como tais; uma lista `[1234, false, Foo]` é escrita `1234,false,Foo`, e não é tentado colapsar a saída para `1234,,Foo`.

### 63.2, Funções e Variáveis Definidas para numericalio

Função: read_matrix (nomearquivo) ¶
Função: read_matrix (nomearquivo, separator_flag) ¶

  Lê o arquivo nomearquivo e retorna seu conteúdo completo como uma matriz. Se separator_flag não for especificado, o arquivo é assumido como delimitado por espaços em branco.

  `read_matrix` infere o tamanho da matriz dos dados de entrada. Cada linha do arquivo inicia uma linha da matriz. Se algumas linhas possuirem diferentes comprimentos, `read_matrix` reclama.

Função: read_lisp_array (nomearquivo, A) ¶
Função: read_lisp_array (nomearquivo, A, separator_flag) ¶

  `read_lisp_array` exige que o array seja declarado através de `make_array` antes de chamar a função de leitura. (Isso obviamente é necessário para inferir a dimensão do array, que pode ser um problema para arrays com múltiplas dimensões.)

  `read_lisp_array` não verifica para ver se o arquivo de entrada está de acordo com as dimensãoes do array; a entrada é lida como uma lista monótona, então o array é preenchido usando `fillarray`.

Função: read_maxima_array (nomearquivo, A) ¶
Função: read_maxima_array (nomearquivo, A, separator_flag) ¶

  `read_maxima_array` requer que o array seja declarado através de `array` antes de chamar a função de leitura. (Isso obviamente é necessário para inferir a dimensão do array, que pode ser uma hassle para arrays com múltiplas dimensões.)

  `read_maxima_array` não verifica para ver se o arquivo de entrada está de acordo com as dimensãoes do array; a entrada é lida como uma lista monótona, então o array é preenchido usando `fillarray`.

Função: read_hashed_array (nomearquivo, A) ¶
Função: read_hashed_array (nomearquivo, A, separator_flag) ¶

  `read_hashed_array` trata o primeiro item sobre uma linha como uma chave hash, e associa o restante da linha (como uma lista) com a chava. Por exemplo, a linha `567 12 17 32 55` é equivalente a `A[567]: [12, 17, 32, 55]$`. Linhas não precisam ter o mesmo número de elementos.

Função: read_nested_list (nomearquivo) ¶
Função: read_nested_list (nomearquivo, separator_flag) ¶

  `read_nested_list` retorna uma lista que tem uma sublista para cada linha de entrada. Linhas não precisam ter o mesmo número de elementos. Linhas vazias não são ignoradas: uma linha vazia retorna uma sublista vazia.

Função: read_list (nomearquivo) ¶
Função: read_list (nomearquivo, separator_flag) ¶

  `read_list` lê todas as entradas em uma lista monótona. `read_list` ignora o caractere de fim de linha.

Função: write_data (X, nomearquivo) ¶
Função: write_data (object, nomearquivo, separator_flag) ¶

  `write_data` escreve o objeto X no arquivo nomearquivo.

  `write_data` escreve matrizes da forma usual, com uma linha por fileira.

  `write_data` escreve arrays declarados do Lisp e do Maxima da forma usual, com um caractere de nova linha no final de todo pedaço. Pedaços dimensionais muito grandes são separados por meio de novas linhas adicionais.

  `write_data` escreve arrays desordenados com uma chave seguida por a lista associada sobre cada linha.

  `write_data` escreve a lista seguinte com cada sublista em uma linha.

  `write_data` escreve uma lista monótona toda em uma linha.

  Se `write_data` anexa ao final ou abandona os excessos em seus arquivos de saída é governado através da variável global `file_output_append`.