@c Language: Portuguese
@c Source: stringproc.texi (en) 1.6
@menu
* Introdução a manipulação de sequências de caracteres::
* Definições para entrada e saída::
* Definições para caracteres::
* Definições para sequências de caracteres::
@end menu

@node Introdução a manipulação de sequências de caracteres, Definições para entrada e saída, stringproc, stringproc
@section Introdução a manipulação de sequências de caracteres

O ficheiro @code{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 @code{stringproc.lisp} para uso digite @code{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 @code{stringp} e @code{lstringp}.
Se por alguma razão tiver um valor,
que é uma sequência de caracteres do Lisp, talvez quando estiver usando a função @code{sconcat} do Maxima, poderá converter via @code{sunlisp}. 


@c ===beg===
@c load("stringproc")$
@c m: "text";
@c [stringp(m),lstringp(m)];
@c l: sconcat("text");
@c [stringp(l),lstringp(l)];
@c stringp( sunlisp(l) );
@c ===end===
@example
(%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
@end example

Todas as funções em @code{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 @code{charp} ( @code{lcharp} e conversões do Lisp para o Maxima com @code{cunlisp}).


@c ===beg===
@c load("stringproc")$
@c c: "e";
@c [charp(c),lcharp(c)];
@c supcase(c);
@c charp(%);
@c ===end===
@example
(%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
@end example

Novamente, todas as funções em @code{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, @code{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 @code{charat} e de @code{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
@code{stringproc.lisp}.  O seguinte exemplo mostra algumas das
funções aqui introduzidas no trabalho.

Exemplo: 

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

@example
(%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
@end example

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

@example
(%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]
@end example

@code{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 @code{parse_string}, que pode ser disponibilizada para uso através de @code{eval_string.lisp}.

@example 
(%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)$
@end example

@code{readline} retorna @code{false} quado o fim de ficheiro acontecer.

@node Definições para entrada e saída, Definições para caracteres, Introdução a manipulação de sequências de caracteres, stringproc
@section Definições para entrada e saída

Exemplo: 

@c ===beg===
@c load("stringproc")$
@c s: openw("E:/file.txt");
@c control: 
@c  "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2tand an integer: ~20t~d~%"$
@c printf( s,control, 'true,[1,2,3],42 )$
@c close(s);
@c s: openr("E:/file.txt");
@c while stringp( tmp:readline(s) ) do print(tmp)$
@c close(s)$
@c ===end===
@example
(%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)$
@end example


@deffn {Função} close (@var{fluxo}) 
Fecha  @var{fluxo} e retorna @code{true} se @var{fluxo} tiver sido aberto anteriormente. 

@end deffn

@deffn {Função} flength (@var{fluxo})
Retorna o número de elementos em @var{fluxo}. 

@end deffn

@deffn {Função} fposition (@var{fluxo})
@deffnx {Função} fposition (@var{fluxo}, @var{pos})
Retorna a posição corrente em @var{fluxo}, se @var{pos} não está sendo usada.
Se @var{pos} estiver sendo usada,
@code{fposition} escolhe a posição em @var{fluxo}.
@var{pos} tem que ser um número positivo,
o primeiro elemento em @var{fluxo} está na posição 1.

@end deffn

@deffn {Função} freshline () 
@deffnx {Função} freshline (@var{fluxo}) 
escreve uma nova linha (em @var{fluxo}),
se a posição actual não for um início de linha.
Veja também @code{newline}.
@end deffn

@deffn {Função} newline () 
@deffnx {Função} newline (@var{fluxo}) 
Escreve uma nova linha (para @var{fluxo}).
Veja @code{sprint} para um exemplo de uso de @code{newline()}.
Note que existem alguns casos, onde @code{newline()}não trabalha como esperado. 

@end deffn

@deffn {Função} opena (@var{ficheiro}) 
Retorna um fluxo de saída para @var{ficheiro}.
Se um ficheiro já existente tiver sido aberto, @code{opena} anexa os elementos ao final do ficheiro.

@end deffn

@deffn {Função} openr (@var{ficheiro}) 
Retorna um fluxo para @var{ficheiro}.
Se @var{ficheiro} não existir, ele será criado.

@end deffn

@deffn {Função} openw (@var{ficheiro}) 
Retorna um fluxo de saída para @var{ficheiro}.
Se @var{ficheiro} não existir, será criado.
Se um ficheiro já existente for aberto, @code{openw} modifica destrutivametne o @var{ficheiro}.

@end deffn

@deffn {Função} printf (@var{dest}, @var{seq_caracte})
@deffnx {Função} printf (@var{dest}, @var{seq_caracte}, @var{expr_1}, ..., @var{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 @code{printf}.
Veja um referência de Lisp para maiores informações.

@example
   ~%       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
@end example

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
@code{~a}.  @code{~s} mostra as sequências de caracteres entre "aspas
duplas"; pode evitar isso usando @code{~a}.  Note que a directiva de
selecção @code{~[} é indexada em zero.  Também note que existem
algumas directivas, que não trabalham no Maxima.  Por exemplo,
@code{~:[} falha.

@c ===beg===
@c load("stringproc")$
@c printf( false, "~a ~a ~4f ~a ~@@r", 
@c         "String",sym,bound,sqrt(12),144), bound = 1.234;
@c printf( false,"~@{~a ~@}",["one",2,"THREE"] );
@c printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
@c         mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
@c control: "~:(~r~) bird~p ~[is~;are~] singing."$
@c printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
@c ===end===
@example
(%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.
@end example

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

@end deffn

@deffn {Função} readline (@var{fluxo}) 
Retorna uma sequência de caracteres contendo os caracteres a partir da posição corrente em @var{fluxo} até o fim de linha ou @var{false} se o fim de linha do ficheiro for encontrado.

@end deffn

@deffn {Função} sprint (@var{expr_1}, ..., @var{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. @code{newline()}, que pode ser chamada a partir de
@code{stringproc.lisp} pode ser útil, se desejar colocar uma parada de
linha intermédia.

@c ===beg===
@c for n:0 thru 22 do sprint( fib(n) )$
@c load("stringproc")$
@c for n:0 thru 22 do ( 
@c    sprint(fib(n)), if mod(n,10)=9 then newline() )$
@c ===end===
@example
(%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 
@end example

@end deffn

@node Definições para caracteres, Definições para sequências de caracteres, Definições para entrada e saída, stringproc
@section Definições para caracteres

@deffn {Função} alphacharp (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere alfabético. 

@end deffn

@deffn {Função} alphanumericp (@var{caractere}) 
Retorna @code{true} se @var{caractere} for um caractere alfabético ou um dígito. 

@end deffn

@deffn {Função} ascii (@var{int}) 
Retorna o caractere correspondente ao código numérico ASCII @var{int}.
( -1 < int < 256 )

@c ===beg===
@c load("stringproc")$
@c for n from 0 thru 255 do ( 
@c    tmp: ascii(n), if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
@c ===end===
@example
(%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
@end example

@end deffn

@deffn {Função} cequal (@var{caractere_1}, @var{caractere_2})          
Retorna @code{true} se @var{caractere_1} e @var{caractere_2} forem os mesmos. 

@end deffn

@deffn {Função} cequalignore (@var{caractere_1}, @var{caractere_2})    
como @code{cequal} mas ignora a caixa alta/baixa. 

@end deffn

@deffn {Função} cgreaterp (@var{caractere_1}, @var{caractere_2})       
Retorna @code{true} se o código numérico ASCII do @var{caractere_1} for maior que o código numérico ASCII do @var{caractere_2}. 

@end deffn

@deffn {Função} cgreaterpignore (@var{caractere_1}, @var{caractere_2})
Como @code{cgreaterp} mas ignora a caixa alta/baixa. 

@end deffn

@deffn {Função} charp (@var{obj}) 
Retorna @code{true} se @var{obj} for um caractere do Maxima.
Veja na seção "Introdução a manipulação de sequências de caracteres" para ter um exemplo.

@end deffn

@deffn {Função} cint (@var{caractere}) 
Retorna o código numéico ASCII de @var{caractere}.

@end deffn

@deffn {Função} clessp (@var{caractere_1}, @var{caractere_2})
Retorna @code{true} se o código numérico ASCII de @var{caractere_1} for menor que o código numérico ASCII de @var{caractere_2}. 

@end deffn

@deffn {Função} clesspignore (@var{caractere_1}, @var{caractere_2})
Como em @code{clessp} ignora a caixa alta/baixa. 

@end deffn

@deffn {Função} constituent (@var{caractere})   
Retorna @code{true} se @var{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.
(@code{constituent} foi definida por Paul Graham, em ANSI Common Lisp, 1996, página 67.)

@c ===beg===
@c load("stringproc")$
@c for n from 0 thru 255 do ( 
@c    tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
@c ===end===
@example
(%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 @{ | @} ~
@end example

@end deffn

@deffn {Função} cunlisp (@var{lisp_char}) 
Converte um caractere do Lisp em um caractere do Maxima.  (É
possível que não chegue a precisar dessa função.)

@end deffn

@deffn {Função} digitcharp (@var{caractere})    
Retorna @code{true} se @var{caractere} for um dígito (algarismo de 0 a 9). 

@end deffn

@deffn {Função} lcharp (@var{obj}) 
Retorna @code{true} se @var{obj} for um caractere do Lisp.
(Pode não precisar dessa função.)

@end deffn

@deffn {Função} lowercasep (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere em caixa baixa. 

@end deffn

@defvr {Variable} newline 
O caractere de nova linha. 

@end defvr

@defvr {Variável} space   
O caractere de espaço em branco.

@end defvr

@defvr {Variável} tab     
O caractere de tabulação.

@end defvr

@deffn {Função} uppercasep (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere em caixa alta. 

@end deffn

@node Definições para sequências de caracteres,  , Definições para caracteres, stringproc
@section Definições para sequências de caracteres

@deffn {Função} sunlisp (@var{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.)

@end deffn

@deffn {Função} lstringp (@var{obj}) 
Retorna @code{true} se @var{obj} is uma sequência de caracteres do Lisp.
(Em geral, pode não chegar a precisar dessa função.)

@end deffn

@deffn {Função} stringp (@var{obj}) 
Retorna @code{true} se @var{obj} for uma sequência de caracteres do Maxima.
Veja a introdução para obter exemplos.

@end deffn

@deffn {Função} charat (@var{seq_caracte}, @var{n}) 
Retorna o @var{n}-ésimo caractere de @var{seq_caracte}.
O primeiro caractere em @var{seq_caracte} é retornado com @var{n} = 1.

@c ===beg===
@c load("stringproc")$
@c charat("Lisp",1);
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) charat("Lisp",1);
(%o2)                           L
@end example

@end deffn

@deffn {Função} charlist (@var{seq_caracte}) 
Retorna a lsita de todos os caracteres em @var{seq_caracte}. 

@c ===beg===
@c load("stringproc")$
@c charlist("Lisp");
@c %[1];
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) charlist("Lisp");
(%o2)                     [L, i, s, p]
(%i3) %[1];
(%o3)                           L
@end example

@end deffn

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

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

@c ===beg===
@c load("stringproc")$
@c 2*parsetoken("1.234 5.678");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) 2*parsetoken("1.234 5.678");
(%o2)                         2.468
@end example

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

@end deffn

@deffn {Função} sconc (@var{expr_1}, ..., @var{expr_n})
Avalia seus argumentos e concatena-os em uma sequência de caracteres.
@code{sconc} é como @code{sconcat} mas retorna uma sequência de caracteres do Maxima.

@c ===beg===
@c load("stringproc")$
@c sconc("xx[",3,"]:",expand((x+y)^3));
@c stringp(%);
@c ===end===
@example
(%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
@end example

@end deffn

@deffn {Função} scopy (@var{seq_caracte}) 
Retorna uma cópia de @var{seq_caracte} como uma nova sequência de caracteres. 

@end deffn

@deffn {Função} sdowncase (@var{seq_caracte}) 
@deffnx {Função} sdowncase (@var{seq_caracte}, @var{início}) 
@deffnx {Função} sdowncase (@var{seq_caracte}, @var{início}, @var{fim}) 
Como em @code{supcase}, mas caracteres em caixa alta são convertidos para caracteres em caixa baixa. 

@end deffn

@deffn {Função} sequal (@var{seq_caracte__1}, @var{seq_caracte__2}) 
Retorna @code{true} se @var{seq_caracte__1} e @var{seq_caracte__2} tiverem o mesmo comprimento e contiverem os mesmos caracteres. 

@end deffn

@deffn {Função} sequalignore (@var{seq_caracte__1}, @var{seq_caracte__2})
Como em @code{sequal} mas igonara a caixa alta/baixa. 

@end deffn

@deffn {Função} sexplode (@var{seq_caracte})
@code{sexplode} é um apelido para a função @code{charlist}.

@end deffn

@deffn {Função} simplode (@var{lista})  
@deffnx {Função} simplode (@var{lista}, @var{delim})  
@code{simplode} takes uma @code{lista} ou expressões  e concatena-as em uma sequência de caracteres.
Se nenhum delimitador @var{delim} for usado, @code{simplode} funciona como @code{sconc} e não utiliza delimitador.
@var{delim} pode ser qualquer sequência de caracteres.

@c ===beg===
@c load("stringproc")$
@c simplode(["xx[",3,"]:",expand((x+y)^3)]);
@c simplode( sexplode("stars")," * " );
@c simplode( ["One","more","coffee."]," " );
@c ===end===
@example
(%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.
@end example

@end deffn

@deffn {Função} sinsert (@var{seq}, @var{seq_caracte}, @var{pos})  
Retorna uma sequência de caracteres que é uma concatenação de @code{substring (@var{seq_caracte}, 1, @var{pos} - 1)},
a sequência de caracteres @var{seq} e @code{substring (@var{seq_caracte}, @var{pos})}.
Note que o primeiro caractere está em @var{seq_caracte} e está na posição 1.

@c ===beg===
@c load("stringproc")$
@c s: "A submarine."$
@c sconc( substring(s,1,3),"yellow ",substring(s,3) );
@c sinsert("hollow ",s,3);
@c ===end===
@example
(%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.
@end example

@end deffn

@deffn {Função} sinvertcase (@var{seq_caracte})  
@deffnx {Função} sinvertcase (@var{seq_caracte}, @var{início})  
@deffnx {Função} sinvertcase (@var{seq_caracte}, @var{início}, @var{fim})  
Retorna @var{seq_caracte} excepto que cada caractere da posição @var{início} até a posição @var{fim} está invertido.
Se a posição @var{fim} não for fornecida,
todos os caracteres do início ao @var{fim} de @var{seq_caracte} são substituídos.

@c ===beg===
@c load("stringproc")$
@c sinvertcase("sInvertCase");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) sinvertcase("sInvertCase");
(%o2)                      SiNVERTcASE
@end example

@end deffn

@deffn {Função} slength (@var{seq_caracte}) 
Retorna número de caracteres em @var{seq_caracte}. 

@end deffn

@deffn {Função} smake (@var{num}, @var{caractere}) 
Retorna uma nova sequência de caracteres repetindo @var{num} vezes @var{caractere}. 

@c ===beg===
@c load("stringproc")$
@c smake(3,"w");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) smake(3,"w");
(%o2)                          www
@end example

@end deffn

@deffn {Função} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2}) 
@deffnx {Função} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2}, @var{test}) 
Retorna a posição do primeiro caractere de @var{seq_caracte__1} no qual @var{seq_caracte__1} e @var{seq_caracte__2} diferem ou @code{false} em caso contrário.
A função padrao de teste para coincidência é @code{sequal}.
Se @code{smismatch} pode ignorar a caixa alta/baixa, use @code{sequalignore} como função de teste.

@c ===beg===
@c load("stringproc")$
@c smismatch("seven","seventh");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) smismatch("seven","seventh");
(%o2)                           6
@end example

@end deffn

@deffn {Função} split (@var{seq_caracte})  
@deffnx {Função} split (@var{seq_caracte}, @var{delim})  
@deffnx {Função} split (@var{seq_caracte}, @var{delim}, @var{multiple})  
Retorna a lista de todas as fichas em @var{seq_caracte}.
Cada ficha é uma sequência de caracteres não analisada.
@code{split} usa @var{delim} como delimitador.
Se @var{delim} não for fornecido, o caractere de espaço é o delimitador padrão.
@var{multiple} é uma variável booleana com @code{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 @var{multiple} for escolhido para @code{false}, cada delimitador é considerado.

@c ===beg===
@c load("stringproc")$
@c split("1.2   2.3   3.4   4.5");
@c split("first;;third;fourth",";",false);
@c ===end===
@example
(%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]
@end example

@end deffn

@deffn {Função} sposition (@var{caractere}, @var{seq_caracte}) 
Retorna a posição do primeiro caractere em @var{seq_caracte} que coincide com @var{caractere}.
O primeiro caractere em @var{seq_caracte} está na posição 1.
Para que os caracteres que coincidirem desconsiderem a caixa alta/baixa veja @code{ssearch}.

@end deffn

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

@c ===beg===
@c load("stringproc")$
@c sremove("n't","I don't like coffee.");
@c sremove ("DO ",%,'sequalignore);
@c ===end===
@example
(%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.
@end example

@end deffn

@deffn {Função} sremovefirst (@var{seq}, @var{seq_caracte})  
@deffnx {Função} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test})  
@deffnx {Função} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{início})  
@deffnx {Função} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{início}, @var{fim})  
Como em @code{sremove} excepto que a primeira subsequência de caracteres que coincide com @code{seq} é removida. 

@end deffn

@deffn {Função} sreverse (@var{seq_caracte}) 
Retorna uma sequência de caracteres com todos os caracteres de @var{seq_caracte} em ordem reversa. 

@end deffn

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

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

@end deffn

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

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

@end deffn

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

@c ===beg===
@c load("stringproc")$
@c ssubst("like","hate","I hate Thai food. I hate green tea.");
@c ssubst("Indian","thai",%,'sequalignore,8,12);
@c ===end===
@example
(%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.
@end example

@end deffn

@deffn {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}) 
@deffnx {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}) 
@deffnx {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{início}) 
@deffnx {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{início}, @var{fim}) 
Como em @code{subst} excepto que somente a primeira subsequência de caracteres que coincidir com @var{antiga} é substituída. 

@end deffn

@deffn {Função} strim (@var{seq},@var{seq_caracte}) 
Retorna uma sequência de caracteres como @var{seq_caracte},
mas com todos os caracteres que aparecerem em @var{seq} removidos de ambas as extremidades. 

@c ===beg===
@c load("stringproc")$
@c "/* comment */"$
@c strim(" /*",%);
@c slength(%);
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) "/* comment */"$
(%i3) strim(" /*",%);
(%o3)                        comment
(%i4) slength(%);
(%o4)                           7
@end example

@end deffn

@deffn {Função} striml (@var{seq}, @var{seq_caracte}) 
Como em @code{strim} excepto que somente a extremidade esquerda de @var{seq_caracte} é recordada. 

@end deffn

@deffn {Função} strimr (@var{seq}, @var{seq_caracte}) 
Como em @code{strim} excepto que somente a extremidade direita de sequência de caracteres é recortada. 

@end deffn

@deffn {Função} substring (@var{seq_caracte}, @var{início})
@deffnx {Função} substring (@var{seq_caracte}, @var{início}, @var{fim}) 
Retorna a subsequência de caracteres de @var{seq_caracte} começando na posição @var{início} e terminando na posição @var{fim}.
O caractere na posição @var{fim} não é incluído.
Se @var{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 @var{seq_caracte} está na posição 1.

@c ===beg===
@c load("stringproc")$
@c substring("substring",4);
@c substring(%,4,6);
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) substring("substring",4);
(%o2)                        string
(%i3) substring(%,4,6);
(%o3)                          in
@end example

@end deffn

@deffn {Função} supcase (@var{seq_caracte}) 
@deffnx {Função} supcase (@var{seq_caracte}, @var{início}) 
@deffnx {Função} supcase (@var{seq_caracte}, @var{início}, @var{fim}) 
Retorna @var{seq_caracte} excepto que caracteres em caixa baixa a partir da posição @var{início} até a posição @var{fim} são substituídos pelo correspondente caracteres em cixa alta.
Se @var{fim} não for fornecido,
todos os caracteres em caixa baixa de @var{início} até o fim de @var{seq_caracte} são substituídos.

@c ===beg===
@c load("stringproc")$
@c supcase("english",1,2);
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) supcase("english",1,2);
(%o2)                        English
@end example

@end deffn

@deffn {Função} tokens (@var{seq_caracte}) 
@deffnx {Função} tokens (@var{seq_caracte}, @var{test}) 
Retorna uma lista de fichas, que tiverem sido extrídos de @var{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, @var{constituent} é usada como teste padrão.
@code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}} é o conjunto de fnç~oes de teste. 
(A versão Lisp de @code{tokens} é escrita por Paul Graham. ANSI Common Lisp, 1996, page 67.)

@c ===beg===
@c load("stringproc")$
@c tokens("24 October 2005");
@c tokens("05-10-24",'digitcharp);
@c map(parsetoken,%);
@c ===end===
@example
(%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]
@end example

@end deffn

