doc/info/pt_BR/stringproc.texi

   1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
   2 @c /stringproc.texi/1.8/Sat Jun  2 00:13:34 2007//
   3 @menu
   4 * Introdução a manipulação de seq@"{u}ências de caracteres::
   5 * Funções e Variáveis para entrada e saída::
   6 * Funções e Variáveis para caracteres::
   7 * Funções e Variáveis para seq@"{u}ências de caracteres::
   8 @end menu
   9
  10 @node Introdução a manipulação de seq@"{u}ências de caracteres, Funções e Variáveis para entrada e saída, stringproc, stringproc
  11 @section Introdução a manipulação de seq@"{u}ências de caracteres
  12
  13 O arquivo @code{stringproc.lisp} amplia a compatibilidade do Maxima de trabalhar com seq@"{u}ências de caracteres
  14 e adiciona algumas funções úteis a entrada e saída de dados.
  15
  16 Para esclarecimentos e correções por favor mande um e-mail para van.nek at arcor.de .
  17
  18 No Maxima uma seq@"{u}ência de caracteres é facilmente contruída digitando "texto" (qualquer texto desejado entre aspas duplas).
  19 Note que seq@"{u}ências de caracteres do Maxima não são seq@"{u}ências de caracteres do Lisp e vice-versa.
  20 @code{stringp} realiza testes para seq@"{u}ências de caracteres
  21 do Maxima, e @code{lstringp} realiza testes para seq@"{u}ências de caracteres do Lisp.
  22 Se por alguma razão voce tiver um valor,
  23 que é uma seq@"{u}ência de caracteres do Lisp, talvez quando estiver usando a função @code{sconcat} do Maxima, você pode converter via @code{sunlisp}.
  24
  25
  26 @c ===beg===
  27 @c m: "text";
  28 @c [stringp(m),lstringp(m)];
  29 @c l: sconcat("text");
  30 @c [stringp(l),lstringp(l)];
  31 @c stringp( sunlisp(l) );
  32 @c ===end===
  33 @example
  34 (%i1) m: "text";
  35 (%o1)                         text
  36 (%i2) [stringp(m),lstringp(m)];
  37 (%o2)                     [true, false]
  38 (%i3) l: sconcat("text");
  39 (%o3)                         text
  40 (%i4) [stringp(l),lstringp(l)];
  41 (%o4)                     [false, true]
  42 (%i5) stringp( sunlisp(l) );
  43 (%o5)                         true
  44 @end example
  45
  46 Todas as funções em @code{stringproc.lisp}, que retornarem seq@"{u}ências de caracteres, retornam seq@"{u}ências de caracteres do Maxima.
  47
  48 Caracteres são introduzidos como seq@"{u}ências de caracteres do Maxima de comprimento 1.
  49 Com certeza, esses caracteres não são caracteres do Lisp.
  50 Testes podem ser realizados com @code{charp} ( @code{lcharp} e conversões do Lisp para o Maxima com @code{cunlisp}).
  51
  52
  53 @c ===beg===
  54 @c c: "e";
  55 @c [charp(c),lcharp(c)];
  56 @c supcase(c);
  57 @c charp(%);
  58 @c ===end===
  59 @example
  60 (%i1) c: "e";
  61 (%o1)                           e
  62 (%i2) [charp(c),lcharp(c)];
  63 (%o2)                     [true, false]
  64 (%i3) supcase(c);
  65 (%o3)                           E
  66 (%i4) charp(%);
  67 (%o4)                         true
  68 @end example
  69
  70 Novamente, todas as funções em @code{stringproc.lisp}, que retornam caracteres, retornam caracteres do Maxima.
  71 devido a esse fato, que os caracteres introduzidos são seq@"{u}ências de caracteres comprimento 1,
  72 você pode usar muitas das funções de seq@"{u}ência de caracteres também para caracteres.
  73 Como visto, @code{supcase} é um exemplo.
  74
  75 É importante saber,
  76 que o primeiro caractere em uma seq@"{u}ência de caracteres do Maxima éstá na posição 1.
  77 Isso é designado devido ao fato de o primeiro elemento em uma lista do Maxima está na posição 1 também.
  78 Veja definições de @code{charat} e de @code{charlist} para obter exemplos.
  79
  80 Em aplicações fnções de seq@"{u}ência de caractere são muitas vezes usadas quando estamos trabalhando com arquivos.
  81 Você encontrará algumas úteis funções de fluxo e funções de impressões em @code{stringproc.lisp}.
  82 O seguinte exemplo mostra algumas das funções aqui introduzidas no trabalho.
  83
  84 Exemplo:
  85
  86 @code{openw} retorna um fluxo de saída para um arquivo, @code{printf} então permite escrita formatada
  87 para esse arquivo. Veja @code{printf} para detalhes.
  88
  89 @example
  90 +(%i1) s: openw("E:/file.txt");
  91 +(%o1)                    #<output stream E:/file.txt>
  92 +(%i2) for n:0 thru 10 do printf( s, "~d ", fib(n) );
  93 +(%o2)                                done
  94 +(%i3) printf( s, "~%~d ~f ~a ~a ~f ~e ~a~%",
  95                42,1.234,sqrt(2),%pi,1.0e-2,1.0e-2,1.0b-2 );
  96 +(%o3)                                false
  97 +(%i4) close(s);
  98 +(%o4)                                true
  99 @end example
 100
 101 Após fechar o fluxo você pode abrí-lo novamente, dessa vez com direção de entrada.
 102 @code{readline} retorna a linha completa como uma seq@"{u}ência de caracteres. O pacote @code{stringproc}
 103 agora oferece muitas funções para manipulação de seq@"{u}ências de caracteres. A troca de indicações/fichas pode ser realizada por
 104 @code{split} ou por @code{tokens}.
 105
 106 @example
 107 (%i5) s: openr("E:/file.txt");
 108 (%o5)                     #<input stream E:/file.txt>
 109 (%i6) readline(s);
 110 (%o6)                     0 1 1 2 3 5 8 13 21 34 55
 111 (%i7) line: readline(s);
 112 (%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
 113 (%i8) list: tokens(line);
 114 (%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
 115 (%i9) map( parsetoken, list );
 116 (%o9)           [42, 1.234, false, false, 0.01, 0.01, false]
 117 @end example
 118
 119 @code{parsetoken} somente analiza números inteiros e em ponto flutuante. A análise de símbolos ou grandes números em ponto flutuante
 120 precisa de @code{parse_string}, que irá ser disponibilizada para uso automaticamente através de @code{eval_string.lisp}.
 121
 122 @example
 123 (%i10) map( parse_string, list );
 124 (%o10)           [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
 125 (%i11) float(%);
 126 (%o11) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01, 0.01, 0.01]
 127 (%i12) readline(s);
 128 (%o12)                               false
 129 (%i13) close(s)$
 130 @end example
 131
 132 @code{readline} retorna @code{false} quado o fim de arquivo acontecer.
 133
 134 @node Funções e Variáveis para entrada e saída, Funções e Variáveis para caracteres, Introdução a manipulação de seq@"{u}ências de caracteres, stringproc
 135 @section Funções e Variáveis para entrada e saída
 136
 137 Exemplo:
 138
 139 @c ===beg===
 140 @c s: openw("E:/file.txt");
 141 @c control:
 142 @c  "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2tand an integer: ~20t~d~%"$
 143 @c printf( s,control, 'true,[1,2,3],42 )$
 144 @c close(s);
 145 @c s: openr("E:/file.txt");
 146 @c while stringp( tmp:readline(s) ) do print(tmp)$
 147 @c close(s)$
 148 @c ===end===
 149 @example
 150 (%i1) s: openw("E:/file.txt");
 151 (%o1)                     #<output stream E:/file.txt>
 152 (%i2) control:
 153  "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2tand an integer: ~20t~d~%"$
 154 (%i3) printf( s,control, 'true,[1,2,3],42 )$
 155 (%o3)                                false
 156 (%i4) close(s);
 157 (%o4)                                true
 158 (%i5) s: openr("E:/file.txt");
 159 (%o5)                     #<input stream E:/file.txt>
 160 (%i6) while stringp( tmp:readline(s) ) do print(tmp)$
 161   An atom:          true
 162   and a list:       one two three
 163   and an integer:   42
 164 (%i7) close(s)$
 165 @end example
 166
 167
 168 @deffn {Função} close (@var{fluxo})
 169 Fecha  @var{fluxo} e retorna @code{true} se @var{fluxo} tiver sido aberto anteriormente.
 170
 171 @end deffn
 172
 173 @deffn {Função} flength (@var{fluxo})
 174 Retorna o número de elementos em @var{fluxo}.
 175
 176 @end deffn
 177
 178 @deffn {Função} fposition (@var{fluxo})
 179 @deffnx {Função} fposition (@var{fluxo}, @var{pos})
 180 Retorna a posição corrente em @var{fluxo}, se @var{pos} não está sendo usada.
 181 Se @var{pos} estiver sendo usada,
 182 @code{fposition} escolhe a posição em @var{fluxo}.
 183 @var{pos} tem que ser um número positivo,
 184 o primeiro elemento em @var{fluxo} está na posição 1.
 185
 186 @end deffn
 187
 188 @deffn {Função} freshline ()
 189 @deffnx {Função} freshline (@var{fluxo})
 190 escreve uma nova linha (em @var{fluxo}),
 191 se a posição atual não for um início de linha.
 192 Veja também @code{newline}.
 193 @end deffn
 194
 195 @deffn {Função} newline ()
 196 @deffnx {Função} newline (@var{fluxo})
 197 Escreve uma nova linha (para @var{fluxo}).
 198 Veja @code{sprint} para um exemplo de uso de @code{newline()}.
 199 Note que existem alguns casos, onde @code{newline()}não trabalha como esperado.
 200
 201 @end deffn
 202
 203 @deffn {Função} opena (@var{arquivo})
 204 Retorna um fluxo de saída para @var{arquivo}.
 205 Se um arquivo já existente tiver sido aberto, @code{opena} anexa os elementos ao final do arquivo.
 206
 207 @end deffn
 208
 209 @deffn {Função} openr (@var{arquivo})
 210 Retorna um fluxo para @var{arquivo}.
 211 Se @var{arquivo} não existir, ele será criado.
 212
 213 @end deffn
 214
 215 @deffn {Função} openw (@var{arquivo})
 216 Retorna um fluxo de saída para @var{arquivo}.
 217 Se @var{arquivo} não existir, será criado.
 218 Se um arquivo já existente for aberto, @code{openw} modifica destrutivametne o @var{arquivo}.
 219
 220 @end deffn
 221
 222 @deffn {Função} printf (@var{dest}, @var{seq_caracte})
 223 @deffnx {Função} printf (@var{dest}, @var{seq_caracte}, @var{expr_1}, ..., @var{expr_n})
 224 Torna a função FORMAT do Lisp Comum disponível no Maxima.
 225 (Retirado de gcl.info: "format produces formatted output by outputting the caracteres of
 226 control-string string and observing that a tilde introduces a directive.
 227 The caractere after the tilde,
 228 possibly preceded by prefix parameters and modifiers,
 229 specifies what kind of formatting is desired.
 230 Most directives use one or more elements of args to create their output.")
 231
 232 A seguinte descrição e oa exemplos podem fornecer uma idéia de uso de @code{printf}.
 233 Veja um referência de Lisp para maiores informações.
 234
 235 @example
 236    ~%       nova linha
 237    ~&       novíssima line
 238    ~t       tabulação
 239    ~$       monetário
 240    ~d       inteiro decimal
 241    ~b       inteiro binário
 242    ~o       inteiro octal
 243    ~x       inteiro hexadecimal
 244    ~br      inteiro de base b
 245    ~r       soletra um inteiro
 246    ~p       plural
 247    ~f       ponto flutuante
 248    ~e       notação científica
 249    ~g       ~f ou ~e, dependendo  da magnitude
 250    ~a       como mostrado pela função print do Maxima
 251    ~s       seq@"{u}ências de caracteres entre "aspas duplas"
 252    ~~       ~
 253    ~<       justificação de texto, ~> terminador de justificação de texto
 254    ~(       conversão de caixa alta/baixa, ~) terminador de conversão de caixa
 255    ~[       seleção, ~] terminador de seleção
 256    ~@{       iteração, ~@} terminador de iteração
 257 @end example
 258
 259 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
 260 simplesmente serem mostrados por meio da diretiva @code{~a}.
 261 @code{~s} mostra a seq@"{u}ências de caracteres entre "aspas duplas", você pode evitar isso usando @code{~a}.
 262 Note que a diretiva de seleção @code{~[} é indexada em zero.
 263 Também note que existem algumas diretivas, que não trabalham no Maxima.
 264 Por exemplo, @code{~:[} falha.
 265
 266 @c ===beg===
 267 @c printf( false, "~a ~a ~4f ~a ~@@r",
 268 @c         "String",sym,bound,sqrt(12),144), bound = 1.234;
 269 @c printf( false,"~@{~a ~@}",["one",2,"THREE"] );
 270 @c printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
 271 @c         mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
 272 @c control: "~:(~r~) bird~p ~[is~;are~] singing."$
 273 @c printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
 274 @c ===end===
 275 @example
 276 (%i1) printf( false, "~a ~a ~4f ~a ~@@r",
 277               "String",sym,bound,sqrt(12),144), bound = 1.234;
 278 (%o1)                 String sym 1.23 2*sqrt(3) CXLIV
 279 (%i2) printf( false,"~@{~a ~@}",["one",2,"THREE"] );
 280 (%o2)                          one 2 THREE
 281 (%i3) printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
 282               mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
 283       1.1       2.0       3.3
 284       4.0       5.0       6.0
 285       7.0       8.9       9.0
 286 (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
 287 (%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
 288 (%o5)                    Two birds are singing.
 289 @end example
 290
 291 Se @var{dest} for um fluxo ou @code{true}, então @code{printf} retorna @code{false}.
 292 De outra forma, @code{printf} retorna uma seq@"{u}ência de caracteres contendo a saída.
 293
 294 @end deffn
 295
 296 @deffn {Função} readline (@var{fluxo})
 297 Retorna uma seq@"{u}ê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 arquivo for encontrado.
 298
 299 @end deffn
 300
 301 @deffn {Função} sprint (@var{expr_1}, ..., @var{expr_n})
 302 Avalia e mostra seus argumentos um após o outro `sobre uma linha' iniciando na posição mais à esquerda.
 303 Os números são mostrados com o '-' à direita do número,
 304 e isso desconsidera o comprimento da linha. @code{newline()}, que irá ser chamada automaticamente a partir de @code{stringproc.lisp}
 305 pode ser útil, se você desejar colocar uma parada de linha intermediária.
 306
 307 @c ===beg===
 308 @c for n:0 thru 22 do sprint( fib(n) )$
 309 @c for n:0 thru 22 do (
 310 @c    sprint(fib(n)), if mod(n,10)=9 then newline() )$
 311 @c ===end===
 312 @example
 313 (%i1) for n:0 thru 22 do sprint( fib(n) )$
 314 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711
 315 (%i2) for n:0 thru 22 do (
 316          sprint(fib(n)), if mod(n,10)=9 then newline() )$
 317 0 1 1 2 3 5 8 13 21 34
 318 55 89 144 233 377 610 987 1597 2584 4181
 319 6765 10946 17711
 320 @end example
 321
 322 @end deffn
 323
 324 @node Funções e Variáveis para caracteres, Funções e Variáveis para seq@"{u}ências de caracteres, Funções e Variáveis para entrada e saída, stringproc
 325 @section Funções e Variáveis para caracteres
 326
 327 @deffn {Função} alphacharp (@var{caractere})
 328 Retorna @code{true} se @var{caractere} for um caractere alfabético.
 329
 330 @end deffn
 331
 332 @deffn {Função} alphanumericp (@var{caractere})
 333 Retorna @code{true} se @var{caractere} for um caractere alfabético ou um dígito.
 334
 335 @end deffn
 336
 337 @deffn {Função} ascii (@var{int})
 338 Retorna o caractere correspondente ao código numérico ASCII @var{int}.
 339 ( -1 < int < 256 )
 340
 341 @c ===beg===
 342 @c for n from 0 thru 255 do (
 343 @c    tmp: ascii(n), if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
 344 @c ===end===
 345 @example
 346 (%i1) for n from 0 thru 255 do (
 347 tmp: ascii(n), if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
 348 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
 349 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
 350 @end example
 351
 352 @end deffn
 353
 354 @deffn {Função} cequal (@var{caractere_1}, @var{caractere_2})
 355 Retorna @code{true} se @var{caractere_1} e @var{caractere_2} forem os mesmos.
 356
 357 @end deffn
 358
 359 @deffn {Função} cequalignore (@var{caractere_1}, @var{caractere_2})
 360 como @code{cequal} mas ignora a caixa alta/baixa.
 361
 362 @end deffn
 363
 364 @deffn {Função} cgreaterp (@var{caractere_1}, @var{caractere_2})
 365 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}.
 366
 367 @end deffn
 368
 369 @deffn {Função} cgreaterpignore (@var{caractere_1}, @var{caractere_2})
 370 Como @code{cgreaterp} mas ignora a caixa alta/baixa.
 371
 372 @end deffn
 373
 374 @deffn {Função} charp (@var{obj})
 375 Retorna @code{true} se @var{obj} for um caractere do Maxima.
 376 Veja na seção "Introdução a manipulação de seq@"{u}ências de caracteres" para ter um exemplo.
 377
 378 @end deffn
 379
 380 @deffn {Função} cint (@var{caractere})
 381 Retorna o código numéico ASCII de @var{caractere}.
 382
 383 @end deffn
 384
 385 @deffn {Função} clessp (@var{caractere_1}, @var{caractere_2})
 386 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}.
 387
 388 @end deffn
 389
 390 @deffn {Função} clesspignore (@var{caractere_1}, @var{caractere_2})
 391 Como em @code{clessp} ignora a caixa alta/baixa.
 392
 393 @end deffn
 394
 395 @deffn {Função} constituent (@var{caractere})
 396 Retorna @code{true} se @var{caractere} for caractere  gráfico e não o caractere de espaço em branco.
 397 Um caractere gráfico é um caractere que se pode ver, adicionado o caractere de espaço em branco.
 398 (@code{constituent} foi definida por Paul Graham, em ANSI Common Lisp, 1996, página 67.)
 399
 400 @c ===beg===
 401 @c for n from 0 thru 255 do (
 402 @c    tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
 403 @c ===end===
 404 @example
 405 (%i1) for n from 0 thru 255 do (
 406 tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
 407 ! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @@ A B
 408 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
 409 d e f g h i j k l m n o p q r s t u v w x y z @{ | @} ~
 410 @end example
 411
 412 @end deffn
 413
 414 @deffn {Função} cunlisp (@var{lisp_char})
 415 Converte um caractere do Lisp em um caractere do Maxima.
 416 (Você pode não precisar dessa função.)
 417
 418 @end deffn
 419
 420 @deffn {Função} digitcharp (@var{caractere})
 421 Retorna @code{true} se @var{caractere} for um dígito (algarismo de 0 a 9).
 422
 423 @end deffn
 424
 425 @deffn {Função} lcharp (@var{obj})
 426 Retorna @code{true} se @var{obj} for um caractere do Lisp.
 427 (Você pode não precisar dessa função.)
 428
 429 @end deffn
 430
 431 @deffn {Função} lowercasep (@var{caractere})
 432 Retorna @code{true} se @var{caractere} for um caractere em caixa baixa.
 433
 434 @end deffn
 435
 436 @defvr {Variable} newline
 437 O caractere de nova linha.
 438
 439 @end defvr
 440
 441 @defvr {Variável} space
 442 O caractere de espaço em branco.
 443
 444 @end defvr
 445
 446 @defvr {Variável} tab
 447 O caractere de tabulação.
 448
 449 @end defvr
 450
 451 @deffn {Função} uppercasep (@var{caractere})
 452 Retorna @code{true} se @var{caractere} for um caractere em caixa alta.
 453
 454 @end deffn
 455
 456 @node Funções e Variáveis para seq@"{u}ências de caracteres,  , Funções e Variáveis para caracteres, stringproc
 457 @section Funções e Variáveis para seq@"{u}ências de caracteres
 458
 459 @deffn {Função} sunlisp (@var{lisp_string})
 460 Converte uma seq@"{u}ência de caracteres do Lisp em uma seq@"{u}ência de caracteres do Maxima.
 461 (Em geral você pode não precisar dessa função.)
 462
 463 @end deffn
 464
 465 @deffn {Função} lstringp (@var{obj})
 466 Retorna @code{true} se @var{obj} is uma seq@"{u}ência de caracteres do Lisp.
 467 (Em geral você pode não precisar dessa função.)
 468
 469 @end deffn
 470
 471 @deffn {Função} stringp (@var{obj})
 472 Retorna @code{true} se @var{obj} for uma seq@"{u}ência de caracteres do Maxima.
 473 Veja a introdução para obter exemplos.
 474
 475 @end deffn
 476
 477 @deffn {Função} charat (@var{seq_caracte}, @var{n})
 478 Retorna o @var{n}-ésimo caractere de @var{seq_caracte}.
 479 O primeiro caractere em @var{seq_caracte} é retornado com @var{n} = 1.
 480
 481 @c ===beg===
 482 @c charat("Lisp",1);
 483 @c ===end===
 484 @example
 485 (%i1) charat("Lisp",1);
 486 (%o1)                           L
 487 @end example
 488
 489 @end deffn
 490
 491 @deffn {Função} charlist (@var{seq_caracte})
 492 Retorna a lsita de todos os caracteres em @var{seq_caracte}.
 493
 494 @c ===beg===
 495 @c charlist("Lisp");
 496 @c %[1];
 497 @c ===end===
 498 @example
 499 (%i1) charlist("Lisp");
 500 (%o1)                     [L, i, s, p]
 501 (%i2) %[1];
 502 (%o2)                           L
 503 @end example
 504
 505 @end deffn
 506
 507 @deffn {Função} parsetoken (@var{seq_caracte})
 508 @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.
 509 O conjunto de delimitadores para a troca de fichas é @code{@{space, comma, semicolon, tab, newline@}}
 510
 511 Nota de tradução:
 512 espaço, vírgula, ponto e vírgula, tabulação e nova linha.
 513
 514 @c ===beg===
 515 @c 2*parsetoken("1.234 5.678");
 516 @c ===end===
 517 @example
 518 (%i1) 2*parsetoken("1.234 5.678");
 519 (%o1)                         2.468
 520 @end example
 521
 522 Para analizar você pode também usar  a função @code{parse_string}.
 523 Veja a descrição no arquivo 'share\contrib\eval_string.lisp'.
 524
 525 @end deffn
 526
 527 @deffn {Função} sconc (@var{expr_1}, ..., @var{expr_n})
 528 Avalia seus argumentos e concatena-os em uma seq@"{u}ência de caracteres.
 529 @code{sconc} é como @code{sconcat} mas retorna uma seq@"{u}ência de caracteres do Maxima.
 530
 531 @c ===beg===
 532 @c sconc("xx[",3,"]:",expand((x+y)^3));
 533 @c stringp(%);
 534 @c ===end===
 535 @example
 536 (%i1) sconc("xx[",3,"]:",expand((x+y)^3));
 537 (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
 538 (%i2) stringp(%);
 539 (%o2)                         true
 540 @end example
 541
 542 @end deffn
 543
 544 @deffn {Função} scopy (@var{seq_caracte})
 545 Retorna uma cópia de @var{seq_caracte} como uma nova seq@"{u}ência de caracteres.
 546
 547 @end deffn
 548
 549 @deffn {Função} sdowncase (@var{seq_caracte})
 550 @deffnx {Função} sdowncase (@var{seq_caracte}, @var{início})
 551 @deffnx {Função} sdowncase (@var{seq_caracte}, @var{início}, @var{fim})
 552 Como em @code{supcase}, mas caracteres em caixa alta são convertidos para caracteres em caixa baixa.
 553
 554 @end deffn
 555
 556 @deffn {Função} sequal (@var{seq_caracte__1}, @var{seq_caracte__2})
 557 Retorna @code{true} se @var{seq_caracte__1} e @var{seq_caracte__2} tiverem o mesmo comprimento e contiverem os mesmos caracteres.
 558
 559 @end deffn
 560
 561 @deffn {Função} sequalignore (@var{seq_caracte__1}, @var{seq_caracte__2})
 562 Como em @code{sequal} mas igonara a caixa alta/baixa.
 563
 564 @end deffn
 565
 566 @deffn {Função} sexplode (@var{seq_caracte})
 567 @code{sexplode} é um apelido para a função @code{charlist}.
 568
 569 @end deffn
 570
 571 @deffn {Função} simplode (@var{lista})
 572 @deffnx {Função} simplode (@var{lista}, @var{delim})
 573 @code{simplode} takes uma @code{lista} ou expressões  e concatena-as em uma seq@"{u}ência de caracteres.
 574 Se nenhum delimitador @var{delim} for usado, @code{simplode} funciona como @code{sconc} e não utiliza delimitador.
 575 @var{delim} pode ser qualquer seq@"{u}ência de caracteres.
 576
 577 @c ===beg===
 578 @c simplode(["xx[",3,"]:",expand((x+y)^3)]);
 579 @c simplode( sexplode("stars")," * " );
 580 @c simplode( ["One","more","coffee."]," " );
 581 @c ===end===
 582 @example
 583 (%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
 584 (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
 585 (%i2) simplode( sexplode("stars")," * " );
 586 (%o2)                   s * t * a * r * s
 587 (%i3) simplode( ["One","more","coffee."]," " );
 588 (%o3)                   One more coffee.
 589 @end example
 590
 591 @end deffn
 592
 593 @deffn {Função} sinsert (@var{seq}, @var{seq_caracte}, @var{pos})
 594 Retorna uma seq@"{u}ência de caracteres que é uma concatenação de @code{substring (@var{seq_caracte}, 1, @var{pos} - 1)},
 595 a seq@"{u}ência de caracteres @var{seq} e @code{substring (@var{seq_caracte}, @var{pos})}.
 596 Note que o primeiro caractere está em @var{seq_caracte} e está na posição 1.
 597
 598 @c ===beg===
 599 @c s: "A submarine."$
 600 @c sconc( substring(s,1,3),"yellow ",substring(s,3) );
 601 @c sinsert("hollow ",s,3);
 602 @c ===end===
 603 @example
 604 (%i1) s: "A submarine."$
 605 (%i2) sconc( substring(s,1,3),"yellow ",substring(s,3) );
 606 (%o2)                  A yellow submarine.
 607 (%i3) sinsert("hollow ",s,3);
 608 (%o3)                  A hollow submarine.
 609 @end example
 610
 611 @end deffn
 612
 613 @deffn {Função} sinvertcase (@var{seq_caracte})
 614 @deffnx {Função} sinvertcase (@var{seq_caracte}, @var{início})
 615 @deffnx {Função} sinvertcase (@var{seq_caracte}, @var{início}, @var{fim})
 616 Retorna @var{seq_caracte} exceto que cada caractere da posição @var{início} até a posição @var{fim} está invertido.
 617 Se a posição @var{fim} não for fornecida,
 618 todos os caracteres do início ao @var{fim} de @var{seq_caracte} são substituídos.
 619
 620 @c ===beg===
 621 @c sinvertcase("sInvertCase");
 622 @c ===end===
 623 @example
 624 (%i1) sinvertcase("sInvertCase");
 625 (%o1)                      SiNVERTcASE
 626 @end example
 627
 628 @end deffn
 629
 630 @deffn {Função} slength (@var{seq_caracte})
 631 Retorna número de caracteres em @var{seq_caracte}.
 632
 633 @end deffn
 634
 635 @deffn {Função} smake (@var{num}, @var{caractere})
 636 Retorna uma nova seq@"{u}ência de caracteres repetindo @var{num} vezes @var{caractere}.
 637
 638 @c ===beg===
 639 @c smake(3,"w");
 640 @c ===end===
 641 @example
 642 (%i1) smake(3,"w");
 643 (%o1)                          www
 644 @end example
 645
 646 @end deffn
 647
 648 @deffn {Função} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2})
 649 @deffnx {Função} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2}, @var{test})
 650 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.
 651 A função padrao de teste para coincidência é @code{sequal}.
 652 Se @code{smismatch} pode ignorar a caixa alta/baixa, use @code{sequalignore} como função de teste.
 653
 654 @c ===beg===
 655 @c smismatch("seven","seventh");
 656 @c ===end===
 657 @example
 658 (%i1) smismatch("seven","seventh");
 659 (%o1)                           6
 660 @end example
 661
 662 @end deffn
 663
 664 @deffn {Função} split (@var{seq_caracte})
 665 @deffnx {Função} split (@var{seq_caracte}, @var{delim})
 666 @deffnx {Função} split (@var{seq_caracte}, @var{delim}, @var{multiple})
 667 Retorna a lista de todas as fichas em @var{seq_caracte}.
 668 Cada ficha é uma seq@"{u}ência de caracteres não analisada.
 669 @code{split} usa @var{delim} como delimitador.
 670 Se @var{delim} não for fornecido, o caractere de espaço é o delimitador padrão.
 671 @var{multiple} é uma variável booleana com @code{true} como valor padrão.
 672 Multiplos delimitadores são lidos como um.
 673 Essa função é útil se tabulações são gravadas com caracteres de espaço multiplos.
 674 Se @var{multiple} for escolhido para @code{false}, cada delimitador é considerado.
 675
 676 @c ===beg===
 677 @c split("1.2   2.3   3.4   4.5");
 678 @c split("first;;third;fourth",";",false);
 679 @c ===end===
 680 @example
 681 (%i1) split("1.2   2.3   3.4   4.5");
 682 (%o1)                 [1.2, 2.3, 3.4, 4.5]
 683 (%i2) split("first;;third;fourth",";",false);
 684 (%o2)               [first, , third, fourth]
 685 @end example
 686
 687 @end deffn
 688
 689 @deffn {Função} sposition (@var{caractere}, @var{seq_caracte})
 690 Retorna a posição do primeiro caractere em @var{seq_caracte} que coincide com @var{caractere}.
 691 O primeiro caractere em @var{seq_caracte} está na posição 1.
 692 Para que os caracteres que coincidirem desconsiderem a caixa alta/baixa veja @code{ssearch}.
 693
 694 @end deffn
 695
 696 @deffn {Função} sremove (@var{seq}, @var{seq_caracte})
 697 @deffnx {Função} sremove (@var{seq}, @var{seq_caracte}, @var{test})
 698 @deffnx {Função} sremove (@var{seq}, @var{seq_caracte}, @var{test}, @var{início})
 699 @deffnx {Função} sremove (@var{seq}, @var{seq_caracte}, @var{test}, @var{início}, @var{fim})
 700 Retorna uma seq@"{u}ência de caracteres como @var{seq_caracte} mas com todas as subseq@"{u}ências de caracteres que coincidirem com @var{seq}.
 701 A função padrão de teste de coincidência é @code{sequal}.
 702 Se @code{sremove} puder ignorar a caixa alta/baixa enquanto busca por @var{seq}, use @code{sequalignore} como teste.
 703 Use @var{início} e @var{fim} para limitar a busca.
 704 Note que o primeiro caractere em @var{seq_caracte} está na posição 1.
 705
 706 @c ===beg===
 707 @c sremove("n't","I don't like coffee.");
 708 @c sremove ("DO ",%,'sequalignore);
 709 @c ===end===
 710 @example
 711 (%i1) sremove("n't","I don't like coffee.");
 712 (%o1)                   I do like coffee.
 713 (%i2) sremove ("DO ",%,'sequalignore);
 714 (%o2)                    I like coffee.
 715 @end example
 716
 717 @end deffn
 718
 719 @deffn {Função} sremovefirst (@var{seq}, @var{seq_caracte})
 720 @deffnx {Função} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test})
 721 @deffnx {Função} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{início})
 722 @deffnx {Função} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{início}, @var{fim})
 723 Como em @code{sremove} exceto qie a primeira subseq@"{u}ência de caracteres que coincide com @code{seq} é removida.
 724
 725 @end deffn
 726
 727 @deffn {Função} sreverse (@var{seq_caracte})
 728 Retorna uma seq@"{u}ência de caracteres com todos os caracteres de @var{seq_caracte} em ordem reversa.
 729
 730 @end deffn
 731
 732 @deffn {Função} ssearch (@var{seq}, @var{seq_caracte})
 733 @deffnx {Função} ssearch (@var{seq}, @var{seq_caracte}, @var{test})
 734 @deffnx {Função} ssearch (@var{seq}, @var{seq_caracte}, @var{test}, @var{início})
 735 @deffnx {Função} ssearch (@var{seq}, @var{seq_caracte}, @var{test}, @var{início}, @var{fim})
 736 Retorna a posição da primeira subseq@"{u}ência de caracteres de @var{seq_caracte} que coincide com a seq@"{u}ência de caracteres @var{seq}.
 737 A função padrão de teste de coincidência é @code{sequal}.
 738 Se @code{ssearch} puder igonorar a caixa alta/baixa, use @code{sequalignore} como função de teste.
 739 Use @var{início} e @var{fim} para limitar a busca.
 740 Note que o primeiro caractere em @var{seq_caracte} está na posição 1.
 741
 742 @example
 743 (%i1) ssearch("~s","~@{~S ~@}~%",'sequalignore);
 744 (%o1)                                  4
 745 @end example
 746
 747 @end deffn
 748
 749 @deffn {Função} ssort (@var{seq_caracte})
 750 @deffnx {Função} ssort (@var{seq_caracte}, @var{test})
 751 Retorna uma seq@"{u}ê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}.
 752 A função padrão de teste para ordenaçào é @var{clessp}.
 753 O conjunto de funções de teste é @code{@{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore@}}.
 754
 755 @c ===beg===
 756 @c ssort("I don't like Mondays.");
 757 @c ssort("I don't like Mondays.",'cgreaterpignore);
 758 @c ===end===
 759 @example
 760 (%i1) ssort("I don't like Mondays.");
 761 (%o1)                    '.IMaddeiklnnoosty
 762 (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
 763 (%o2)                 ytsoonnMlkIiedda.'
 764 @end example
 765
 766 @end deffn
 767
 768 @deffn {Função} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte})
 769 @deffnx {Função} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test})
 770 @deffnx {Função} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{início})
 771 @deffnx {Função} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{início}, @var{fim})
 772 Retorna uma seq@"{u}ência de caracteres como @var{seq_caracte} exceto que todas as subseq@"{u}ências de caracteres que coincidirem com @var{antiga} são substituídas por @var{nova}.
 773 @var{antiga} e @var{nova} não precisam ser de mesmo comprimento.
 774 A função padrão de teste para coincidência é para coincidências é @code{sequal}.
 775 Se @code{ssubst} puder ignorar a cixa alta/baixa enquanto procurando por @var{antiga}, use @code{sequalignore} como função de teste.
 776 Use @var{início} e @var{fim} para limitar a busca.
 777 Note que o primeiro caractere em @var{seq_caracte} está na posição 1.
 778
 779 @c ===beg===
 780 @c ssubst("like","hate","I hate Thai food. I hate green tea.");
 781 @c ssubst("Indian","thai",%,'sequalignore,8,12);
 782 @c ===end===
 783 @example
 784 (%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
 785 (%o1)          I like Thai food. I like green tea.
 786 (%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
 787 (%o2)         I like Indian food. I like green tea.
 788 @end example
 789
 790 @end deffn
 791
 792 @deffn {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte})
 793 @deffnx {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test})
 794 @deffnx {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{início})
 795 @deffnx {Função} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{início}, @var{fim})
 796 Como em @code{subst} exceto que somente a primeira subseq@"{u}ência de caracteres que coincidir com @var{antiga} é substituída.
 797
 798 @end deffn
 799
 800 @deffn {Função} strim (@var{seq},@var{seq_caracte})
 801 Retorna uma seq@"{u}ência de caracteres como @var{seq_caracte},
 802 mas com todos os caracteres que aparecerem em @var{seq} removidos de ambas as extremidades.
 803
 804 @c ===beg===
 805 @c "/* comment */"$
 806 @c strim(" /*",%);
 807 @c slength(%);
 808 @c ===end===
 809 @example
 810 (%i1) "/* comment */"$
 811 (%i2) strim(" /*",%);
 812 (%o2)                        comment
 813 (%i3) slength(%);
 814 (%o3)                           7
 815 @end example
 816
 817 @end deffn
 818
 819 @deffn {Função} striml (@var{seq}, @var{seq_caracte})
 820 Como em @code{strim} exceto que somente a extremidade esquerda de @var{seq_caracte} é recordada.
 821
 822 @end deffn
 823
 824 @deffn {Função} strimr (@var{seq}, @var{seq_caracte})
 825 Como em @code{strim} exceto que somente a extremidade direita de seq@"{u}ência de caracteres é recortada.
 826
 827 @end deffn
 828
 829 @deffn {Função} substring (@var{seq_caracte}, @var{início})
 830 @deffnx {Função} substring (@var{seq_caracte}, @var{início}, @var{fim})
 831 Retorna a subseq@"{u}ência de caracteres de @var{seq_caracte} começando na posição @var{início} e terminando na posição @var{fim}.
 832 O caractere na posição @var{fim} não é incluído.
 833 Se @var{fim} não for fornecido, a subseq@"{u}ência de caracteres contém o restante da seq@"{u}ência de caracteres.
 834 Note que o primeiro caractere em @var{seq_caracte} está na posição 1.
 835
 836 @c ===beg===
 837 @c substring("substring",4);
 838 @c substring(%,4,6);
 839 @c ===end===
 840 @example
 841 (%i1) substring("substring",4);
 842 (%o1)                        string
 843 (%i2) substring(%,4,6);
 844 (%o2)                          in
 845 @end example
 846
 847 @end deffn
 848
 849 @deffn {Função} supcase (@var{seq_caracte})
 850 @deffnx {Função} supcase (@var{seq_caracte}, @var{início})
 851 @deffnx {Função} supcase (@var{seq_caracte}, @var{início}, @var{fim})
 852 Retorna @var{seq_caracte} exceto 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 caixa alta.
 853 Se @var{fim} não for fornecido,
 854 todos os caracteres em caixa baixa de @var{início} até o fim de @var{seq_caracte} são substituídos.
 855
 856 @c ===beg===
 857 @c supcase("english",1,2);
 858 @c ===end===
 859 @example
 860 (%i1) load("stringproc")$
 861 (%i1) supcase("english",1,2);
 862 (%o1)                        English
 863 @end example
 864
 865 @end deffn
 866
 867 @deffn {Função} tokens (@var{seq_caracte})
 868 @deffnx {Função} tokens (@var{seq_caracte}, @var{test})
 869 Retorna uma lista de fichas, que tiverem sido extrídos de @var{seq_caracte}.
 870 As fichas são subseq@"{u}ências de caracteres cujos caracteres satisfazem a uma determinada função de teste.
 871 Se o teste não for fornecido, @var{constituent} é usada como teste padrão.
 872 @code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}} é o conjunto de fnções de teste.
 873 (A verão Lisp de @code{tokens} é escrita por Paul Graham. ANSI Common Lisp, 1996, page 67.)
 874
 875 @c ===beg===
 876 @c load("stringproc")$
 877 @c tokens("24 October 2005");
 878 @c tokens("05-10-24",'digitcharp);
 879 @c map(parsetoken,%);
 880 @c ===end===
 881 @example
 882 (%i1) tokens("24 October 2005");
 883 (%o1)                  [24, October, 2005]
 884 (%i2) tokens("05-10-24",'digitcharp);
 885 (%o2)                     [05, 10, 24]
 886 (%i3) map(parsetoken,%);
 887 (%o3)                      [5, 10, 24]
 888 @end example
 889
 890 @end deffn
 891