Manual do Maxima 5.41.0: 69. stringproc

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 69. stringproc

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 69.1 Introdução a manipulação de sequências de caracteres

O ficheiro `stringproc.lisp` amplia a compatibilidade do Maxima de trabalhar com sequências de caracteres e adiciona algumas funções úteis a entrada e saída de dados.

Para esclarecimentos e erros por favor mande um e-mail para van.nek at arcor.de .

Para disponibilizar `stringproc.lisp` para uso digite `load("stringproc");`.

No Maxima uma sequência de caracteres é facilmente contruída digitando "texto" (qualquer texto desejado entre aspas duplas). Note que sequências de caracteres do Maxima não são sequências de caracteres do Lisp e vice-versa. Testes podem ser concluídos com `stringp` e `lstringp`. Se por alguma razão tiver um valor, que é uma sequência de caracteres do Lisp, talvez quando estiver usando a função `sconcat` do Maxima, poderá converter via `sunlisp`.

    (%i1) load("stringproc")$
    (%i2) m: "text";
    (%o2)                         text
    (%i3) [stringp(m),lstringp(m)];
    (%o3)                     [true, false]
    (%i4) l: sconcat("text");
    (%o4)                         text
    (%i5) [stringp(l),lstringp(l)];
    (%o5)                     [false, true]
    (%i6) stringp( sunlisp(l) );
    (%o6)                         true

Todas as funções em `stringproc.lisp`, que retornarem sequências de caracteres, retornam sequências de caracteres do Maxima.

Caracteres são introduzidos como sequências de caracteres do Maxima de comprimento 1. Com certeza, esses caracteres não são caracteres do Lisp. Testes podem ser realizados com `charp` ( `lcharp` e conversões do Lisp para o Maxima com `cunlisp`).

    (%i1) load("stringproc")$
    (%i2) c: "e";
    (%o2)                           e
    (%i3) [charp(c),lcharp(c)];
    (%o3)                     [true, false]
    (%i4) supcase(c);
    (%o4)                           E
    (%i5) charp(%);
    (%o5)                         true

Novamente, todas as funções em `stringproc.lisp`, que retornam caracteres, retornam caracteres do Maxima. devido a esse facto, que os caracteres introduzidos são sequências de caracteres de comprimento 1, pode usar muitas das funções de sequência de caracteres também para caracteres. Como visto, `supcase` é um exemplo.

É importante saber, que o primeiro caractere em uma sequência de caracteres do Maxima éstá na posição 1. Isso é designado devido ao facto de o primeiro elemento em uma lista do Maxima está na posição 1 também. Veja definições de `charat` e de `charlist` para obter exemplos.

Em aplicações fnções de sequência de caractere são muitas vezes usadas quando estamos trabalhando com ficheiros. Poderá encontrará algumas funções úteis de fluxo e de impressão em `stringproc.lisp`. O seguinte exemplo mostra algumas das funções aqui introduzidas no trabalho.

Exemplo:

`openw` retorna um fluxo de saída para um ficheiro, `printf` então permite escrita formatada para esse ficheiro. Veja `printf` para detalhes.

    (%i1) load("stringproc")$
    (%i2) s: openw("E:/file.txt");
    (%o2)                    #<output stream E:/file.txt>
    (%i3) for n:0 thru 10 do printf( s, "~d ", fib(n) );
    (%o3)                                done
    (%i4) printf( s, "~%~d ~f ~a ~a ~f ~e ~a~%",
                  42,1.234,sqrt(2),%pi,1.0e-2,1.0e-2,1.0b-2 );
    (%o4)                                false
    (%i5) close(s);
    (%o5)                                true

Após fechar o fluxo pode abrí-lo novamente, dessa vez com direção de entrada. `readline` retorna a linha completa como uma sequência de caracteres. O pacote `stringproc` agora oferece muitas funções para manipulação de sequências de caracteres. A troca de indicações/fichas pode ser realizada por `split` ou por `tokens`.

    (%i6) s: openr("E:/file.txt");
    (%o6)                     #<input stream E:/file.txt>
    (%i7) readline(s);
    (%o7)                     0 1 1 2 3 5 8 13 21 34 55
    (%i8) line: readline(s);
    (%o8)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
    (%i9) list: tokens(line);
    (%o9)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
    (%i10) map( parsetoken, list );
    (%o10)           [42, 1.234, false, false, 0.01, 0.01, false]

`parsetoken` somente analiza números inteiros e em ponto flutuante. A análise de símbolos ou grandes números em ponto flutuante precisa de `parse_string`, que pode ser disponibilizada para uso através de `eval_string.lisp`.

    (%i11) load("eval_string")$
    (%i12) map( parse_string, list );
    (%o12)           [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
    (%i13) float(%);
    (%o13) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01, 0.01, 0.01]
    (%i14) readline(s);
    (%o14)                               false
    (%i15) close(s)$

`readline` retorna `false` quado o fim de ficheiro acontecer.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 69.2 Definições para entrada e saída

Exemplo:

    (%i1) load("stringproc")$
    (%i2) s: openw("E:/file.txt");
    (%o2)                     #<output stream E:/file.txt>
    (%i3) control:
    "~2tAn atom: ~20t~a~%~2tand a list: ~20t~{~r ~}~%~2tand an integer: ~20t~d~%"$
    (%i4) printf( s,control, 'true,[1,2,3],42 )$
    (%o4)                                false
    (%i5) close(s);
    (%o5)                                true
    (%i6) s: openr("E:/file.txt");
    (%o6)                     #<input stream E:/file.txt>
    (%i7) while stringp( tmp:readline(s) ) do print(tmp)$
      An atom:          true
      and a list:       one two three
      and an integer:   42
    (%i8) close(s)$

Função: close (fluxo)

  Fecha fluxo e retorna `true` se fluxo tiver sido aberto anteriormente.

Função: flength (fluxo)

  Retorna o número de elementos em fluxo.

Função: fposition (fluxo)
Função: fposition (fluxo, pos)

  Retorna a posição corrente em fluxo, se pos não está sendo usada. Se pos estiver sendo usada, `fposition` escolhe a posição em fluxo. pos tem que ser um número positivo, o primeiro elemento em fluxo está na posição 1.

Função: freshline ()
Função: freshline (fluxo)

  escreve uma nova linha (em fluxo), se a posição actual não for um início de linha. Veja também `newline`.

Função: newline ()
Função: newline (fluxo)

  Escreve uma nova linha (para fluxo). Veja `sprint` para um exemplo de uso de `newline()`. Note que existem alguns casos, onde `newline()`não trabalha como esperado.

Função: opena (ficheiro)

  Retorna um fluxo de saída para ficheiro. Se um ficheiro já existente tiver sido aberto, `opena` anexa os elementos ao final do ficheiro.

Função: openr (ficheiro)

  Retorna um fluxo para ficheiro. Se ficheiro não existir, ele será criado.

Função: openw (ficheiro)

  Retorna um fluxo de saída para ficheiro. Se ficheiro não existir, será criado. Se um ficheiro já existente for aberto, `openw` modifica destrutivametne o ficheiro.

Função: printf (dest, seq_caracte)
Função: printf (dest, seq_caracte, expr_1, ..., expr_n)

  Torna a função FORMAT do Lisp Comum disponível no Maxima. (Retirado de gcl.info: "format produces formatted output by outputting the caracteres of control-string string and observing that a tilde introduces a directive. The caractere after the tilde, possibly preceded by prefix parameters and modifiers, specifies what kind of formatting is desired. Most directives use one or more elements of args to create their output.")

  A seguinte descrição e oa exemplos podem fornecer uma idéia de uso de `printf`. Veja um referência de Lisp para maiores informações.

         ~%       nova linha
         ~&       novíssima line
         ~t       tabulação
         ~$       monetário
         ~d       inteiro decimal
         ~b       inteiro binário
         ~o       inteiro octal
         ~x       inteiro hexadecimal
         ~br      inteiro de base b
         ~r       soletra um inteiro
         ~p       plural
         ~f       ponto flutuante
         ~e       notação científica
         ~g       ~f ou ~e, dependendo  da magnitude
         ~a       como mostrado pela função print do Maxima
         ~s       sequências de caracteres entre "aspas duplas"
         ~~       ~
         ~<       justificação de texto, ~> terminador de justificação de texto
         ~(       conversão de caixa alta/baixa, ~) terminador de conversão de caixa
         ~[       selecção, ~] terminador de selecção
         ~{       iteração, ~} terminador de iteração

  Por favor note que não existe especificador de formato para grandes números em ponto flutuante. Todavia grandes números em ponto flutuante podem simplesmente serem mostrados por meio da directiva `~a`. `~s` mostra as sequências de caracteres entre "aspas duplas"; pode evitar isso usando `~a`. Note que a directiva de selecção `~[` é indexada em zero. Também note que existem algumas directivas, que não trabalham no Maxima. Por exemplo, `~:[` falha.

      (%i1) load("stringproc")$
      (%i2) printf( false, "~a ~a ~4f ~a ~@r",
                    "String",sym,bound,sqrt(12),144), bound = 1.234;
      (%o2)                 String sym 1.23 2*sqrt(3) CXLIV
      (%i3) printf( false,"~{~a ~}",["one",2,"THREE"] );
      (%o3)                          one 2 THREE
      (%i4) printf( true,"~{~{~9,1f ~}~%~}",mat ),
                    mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
            1.1       2.0       3.3
            4.0       5.0       6.0
            7.0       8.9       9.0
      (%i5) control: "~:(~r~) bird~p ~[is~;are~] singing."$
      (%i6) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
      (%o6)                    Two birds are singing.

  Se dest for um fluxo ou `true`, então `printf` retorna `false`. De outra forma, `printf` retorna uma sequência de caracteres contendo a saída.

Função: readline (fluxo)

  Retorna uma sequência de caracteres contendo os caracteres a partir da posição corrente em fluxo até o fim de linha ou false se o fim de linha do ficheiro for encontrado.

Função: sprint (expr_1, ..., expr_n)

  Avalia e mostra seus argumentos um após o outro `sobre uma linha' iniciando na posição mais à esquerda. Os números são mostrados com o '-' à direita do número, e isso desconsidera o comprimento da linha. `newline()`, que pode ser chamada a partir de `stringproc.lisp` pode ser útil, se desejar colocar uma parada de linha intermédia.

      (%i1) for n:0 thru 22 do sprint( fib(n) )$
      0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711
      (%i2) load("stringproc")$
      (%i3) for n:0 thru 22 do (
               sprint(fib(n)), if mod(n,10)=9 then newline() )$
      0 1 1 2 3 5 8 13 21 34
      55 89 144 233 377 610 987 1597 2584 4181
      6765 10946 17711

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 69.3 Definições para caracteres

Função: alphacharp (caractere)

  Retorna `true` se caractere for um caractere alfabético.

Função: alphanumericp (caractere)

  Retorna `true` se caractere for um caractere alfabético ou um dígito.

Função: ascii (int)

  Retorna o caractere correspondente ao código numérico ASCII int. ( -1 < int < 256 )

      (%i1) load("stringproc")$
      (%i2) for n from 0 thru 255 do (
      tmp: ascii(n), if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
      A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
      a b c d e f g h i j k l m n o p q r s t u v w x y z

Função: cequal (caractere_1, caractere_2)

  Retorna `true` se caractere_1 e caractere_2 forem os mesmos.

Função: cequalignore (caractere_1, caractere_2)

  como `cequal` mas ignora a caixa alta/baixa.

Função: cgreaterp (caractere_1, caractere_2)

  Retorna `true` se o código numérico ASCII do caractere_1 for maior que o código numérico ASCII do caractere_2.

Função: cgreaterpignore (caractere_1, caractere_2)

  Como `cgreaterp` mas ignora a caixa alta/baixa.

Função: charp (obj)

  Retorna `true` se obj for um caractere do Maxima. Veja na seção "Introdução a manipulação de sequências de caracteres" para ter um exemplo.

Função: cint (caractere)

  Retorna o código numéico ASCII de caractere.

Função: clessp (caractere_1, caractere_2)

  Retorna `true` se o código numérico ASCII de caractere_1 for menor que o código numérico ASCII de caractere_2.

Função: clesspignore (caractere_1, caractere_2)

  Como em `clessp` ignora a caixa alta/baixa.

Função: constituent (caractere)

  Retorna `true` se caractere for caractere gráfico e não o caractere de espaço em branco. Um caractere gráfico é um caractere que se pode ver, adicionado o caractere de espaço em branco. (`constituent` foi definida por Paul Graham, em ANSI Common Lisp, 1996, página 67.)

      (%i1) load("stringproc")$
      (%i2) for n from 0 thru 255 do (
      tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
      ! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
      C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
      d e f g h i j k l m n o p q r s t u v w x y z { | } ~

Função: cunlisp (lisp_char)

  Converte um caractere do Lisp em um caractere do Maxima. (É possível que não chegue a precisar dessa função.)

Função: digitcharp (caractere)

  Retorna `true` se caractere for um dígito (algarismo de 0 a 9).

Função: lcharp (obj)

  Retorna `true` se obj for um caractere do Lisp. (Pode não precisar dessa função.)

Função: lowercasep (caractere)

  Retorna `true` se caractere for um caractere em caixa baixa.

Variable: newline

  O caractere de nova linha.

Variável: space

  O caractere de espaço em branco.

Variável: tab

  O caractere de tabulação.

Função: uppercasep (caractere)

  Retorna `true` se caractere for um caractere em caixa alta.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 69.4 Definições para sequências de caracteres

Função: sunlisp (lisp_string)

  Converte uma sequência de caracteres do Lisp em uma sequência de caracteres do Maxima. (Em geral, pode não chegar a precisar dessa função.)

Função: lstringp (obj)

  Retorna `true` se obj is uma sequência de caracteres do Lisp. (Em geral, pode não chegar a precisar dessa função.)

Função: stringp (obj)

  Retorna `true` se obj for uma sequência de caracteres do Maxima. Veja a introdução para obter exemplos.

Função: charat (seq_caracte, n)

  Retorna o n-ésimo caractere de seq_caracte. O primeiro caractere em seq_caracte é retornado com n = 1.

      (%i1) load("stringproc")$
      (%i2) charat("Lisp",1);
      (%o2)                           L

Função: charlist (seq_caracte)

  Retorna a lsita de todos os caracteres em seq_caracte.

      (%i1) load("stringproc")$
      (%i2) charlist("Lisp");
      (%o2)                     [L, i, s, p]
      (%i3) %[1];
      (%o3)                           L

Função: parsetoken (seq_caracte)

  `parsetoken` converte a primeira ficha em seq_caracte para o correspondente número ou retorna `false` se o número não puder ser determinado. O conjunto de delimitadores para a troca de fichas é `{space, comma, semicolon, tab, newline}`

  Nota de tradução: espaço, vírgula, ponto e vírgula, tabulação e nova linha.

      (%i1) load("stringproc")$
      (%i2) 2*parsetoken("1.234 5.678");
      (%o2)                         2.468

  Para analizar, pode também usar a função `parse_string`. Veja a descrição no ficheiro 'share\contrib\eval_string.lisp'.

Função: sconc (expr_1, ..., expr_n)

  Avalia seus argumentos e concatena-os em uma sequência de caracteres. `sconc` é como `sconcat` mas retorna uma sequência de caracteres do Maxima.

      (%i1) load("stringproc")$
      (%i2) sconc("xx[",3,"]:",expand((x+y)^3));
      (%o2)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
      (%i3) stringp(%);
      (%o3)                         true

Função: scopy (seq_caracte)

  Retorna uma cópia de seq_caracte como uma nova sequência de caracteres.

Função: sdowncase (seq_caracte)
Função: sdowncase (seq_caracte, início)
Função: sdowncase (seq_caracte, início, fim)

  Como em `supcase`, mas caracteres em caixa alta são convertidos para caracteres em caixa baixa.

Função: sequal (seq_caracte__1, seq_caracte__2)

  Retorna `true` se seq_caracte__1 e seq_caracte__2 tiverem o mesmo comprimento e contiverem os mesmos caracteres.

Função: sequalignore (seq_caracte__1, seq_caracte__2)

  Como em `sequal` mas igonara a caixa alta/baixa.

Função: sexplode (seq_caracte)

  `sexplode` é um apelido para a função `charlist`.

Função: simplode (lista)
Função: simplode (lista, delim)

  `simplode` takes uma `lista` ou expressões e concatena-as em uma sequência de caracteres. Se nenhum delimitador delim for usado, `simplode` funciona como `sconc` e não utiliza delimitador. delim pode ser qualquer sequência de caracteres.

      (%i1) load("stringproc")$
      (%i2) simplode(["xx[",3,"]:",expand((x+y)^3)]);
      (%o2)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
      (%i3) simplode( sexplode("stars")," * " );
      (%o3)                   s * t * a * r * s
      (%i4) simplode( ["One","more","coffee."]," " );
      (%o4)                   One more coffee.

Função: sinsert (seq, seq_caracte, pos)

  Retorna uma sequência de caracteres que é uma concatenação de `substring (seq_caracte, 1, pos - 1)`, a sequência de caracteres seq e `substring (seq_caracte, pos)`. Note que o primeiro caractere está em seq_caracte e está na posição 1.

      (%i1) load("stringproc")$
      (%i2) s: "A submarine."$
      (%i3) sconc( substring(s,1,3),"yellow ",substring(s,3) );
      (%o3)                  A yellow submarine.
      (%i4) sinsert("hollow ",s,3);
      (%o4)                  A hollow submarine.

Função: sinvertcase (seq_caracte)
Função: sinvertcase (seq_caracte, início)
Função: sinvertcase (seq_caracte, início, fim)

  Retorna seq_caracte excepto que cada caractere da posição início até a posição fim está invertido. Se a posição fim não for fornecida, todos os caracteres do início ao fim de seq_caracte são substituídos.

      (%i1) load("stringproc")$
      (%i2) sinvertcase("sInvertCase");
      (%o2)                      SiNVERTcASE

Função: slength (seq_caracte)

  Retorna número de caracteres em seq_caracte.

Função: smake (num, caractere)

  Retorna uma nova sequência de caracteres repetindo num vezes caractere.

      (%i1) load("stringproc")$
      (%i2) smake(3,"w");
      (%o2)                          www

Função: smismatch (seq_caracte__1, seq_caracte__2)
Função: smismatch (seq_caracte__1, seq_caracte__2, test)

  Retorna a posição do primeiro caractere de seq_caracte__1 no qual seq_caracte__1 e seq_caracte__2 diferem ou `false` em caso contrário. A função padrao de teste para coincidência é `sequal`. Se `smismatch` pode ignorar a caixa alta/baixa, use `sequalignore` como função de teste.

      (%i1) load("stringproc")$
      (%i2) smismatch("seven","seventh");
      (%o2)                           6

Função: split (seq_caracte)
Função: split (seq_caracte, delim)
Função: split (seq_caracte, delim, multiple)

  Retorna a lista de todas as fichas em seq_caracte. Cada ficha é uma sequência de caracteres não analisada. `split` usa delim como delimitador. Se delim não for fornecido, o caractere de espaço é o delimitador padrão. multiple é uma variável booleana com `true` como valor padrão. Multiplos delimitadores são lidos como um. Essa função é útil se tabulações são gravadas com caracteres de espaço multiplos. Se multiple for escolhido para `false`, cada delimitador é considerado.

      (%i1) load("stringproc")$
      (%i2) split("1.2   2.3   3.4   4.5");
      (%o2)                 [1.2, 2.3, 3.4, 4.5]
      (%i3) split("first;;third;fourth",";",false);
      (%o3)               [first, , third, fourth]

Função: sposition (caractere, seq_caracte)

  Retorna a posição do primeiro caractere em seq_caracte que coincide com caractere. O primeiro caractere em seq_caracte está na posição 1. Para que os caracteres que coincidirem desconsiderem a caixa alta/baixa veja `ssearch`.

Função: sremove (seq, seq_caracte)
Função: sremove (seq, seq_caracte, test)
Função: sremove (seq, seq_caracte, test, início)
Função: sremove (seq, seq_caracte, test, início, fim)

  Retorna uma sequência de caracteres como seq_caracte mas com todas as subsequências de caracteres que coincidirem com seq. A função padrão de teste de coincidência é `sequal`. Se `sremove` puder ignorar a caixa alta/baixa enquanto busca por seq, use `sequalignore` como teste. Use início e fim para limitar a busca. Note que o primeiro caractere em seq_caracte está na posição 1.

      (%i1) load("stringproc")$
      (%i2) sremove("n't","I don't like coffee.");
      (%o2)                   I do like coffee.
      (%i3) sremove ("DO ",%,'sequalignore);
      (%o3)                    I like coffee.

Função: sremovefirst (seq, seq_caracte)
Função: sremovefirst (seq, seq_caracte, test)
Função: sremovefirst (seq, seq_caracte, test, início)
Função: sremovefirst (seq, seq_caracte, test, início, fim)

  Como em `sremove` excepto que a primeira subsequência de caracteres que coincide com `seq` é removida.

Função: sreverse (seq_caracte)

  Retorna uma sequência de caracteres com todos os caracteres de seq_caracte em ordem reversa.

Função: ssearch (seq, seq_caracte)
Função: ssearch (seq, seq_caracte, test)
Função: ssearch (seq, seq_caracte, test, início)
Função: ssearch (seq, seq_caracte, test, início, fim)

  Retorna a posição da primeira subsequência de caracteres de seq_caracte que coincide com a sequência de caracteres seq. A função padrão de teste de coincidência é `sequal`. Se `ssearch` puder igonorar a caixa alta/baixa, use `sequalignore` como função de teste. Use início e fim para limitar a busca. Note que o primeiro caracter em seq_caracte está na posição 1.

      (%i1) ssearch("~s","~{~S ~}~%",'sequalignore);
      (%o1)                                  4

Função: ssort (seq_caracte)
Função: ssort (seq_caracte, test)

  Retorna uma sequência de caracteres que contém todos os caracteres de seq_caracte em uma ordem tal que não existam dois caracteres c sucessivos e d seja tal que `test (c, d)` seja `false` e `test (d, c)` seja `true`. A função padrão de teste para ordenação é clessp. O conjunto de funções de teste é `{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore}`.

      (%i1) load("stringproc")$
      (%i2) ssort("I don't like Mondays.");
      (%o2)                    '.IMaddeiklnnoosty
      (%i3) ssort("I don't like Mondays.",'cgreaterpignore);
      (%o3)                 ytsoonnMlkIiedda.'

Função: ssubst (nova, antiga, seq_caracte)
Função: ssubst (nova, antiga, seq_caracte, test)
Função: ssubst (nova, antiga, seq_caracte, test, início)
Função: ssubst (nova, antiga, seq_caracte, test, início, fim)

  Retorna uma sequência de caracteres como seq_caracte excepto que todas as subsequências de caracteres que coincidirem com antiga são substituídas por nova. antiga e nova não precisam ser de mesmo comprimento. A função padrão de teste para coincidência é para coincidências é `sequal`. Se `ssubst` puder ignorar a cixa alta/baixa enquanto procurando por antiga, use `sequalignore` como função de teste. Use início e fim para limitar a busca. Note que o primeiro caractere em seq_caracte está na posição 1.

      (%i1) load("stringproc")$
      (%i2) ssubst("like","hate","I hate Thai food. I hate green tea.");
      (%o2)          I like Thai food. I like green tea.
      (%i3) ssubst("Indian","thai",%,'sequalignore,8,12);
      (%o3)         I like Indian food. I like green tea.

Função: ssubstfirst (nova, antiga, seq_caracte)
Função: ssubstfirst (nova, antiga, seq_caracte, test)
Função: ssubstfirst (nova, antiga, seq_caracte, test, início)
Função: ssubstfirst (nova, antiga, seq_caracte, test, início, fim)

  Como em `subst` excepto que somente a primeira subsequência de caracteres que coincidir com antiga é substituída.

Função: strim (seq,seq_caracte)

  Retorna uma sequência de caracteres como seq_caracte, mas com todos os caracteres que aparecerem em seq removidos de ambas as extremidades.

      (%i1) load("stringproc")$
      (%i2) "/* comment */"$
      (%i3) strim(" /*",%);
      (%o3)                        comment
      (%i4) slength(%);
      (%o4)                           7

Função: striml (seq, seq_caracte)

  Como em `strim` excepto que somente a extremidade esquerda de seq_caracte é recordada.

Função: strimr (seq, seq_caracte)

  Como em `strim` excepto que somente a extremidade direita de sequência de caracteres é recortada.

Função: substring (seq_caracte, início)
Função: substring (seq_caracte, início, fim)

  Retorna a subsequência de caracteres de seq_caracte começando na posição início e terminando na posição fim. O caractere na posição fim não é incluído. Se fim não for fornecido, a subsequência de caracteres contém o restante da sequência de caracteres. Note que o primeiro caractere em seq_caracte está na posição 1.

      (%i1) load("stringproc")$
      (%i2) substring("substring",4);
      (%o2)                        string
      (%i3) substring(%,4,6);
      (%o3)                          in

Função: supcase (seq_caracte)
Função: supcase (seq_caracte, início)
Função: supcase (seq_caracte, início, fim)

  Retorna seq_caracte excepto que caracteres em caixa baixa a partir da posição início até a posição fim são substituídos pelo correspondente caracteres em cixa alta. Se fim não for fornecido, todos os caracteres em caixa baixa de início até o fim de seq_caracte são substituídos.

      (%i1) load("stringproc")$
      (%i2) supcase("english",1,2);
      (%o2)                        English

Função: tokens (seq_caracte)
Função: tokens (seq_caracte, test)

  Retorna uma lista de fichas, que tiverem sido extrídos de seq_caracte. As fichas são subsequências de caracteres cujos caracteres satisfazem a uma determinada função de teste. Se o teste não for fornecido, constituent é usada como teste padrão. `{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp}` é o conjunto de fnç~oes de teste. (A versão Lisp de `tokens` é escrita por Paul Graham. ANSI Common Lisp, 1996, page 67.)

      (%i1) load("stringproc")$
      (%i2) tokens("24 October 2005");
      (%o2)                  [24, October, 2005]
      (%i3) tokens("05-10-24",'digitcharp);
      (%o3)                     [05, 10, 24]
      (%i4) map(parsetoken,%);
      (%o4)                      [5, 10, 24]

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Viktor T. Toth on Outubro, 3 2017 using texi2html 1.76.