Introducedilhaão a manipulacedilhaão de seqüências de caracteres
================================================================

O arquivo stringproc.lisp amplia a compatibilidade do Maxima de trabalhar com seqüências de caracteres e adiciona algumas funcedilhaões úteis a entrada e saída de dados.

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

No Maxima uma seqüência de caracteres é facilmente contruída digitando "texto" (qualquer texto desejado entre aspas duplas). Note que seqüências de caracteres do Maxima não são seqüências de caracteres do Lisp e vice-versa. stringp realiza testes para seqüências de caracteres do Maxima, e lstringp realiza testes para seqüências de caracteres do Lisp. Se por alguma razão voce tiver um valor, que é uma seqüência de caracteres do Lisp, talvez quando estiver usando a funcedilhaão sconcat do Maxima, você pode converter via sunlisp.

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

Todas as funcedilhaões em stringproc.lisp, que retornarem seqüências de caracteres, retornam seqüências de caracteres do Maxima.

Caracteres são introduzidos como seqüê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) c: "e";
     (%o1)                           e
     (%i2) [charp(c),lcharp(c)];
     (%o2)                     [true, false]
     (%i3) supcase(c);
     (%o3)                           E
     (%i4) charp(%);
     (%o4)                         true

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

É importante saber, que o primeiro caractere em uma seqüência de caracteres do Maxima éstá na posicedilhaão 1. Isso é designado devido ao fato de o primeiro elemento em uma lista do Maxima está na posicedilhaão 1 também. Veja definicedilhaões de charat e de charlist para obter exemplos.

Em aplicacedilhaões fncedilhaões de seqüência de caractere são muitas vezes usadas quando estamos trabalhando com arquivos. Você encontrará algumas úteis funcedilhaões de fluxo e funcedilhaões de impressões em stringproc.lisp. O seguinte exemplo mostra algumas das funcedilhaões aqui introduzidas no trabalho.

Exemplo:

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

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

Após fechar o fluxo você pode abrí-lo novamente, dessa vez com direcedilhaão de entrada. readline retorna a linha completa como uma seqüência de caracteres. O pacote stringproc agora oferece muitas funcedilhaões para manipulacedilhaão de seqüências de caracteres. A troca de indicacedilhaões/fichas pode ser realizada por split ou por tokens.

     (%i5) s: openr("E:/file.txt");
     (%o5)                     #<input stream E:/file.txt>
     (%i6) readline(s);
     (%o6)                     0 1 1 2 3 5 8 13 21 34 55
     (%i7) line: readline(s);
     (%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
     (%i8) list: tokens(line);
     (%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
     (%i9) map( parsetoken, list );
     (%o9)           [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 irá ser disponibilizada para uso automaticamente através de eval_string.lisp.

     (%i10) map( parse_string, list );
     (%o10)           [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
     (%i11) float(%);
     (%o11) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01, 0.01, 0.01]
     (%i12) readline(s);
     (%o12)                               false
     (%i13) close(s)$

readline retorna false quado o fim de arquivo acontecer.

Funcedilhaões e Variáveis para entrada e saída
==============================================

Exemplo:

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

 -- Funcedilhaão: close (FLUXO)
     Fecha  FLUXO e retorna true se FLUXO tiver sido aberto anteriormente.

 -- Funcedilhaão: flength (FLUXO)
     Retorna o número de elementos em FLUXO.

 -- Funcedilhaão: fposition (FLUXO)
 -- Funcedilhaão: fposition (FLUXO, POS)
     Retorna a posicedilhaão corrente em FLUXO, se POS não está sendo usada. Se POS estiver sendo usada, fposition escolhe a posicedilhaão em FLUXO. POS tem que ser um número positivo, o primeiro elemento em FLUXO está na posicedilhaão 1.

 -- Funcedilhaão: freshline ()
 -- Funcedilhaão: freshline (FLUXO)
     escreve uma nova linha (em FLUXO), se a posicedilhaão atual não for um início de linha. Veja também newline.

 -- Funcedilhaão: newline ()
 -- Funcedilhaã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.

 -- Funcedilhaão: opena (ARQUIVO)
     Retorna um fluxo de saída para ARQUIVO. Se um arquivo já existente tiver sido aberto, opena anexa os elementos ao final do arquivo.

 -- Funcedilhaão: openr (ARQUIVO)
     Retorna um fluxo para ARQUIVO. Se ARQUIVO não existir, ele será criado.

 -- Funcedilhaão: openw (ARQUIVO)
     Retorna um fluxo de saída para ARQUIVO. Se ARQUIVO não existir, será criado. Se um arquivo já existente for aberto, openw modifica destrutivametne o ARQUIVO.

 -- Funcedilhaão: printf (DEST, SEQ_CARACTE)
 -- Funcedilhaão: printf (DEST, SEQ_CARACTE, EXPR_1, ..., EXPR_N)
     Torna a funcedilhaã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 descricedilhaão e oa exemplos podem fornecer uma idéia de uso de printf. Veja um referência de Lisp para maiores informacedilhaões.

             ~%       nova linha
             ~&       novíssima line
             ~t       tabulacedilhaã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       notacedilhaão científica
             ~g       ~f ou ~e, dependendo  da magnitude
             ~a       como mostrado pela funcedilhaão print do Maxima
             ~s       seqüências de caracteres entre "aspas duplas"
             ~~       ~
             ~<       justificacedilhaão de texto, ~> terminador de justificacedilhaão de texto
             ~(       conversão de caixa alta/baixa, ~) terminador de conversão de caixa
             ~[       selecedilhaão, ~] terminador de selecedilhaão
             ~{       iteracedilhaão, ~} terminador de iteracedilhaã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 diretiva ~a. ~s mostra a seqüências de caracteres entre "aspas duplas", você pode evitar isso usando ~a. Note que a diretiva de selecedilhaão ~[ é indexada em zero. Também note que existem algumas diretivas, que não trabalham no Maxima. Por exemplo, ~:[ falha.

          (%i1) printf( false, "~a ~a ~4f ~a ~@r",
                        "String",sym,bound,sqrt(12),144), bound = 1.234;
          (%o1)                 String sym 1.23 2*sqrt(3) CXLIV
          (%i2) printf( false,"~{~a ~}",["one",2,"THREE"] );
          (%o2)                          one 2 THREE
          (%i3) 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
          (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
          (%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
          (%o5)                    Two birds are singing.

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

 -- Funcedilhaão: readline (FLUXO)
     Retorna uma seqüência de caracteres contendo os caracteres a partir da posicedilhaão corrente em FLUXO até o fim de linha ou FALSE se o fim de linha do arquivo for encontrado.

 -- Funcedilhaão: sprint (EXPR_1, ..., EXPR_N)
     Avalia e mostra seus argumentos um após o outro `sobre uma linha' iniciando na posicedilhaão mais à esquerda. Os números são mostrados com o '-' à direita do número, e isso desconsidera o comprimento da linha. newline(), que irá ser chamada automaticamente a partir de stringproc.lisp pode ser útil, se você desejar colocar uma parada de linha intermediária.

          (%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) 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

Funcedilhaões e Variáveis para caracteres
=========================================

 -- Funcedilhaão: alphacharp (CARACTERE)
     Retorna true se CARACTERE for um caractere alfabético.

 -- Funcedilhaão: alphanumericp (CARACTERE)
     Retorna true se CARACTERE for um caractere alfabético ou um dígito.

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

          (%i1) 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

 -- Funcedilhaão: cequal (CARACTERE_1, CARACTERE_2)
     Retorna true se CARACTERE_1 e CARACTERE_2 forem os mesmos.

 -- Funcedilhaão: cequalignore (CARACTERE_1, CARACTERE_2)
     como cequal mas ignora a caixa alta/baixa.

 -- Funcedilhaã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.

 -- Funcedilhaão: cgreaterpignore (CARACTERE_1, CARACTERE_2)
     Como cgreaterp mas ignora a caixa alta/baixa.

 -- Funcedilhaão: charp (OBJ)
     Retorna true se OBJ for um caractere do Maxima. Veja na secedilhaão "Introducedilhaão a manipulacedilhaão de seqüências de caracteres" para ter um exemplo.

 -- Funcedilhaão: cint (CARACTERE)
     Retorna o código numéico ASCII de CARACTERE.

 -- Funcedilhaã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.

 -- Funcedilhaão: clesspignore (CARACTERE_1, CARACTERE_2)
     Como em clessp ignora a caixa alta/baixa.

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

          (%i1) 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 { | } ~

 -- Funcedilhaão: cunlisp (LISP_CHAR)
     Converte um caractere do Lisp em um caractere do Maxima. (Você pode não precisar dessa funcedilhaão.)

 -- Funcedilhaão: digitcharp (CARACTERE)
     Retorna true se CARACTERE for um dígito (algarismo de 0 a 9).

 -- Funcedilhaão: lcharp (OBJ)
     Retorna true se OBJ for um caractere do Lisp. (Você pode não precisar dessa funcedilhaão.)

 -- Funcedilhaã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 espacedilhao em branco.

 -- Variável: tab
     O caractere de tabulacedilhaão.

 -- Funcedilhaão: uppercasep (CARACTERE)
     Retorna true se CARACTERE for um caractere em caixa alta.

Funcedilhaões e Variáveis para seqüências de caracteres
=======================================================

 -- Funcedilhaão: sunlisp (LISP_STRING)
     Converte uma seqüência de caracteres do Lisp em uma seqüência de caracteres do Maxima. (Em geral você pode não precisar dessa funcedilhaão.)

 -- Funcedilhaão: lstringp (OBJ)
     Retorna true se OBJ is uma seqüência de caracteres do Lisp. (Em geral você pode não precisar dessa funcedilhaão.)

 -- Funcedilhaão: stringp (OBJ)
     Retorna true se OBJ for uma seqüência de caracteres do Maxima. Veja a introducedilhaão para obter exemplos.

 -- Funcedilhaão: charat (SEQ_CARACTE, N)
     Retorna o N-ésimo caractere de SEQ_CARACTE. O primeiro caractere em SEQ_CARACTE é retornado com N = 1.

          (%i1) charat("Lisp",1);
          (%o1)                           L

 -- Funcedilhaão: charlist (SEQ_CARACTE)
     Retorna a lsita de todos os caracteres em SEQ_CARACTE.

          (%i1) charlist("Lisp");
          (%o1)                     [L, i, s, p]
          (%i2) %[1];
          (%o2)                           L

 -- Funcedilhaã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 traducedilhaão: espacedilhao, vírgula, ponto e vírgula, tabulacedilhaão e nova linha.

          (%i1) 2*parsetoken("1.234 5.678");
          (%o1)                         2.468

     Para analizar você pode também usar  a funcedilhaão parse_string. Veja a descricedilhaão no arquivo 'share\contrib\eval_string.lisp'.

 -- Funcedilhaão: sconc (EXPR_1, ..., EXPR_N)
     Avalia seus argumentos e concatena-os em uma seqüência de caracteres. sconc é como sconcat mas retorna uma seqüência de caracteres do Maxima.

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

 -- Funcedilhaão: scopy (SEQ_CARACTE)
     Retorna uma cópia de SEQ_CARACTE como uma nova seqüência de caracteres.

 -- Funcedilhaão: sdowncase (SEQ_CARACTE)
 -- Funcedilhaão: sdowncase (SEQ_CARACTE, INÍCIO)
 -- Funcedilhaão: sdowncase (SEQ_CARACTE, INÍCIO, FIM)
     Como em supcase, mas caracteres em caixa alta são convertidos para caracteres em caixa baixa.

 -- Funcedilhaã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.

 -- Funcedilhaão: sequalignore (SEQ_CARACTE__1, SEQ_CARACTE__2)
     Como em sequal mas igonara a caixa alta/baixa.

 -- Funcedilhaão: sexplode (SEQ_CARACTE)
     sexplode é um apelido para a funcedilhaão charlist.

 -- Funcedilhaão: simplode (LISTA)
 -- Funcedilhaão: simplode (LISTA, DELIM)
     simplode takes uma lista ou expressões  e concatena-as em uma seqüência de caracteres. Se nenhum delimitador DELIM for usado, simplode funciona como sconc e não utiliza delimitador. DELIM pode ser qualquer seqüência de caracteres.

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

 -- Funcedilhaão: sinsert (SEQ, SEQ_CARACTE, POS)
     Retorna uma seqüência de caracteres que é uma concatenacedilhaão de substring (SEQ_CARACTE, 1, POS - 1), a seqüência de caracteres SEQ e substring (SEQ_CARACTE, POS). Note que o primeiro caractere está em SEQ_CARACTE e está na posicedilhaão 1.

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

 -- Funcedilhaão: sinvertcase (SEQ_CARACTE)
 -- Funcedilhaão: sinvertcase (SEQ_CARACTE, INÍCIO)
 -- Funcedilhaão: sinvertcase (SEQ_CARACTE, INÍCIO, FIM)
     Retorna SEQ_CARACTE exceto que cada caractere da posicedilhaão INÍCIO até a posicedilhaão FIM está invertido. Se a posicedilhaão FIM não for fornecida, todos os caracteres do início ao FIM de SEQ_CARACTE são substituídos.

          (%i1) sinvertcase("sInvertCase");
          (%o1)                      SiNVERTcASE

 -- Funcedilhaão: slength (SEQ_CARACTE)
     Retorna número de caracteres em SEQ_CARACTE.

 -- Funcedilhaão: smake (NUM, CARACTERE)
     Retorna uma nova seqüência de caracteres repetindo NUM vezes CARACTERE.

          (%i1) smake(3,"w");
          (%o1)                          www

 -- Funcedilhaão: smismatch (SEQ_CARACTE__1, SEQ_CARACTE__2)
 -- Funcedilhaão: smismatch (SEQ_CARACTE__1, SEQ_CARACTE__2, TEST)
     Retorna a posicedilhaã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 funcedilhaão padrao de teste para coincidência é sequal. Se smismatch pode ignorar a caixa alta/baixa, use sequalignore como funcedilhaão de teste.

          (%i1) smismatch("seven","seventh");
          (%o1)                           6

 -- Funcedilhaão: split (SEQ_CARACTE)
 -- Funcedilhaão: split (SEQ_CARACTE, DELIM)
 -- Funcedilhaão: split (SEQ_CARACTE, DELIM, MULTIPLE)
     Retorna a lista de todas as fichas em SEQ_CARACTE. Cada ficha é uma seqüência de caracteres não analisada. split usa DELIM como delimitador. Se DELIM não for fornecido, o caractere de espacedilhao é o delimitador padrão. MULTIPLE é uma variável booleana com true como valor padrão. Multiplos delimitadores são lidos como um. Essa funcedilhaão é útil se tabulacedilhaões são gravadas com caracteres de espacedilhao multiplos. Se MULTIPLE for escolhido para false, cada delimitador é considerado.

          (%i1) split("1.2   2.3   3.4   4.5");
          (%o1)                 [1.2, 2.3, 3.4, 4.5]
          (%i2) split("first;;third;fourth",";",false);
          (%o2)               [first, , third, fourth]

 -- Funcedilhaão: sposition (CARACTERE, SEQ_CARACTE)
     Retorna a posicedilhaão do primeiro caractere em SEQ_CARACTE que coincide com CARACTERE. O primeiro caractere em SEQ_CARACTE está na posicedilhaão 1. Para que os caracteres que coincidirem desconsiderem a caixa alta/baixa veja ssearch.

 -- Funcedilhaão: sremove (SEQ, SEQ_CARACTE)
 -- Funcedilhaão: sremove (SEQ, SEQ_CARACTE, TEST)
 -- Funcedilhaão: sremove (SEQ, SEQ_CARACTE, TEST, INÍCIO)
 -- Funcedilhaão: sremove (SEQ, SEQ_CARACTE, TEST, INÍCIO, FIM)
     Retorna uma seqüência de caracteres como SEQ_CARACTE mas com todas as subseqüências de caracteres que coincidirem com SEQ. A funcedilhaã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 posicedilhaão 1.

          (%i1) sremove("n't","I don't like coffee.");
          (%o1)                   I do like coffee.
          (%i2) sremove ("DO ",%,'sequalignore);
          (%o2)                    I like coffee.

 -- Funcedilhaão: sremovefirst (SEQ, SEQ_CARACTE)
 -- Funcedilhaão: sremovefirst (SEQ, SEQ_CARACTE, TEST)
 -- Funcedilhaão: sremovefirst (SEQ, SEQ_CARACTE, TEST, INÍCIO)
 -- Funcedilhaão: sremovefirst (SEQ, SEQ_CARACTE, TEST, INÍCIO, FIM)
     Como em sremove exceto qie a primeira subseqüência de caracteres que coincide com seq é removida.

 -- Funcedilhaão: sreverse (SEQ_CARACTE)
     Retorna uma seqüência de caracteres com todos os caracteres de SEQ_CARACTE em ordem reversa.

 -- Funcedilhaão: ssearch (SEQ, SEQ_CARACTE)
 -- Funcedilhaão: ssearch (SEQ, SEQ_CARACTE, TEST)
 -- Funcedilhaão: ssearch (SEQ, SEQ_CARACTE, TEST, INÍCIO)
 -- Funcedilhaão: ssearch (SEQ, SEQ_CARACTE, TEST, INÍCIO, FIM)
     Retorna a posicedilhaão da primeira subseqüência de caracteres de SEQ_CARACTE que coincide com a seqüência de caracteres SEQ. A funcedilhaão padrão de teste de coincidência é sequal. Se ssearch puder igonorar a caixa alta/baixa, use sequalignore como funcedilhaão de teste. Use INÍCIO e FIM para limitar a busca. Note que o primeiro caractere em SEQ_CARACTE está na posicedilhaão 1.

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

 -- Funcedilhaão: ssort (SEQ_CARACTE)
 -- Funcedilhaão: ssort (SEQ_CARACTE, TEST)
     Retorna uma seqüê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 funcedilhaão padrão de teste para ordenacedilhaào é CLESSP. O conjunto de funcedilhaões de teste é {clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore}.

          (%i1) ssort("I don't like Mondays.");
          (%o1)                    '.IMaddeiklnnoosty
          (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
          (%o2)                 ytsoonnMlkIiedda.'

 -- Funcedilhaão: ssubst (NOVA, ANTIGA, SEQ_CARACTE)
 -- Funcedilhaão: ssubst (NOVA, ANTIGA, SEQ_CARACTE, TEST)
 -- Funcedilhaão: ssubst (NOVA, ANTIGA, SEQ_CARACTE, TEST, INÍCIO)
 -- Funcedilhaão: ssubst (NOVA, ANTIGA, SEQ_CARACTE, TEST, INÍCIO, FIM)
     Retorna uma seqüência de caracteres como SEQ_CARACTE exceto que todas as subseqüências de caracteres que coincidirem com ANTIGA são substituídas por NOVA. ANTIGA e NOVA não precisam ser de mesmo comprimento. A funcedilhaã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 funcedilhaão de teste. Use INÍCIO e FIM para limitar a busca. Note que o primeiro caractere em SEQ_CARACTE está na posicedilhaão 1.

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

 -- Funcedilhaão: ssubstfirst (NOVA, ANTIGA, SEQ_CARACTE)
 -- Funcedilhaão: ssubstfirst (NOVA, ANTIGA, SEQ_CARACTE, TEST)
 -- Funcedilhaão: ssubstfirst (NOVA, ANTIGA, SEQ_CARACTE, TEST, INÍCIO)
 -- Funcedilhaão: ssubstfirst (NOVA, ANTIGA, SEQ_CARACTE, TEST, INÍCIO, FIM)
     Como em subst exceto que somente a primeira subseqüência de caracteres que coincidir com ANTIGA é substituída.

 -- Funcedilhaão: strim (SEQ,SEQ_CARACTE)
     Retorna uma seqüência de caracteres como SEQ_CARACTE, mas com todos os caracteres que aparecerem em SEQ removidos de ambas as extremidades.

          (%i1) "/* comment */"$
          (%i2) strim(" /*",%);
          (%o2)                        comment
          (%i3) slength(%);
          (%o3)                           7

 -- Funcedilhaão: striml (SEQ, SEQ_CARACTE)
     Como em strim exceto que somente a extremidade esquerda de SEQ_CARACTE é recordada.

 -- Funcedilhaão: strimr (SEQ, SEQ_CARACTE)
     Como em strim exceto que somente a extremidade direita de seqüência de caracteres é recortada.

 -- Funcedilhaão: substring (SEQ_CARACTE, INÍCIO)
 -- Funcedilhaão: substring (SEQ_CARACTE, INÍCIO, FIM)
     Retorna a subseqüência de caracteres de SEQ_CARACTE comecedilhaando na posicedilhaão INÍCIO e terminando na posicedilhaão FIM. O caractere na posicedilhaão FIM não é incluído. Se FIM não for fornecido, a subseqüência de caracteres contém o restante da seqüência de caracteres. Note que o primeiro caractere em SEQ_CARACTE está na posicedilhaão 1.

          (%i1) substring("substring",4);
          (%o1)                        string
          (%i2) substring(%,4,6);
          (%o2)                          in

 -- Funcedilhaão: supcase (SEQ_CARACTE)
 -- Funcedilhaão: supcase (SEQ_CARACTE, INÍCIO)
 -- Funcedilhaão: supcase (SEQ_CARACTE, INÍCIO, FIM)
     Retorna SEQ_CARACTE exceto que caracteres em caixa baixa a partir da posicedilhaão INÍCIO até a posicedilhaão FIM são substituídos pelo correspondente caracteres em caixa 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")$
          (%i1) supcase("english",1,2);
          (%o1)                        English

 -- Funcedilhaão: tokens (SEQ_CARACTE)
 -- Funcedilhaão: tokens (SEQ_CARACTE, TEST)
     Retorna uma lista de fichas, que tiverem sido extrídos de SEQ_CARACTE. As fichas são subseqüências de caracteres cujos caracteres satisfazem a uma determinada funcedilhaã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 fncedilhaões de teste. (A verão Lisp de tokens é escrita por Paul Graham. ANSI Common Lisp, 1996, page 67.)

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