Funções e Variáveis para seqüências de caracteres (Manual do Maxima)

Anterior: Funções e Variáveis para caracteres, Acima: stringproc [Conteúdo][Índice]

### 73.4, Funções e Variáveis para seqüências de caracteres

Função: sunlisp (lisp_string) ¶

  Converte uma seqüência de caracteres do Lisp em uma seqüência de caracteres do Maxima. (Em geral você pode não precisar dessa função.)

Função: lstringp (obj) ¶

  Retorna `true` se obj is uma seqüência de caracteres do Lisp. (Em geral você pode não precisar dessa função.)

Função: stringp (obj) ¶

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

Função: charat (seq_caracte, n) ¶

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

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

Função: charlist (seq_caracte) ¶

  Retorna a lsita de todos os caracteres em seq_caracte.

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

Função: parsetoken (seq_caracte) ¶

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

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

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

  Para analizar você pode também usar a função `parse_string`. Veja a descrição no arquivo ’share\contrib\eval_string.lisp’.

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

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

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

Função: scopy (seq_caracte) ¶

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

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

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

Função: sequal (seq_caracte__1, seq_caracte__2) ¶

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

Função: sequalignore (seq_caracte__1, seq_caracte__2) ¶

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

Função: sexplode (seq_caracte) ¶

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

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

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

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

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

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

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

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

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

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

Função: slength (seq_caracte) ¶

  Retorna número de caracteres em seq_caracte.

Função: smake (num, caractere) ¶

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

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

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

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

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

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

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

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

Função: sposition (caractere, seq_caracte) ¶

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

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

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

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

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

  Como em `sremove` exceto qie a primeira subseqüência de caracteres que coincide com `seq` é removida.

Função: sreverse (seq_caracte) ¶

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

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

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

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

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

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

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

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

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

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

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

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

Função: strim (seq,seq_caracte) ¶

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

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

Função: striml (seq, seq_caracte) ¶

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

Função: strimr (seq, seq_caracte) ¶

  Como em `strim` exceto que somente a extremidade direita de seqüência de caracteres é recortada.

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

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

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

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

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

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

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

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

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

Anterior: Funções e Variáveis para caracteres, Acima: stringproc [Conteúdo][Índice]