doc/info/pt/stringproc.texi

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