@c english version 1.15
@menu
* Introducci@'on al procesamiento de cadenas::
* Funciones y variables para entrada y salida::
* Funciones y variables para caracteres::
* Funciones y variables para cadenas::
@end menu

@node Introducci@'on al procesamiento de cadenas, Funciones y variables para entrada y salida, stringproc, stringproc
@section Introducci@'on al procesamiento de cadenas

El paquete @code{stringproc} ampl@'{@dotless{i}}a las capacidades de 
Maxima para manipular cadenas de caracteres, al tiempo que a@~nade algunas
funciones @'utiles para la lectura y escritura de ficheros.

Para dudas y fallos, por favor cont@'actese con van.nek at arcor.de .

En Maxima, una cadena de caracteres se construye f@'acilmente 
escribi@'endola entre comillas dobles, como en @code{"texto"}.
La funci@'on @code{stringp} comprueba si el argumento es una cadena.

@c ===beg===
@c m: "text";
@c stringp(m);
@c ===end===
@example
(%i1) m: "text";
(%o1)                         text
(%i2) stringp(m);
(%o2)                         true
@end example

Los caracteres se representan como cadenas de longitud unidad.
No se tratan como caracteres Lisp. Se pueden chequear con la
funci@'on @code{charp} (o con @code{lcharp} para los caracteres Lisp).
La conversi@'on de caracteres Lisp a caracteres Maxima se realiza con
la funci@'on @code{cunlisp}.

@c ===beg===
@c c: "e";
@c [charp(c),lcharp(c)];
@c supcase(c);
@c charp(%);
@c ===end===
@example
(%i1) c: "e";
(%o1)                           e
(%i2) [charp(c),lcharp(c)];
(%o2)                     [true, false]
(%i3) supcase(c);
(%o3)                           E
(%i4) charp(%);
(%o4)                         true
@end example

Todos los caracteres devueltos por las funciones de @code{stringproc} son caracteres
de Maxima. Puesto que los caracteres introducidos son cadenas de longitud igual a
la unidad, se pueden utilizar las funciones de cadenas tambi@'en para los 
caracteres, como se ha hecho con @code{supcase} en el anterior ejemplo.

Es importante tener en cuenta que el primer car@'acter en una cadena de Maxima
ocupa la posici@'on 1. Esto se ha dise@~nado as@'{@dotless{i}} para mantener
la compatibilidad con las listas de Maxima. V@'eanse las definiciones de 
@code{charat} y @code{charlist} para ver ejemplos.

Las funciones de cadena se utilizan frecuentemente cuando se trabaja con
ficheros. El siguiente ejemplo muestra algunas de estas funciones en acci@'on.

Ejemplo: 

La funci@'on @code{openw} env@'{@dotless{i}}a un flujo de salida hacia
un fichero, entonces @code{printf} permitir@'a formatera la escritura en
este fichero. V@'ease @code{printf} para m@'as detalles.

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

Una vez cerrado el flujo, se podr@'a abrir nuevamente. La funci@'on @code{readline}
devuelve el rengl@'on entero como una @'unica cadena. El paquete @code{stringproc}
dispone de muchas funciones para manipular cadenas. La separaci@'on de palabras se
puede hacer con @code{split} o @code{tokens}.

@example
(%i5) s: openr("E:/file.txt");
(%o5)                     #<input stream E:/file.txt>
(%i6) readline(s);
(%o6)                     0 1 1 2 3 5 8 13 21 34 55 
(%i7) line: readline(s);
(%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
(%i8) list: tokens(line);
(%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
(%i9) map( parsetoken, list );
(%o9)           [42, 1.234, false, false, 0.01, 0.01, false]
@end example

La funci@'on @code{parsetoken} s@'olo analiza sint@'acticamente n@'umeros
enteros y decimales. El an@'alisis de s@'{@dotless{i}}mbolos y n@'umeros
decimales grandes (@i{big floats}) necesita @code{parse_string}, que se
cargar autom@'aticamente desde @code{eval_string.lisp}.

@example 
(%i5) s: openr("E:/file.txt");
(%o5)                     #<input stream E:/file.txt>
(%i6) readline(s);
(%o6)                     0 1 1 2 3 5 8 13 21 34 55 
(%i7) line: readline(s);
(%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
(%i8) list: tokens(line);
(%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
(%i9) map( parse_string, list );
(%o9)            [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
(%i10) float(%);
(%o10) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01,
                                                     0.01, 0.01]
(%i11) readline(s);
(%o11)                               false
(%i12) close(s)$
@end example

La funci@'on @code{readline} devuelve @code{false} cuando se alcanza el
final del fichero.


@node Funciones y variables para entrada y salida, Funciones y variables para caracteres, Introducci@'on al procesamiento de cadenas, stringproc
@section Funciones y variables para entrada y salida

Ejemplo: 

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

@deffn {Funci@'on} close (@var{stream}) 
Cierra el flujo de datos @var{stream} y devuelve @code{true} si @var{stream} hab@'{@dotless{i}}a
sido abierto. 

@end deffn

@deffn {Funci@'on} flength (@var{stream})
Devuelve el n@'umero de elementos en el flujo de datos @var{stream}. 

@end deffn

@deffn {Funci@'on} fposition (@var{stream})
@deffnx {Funci@'on} fposition (@var{stream}, @var{pos})
Devuelve la posici@'on actual en el flujo de datos @var{stream} si no se utiliza @var{pos}.
Si se utiliza @var{pos}, @code{fposition} ajusta la posici@'on en @var{stream}. 
El argumento @var{pos} debe ser un n@'umero positivo,
ocupando el primer elemento en @var{stream} la posici@'on 1.

@end deffn

@deffn {Funci@'on} freshline () 
@deffnx {Funci@'on} freshline (@var{stream}) 
Escribe una nueva l@'{@dotless{i}}nea (en el flujo de datos @var{stream})
si la posici@'on actual no corresponde al inicio de la l@'{@dotless{i}}nea.

V@'ease tambi@'en @code{newline}.

@end deffn

@deffn {Funci@'on} newline () 
@deffnx {Funci@'on} newline (@var{stream}) 
Escribe una nueva l@'{@dotless{i}}nea (en el flujo de datos  @var{stream}).

V@'ease @code{sprint} para un ejemplo de uso de @code{newline()}.

N@'otese que hay algunos casos en los que @code{newline} no trabaja
seg@'un lo esperado.

@end deffn

@deffn {Funci@'on} opena (@var{file}) 
Devuelve un flujo de datos al fichero @var{file}.
Si se abre un fichero ya existente, @code{opena} a@~nade elementos al final
del fichero.

@end deffn

@deffn {Funci@'on} openr (@var{file}) 
Devuelve un flujo de datos de entrada al fichero @var{file}.
Si @var{file} no existe, ser@'a creado.
@end deffn

@deffn {Funci@'on} openw (@var{file}) 
Devuelve un flujo de datos de salida al fichero @var{file}.
Si @var{file} no existe, ser@'a creado.
Si se abre un fichero ya existente, @code{openw} lo modifica 
borrando el contenido anterior.
@end deffn

@deffn {Funci@'on} printf (@var{dest}, @var{string})
@deffnx {Funci@'on} printf (@var{dest}, @var{string}, @var{expr_1}, ..., @var{expr_n})
Pone al alcance de Maxima la funci@'on FORMAT de Common Lisp.

V@'eanse las referencias de Lisp para m@'as informaci@'on.

La siguiente descripci@'on y los ejemplos pueden dar una idea de c@'omo usar @code{printf}.

@example
   ~%       nueva l@'{@dotless{i}}nea
   ~&       l@'{@dotless{i}}nea de refresco
   ~t       tabulaci@'on
   ~$       moneda
   ~d       entero en base decimal
   ~b       entero en base binaria
   ~o       entero en base octal
   ~x       entero en base hexadecimal
   ~br      entero en base b
   ~r       deletrea un entero
   ~p       plural
   ~f       decimal en coma flotante
   ~e       notaci@'on cient@'{@dotless{i}}fica
   ~g       ~f o ~e, dependiendo de la magnitud
   ~h       n@'umero decimal grande (@i{bigfloat})
   ~a       utiliza la funci@'on @code{string} de Maxima
   ~s       como ~a, pero las cadenas se devuelven entre "comillas dobles"
   ~~       ~
   ~<       justificaci@'on, ~> termina
   ~(       conversor may@'uscula/min@'uscula, ~) termina 
   ~[       selecci@'on, ~] termina 
   ~@{       iteraci@'on, ~@} termina
@end example

La directiva @code{~[} est@'a indexada a partir del cero.
T@'engase en cuenta que la directiva @code{~*} no est@'a soportada.

@c ===beg===
@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) printf( false, "~a ~a ~4f ~a ~@@r", 
              "String",sym,bound,sqrt(12),144), bound = 1.234;
(%o1)                 String sym 1.23 2*sqrt(3) CXLIV
(%i2) printf( false,"~@{~a ~@}",["one",2,"THREE"] );
(%o2)                          one 2 THREE 
(%i3) printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
              mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
      1.1       2.0       3.3 
      4.0       5.0       6.0 
      7.0       8.9       9.0 
(%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
(%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
(%o5)                    Two birds are singing.
@end example

Si @var{dest} es un flujo de datos o @code{true}, entonces @code{printf}
devuelve @code{false}. En otro caso, @code{printf} devuelve una cadena
con la salida.
@end deffn

@deffn {Funci@'on} readline (@var{stream}) 
Devuelve una cadena con los caracteres desde la posici@'on actual en el flujo
de datos @var{stream} hasta el final de la l@'{@dotless{i}}nea, o @code{false}
si est@'a al final del fichero.
@end deffn

@deffn {Funci@'on} sprint (@var{expr_1}, ..., @var{expr_n})
Eval@'ua y muestra sus argumentos uno tras otro en un rengl@'on comenzando por 
su extremo izquierdo. 

La funci@'on @code{newline()}, que se carga autom@'aticamente desde @code{stringproc.lisp},
puede ser de utilidad si se quiere intercalar un salto de l@'{@dotless{i}}nea.

@c ===beg===
@c for n:0 thru 20 do sprint( fib(n) )$
@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 
(%i2) for n:0 thru 22 do ( 
         sprint(fib(n)), if mod(n,10)=9 then newline() )$
0 1 1 2 3 5 8 13 21 34 
55 89 144 233 377 610 987 1597 2584 4181 
6765 10946 17711 
@end example

@end deffn

@node Funciones y variables para caracteres, Funciones y variables para cadenas, Funciones y variables para entrada y salida, stringproc
@section Funciones y variables para caracteres

@deffn {Funci@'on} alphacharp (@var{char})
Devuelve @code{true} si @var{char} es una car@'acter alfab@'etico.
@end deffn

@deffn {Funci@'on} alphanumericp (@var{char}) 
Devuelve @code{true} si @var{char} es una car@'acter alfab@'etico o
un d@'{@dotless{i}}gito.
@end deffn

@deffn {Funci@'on} ascii (@var{int})
Devuelve el car@'acter correspondiente al n@'umero ASCII @var{int},
debiendo ser @math{-1 < int < 256}.

@c ===beg===
@c for n from 0 thru 255 do ( 
@c   tmp: ascii(n),
@c   if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
@c ===end===
@example
(%i1) for n from 0 thru 255 do ( 
  tmp: ascii(n),
  if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
a b c d e f g h i j k l m n o p q r s t u v w x y z
@end example

@end deffn

@deffn {Funci@'on} cequal (@var{char_1}, @var{char_2})          
Devuelve @code{true} si @var{char_1} y @var{char_2} son el mismo car@'acter. 
@end deffn

@deffn {Funci@'on} cequalignore (@var{char_1}, @var{char_2})
Como @code{cequal}, pero ignora si las letras est@'an en may@'usculas o
min@'usculas.
@end deffn

@deffn {Funci@'on} cgreaterp (@var{char_1}, @var{char_2})    
Devuelve  @code{true} si el n@'umero ASCII de @var{char_1} es mayor que el 
de @var{char_2}. 
@end deffn

@deffn {Funci@'on} cgreaterpignore (@var{char_1}, @var{char_2})
Como @code{cgreaterp}, pero ignora si las letras est@'an en may@'usculas o
min@'usculas.
@end deffn

@deffn {Funci@'on} charp (@var{obj})
Devuelve @code{true} si @var{obj} es un car@'acter de Maxima.
@end deffn

@deffn {Funci@'on} cint (@var{char}) 
Devuelve el n@'umero ASCII de @var{char}.
@end deffn

@deffn {Funci@'on} clessp (@var{char_1}, @var{char_2})
Devuelve  @code{true} si el n@'umero ASCII de @var{char_1} es menor que el 
de @var{char_2}.  
@end deffn

@deffn {Funci@'on} clesspignore (@var{char_1}, @var{char_2})
Como @code{clessp}, pero ignora si las letras est@'an en may@'usculas o
min@'usculas.
@end deffn

@deffn {Funci@'on} constituent (@var{char})
Devuelve @code{true} si @var{char} es un car@'acter gr@'afico y no el
car@'acter espacio. Un car@'acter gr@'afico es el que se puede ver y con un
espacio a@~nadido; @code{constituent} est@'a definido por Paul Graham,
ANSI Common Lisp, 1996, page 67.

@c ===beg===
@c for n from 0 thru 255 do ( 
@c    tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
@c ===end===
@example
(%i1) for n from 0 thru 255 do ( 
tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @@ A B
C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
d e f g h i j k l m n o p q r s t u v w x y z @{ | @} ~
@end example

@end deffn

@deffn {Funci@'on} cunlisp (@var{lisp_char}) 
Convierte un car@'acter Lisp en uno de Maxima. El uso de esta funci@'on por
parte del usuario no ser@'a necesario.
@end deffn

@deffn {Funci@'on} digitcharp (@var{char})    
Devuelve @code{true} si @var{char} es un d@'{@dotless{i}}gito. 
@end deffn

@deffn {Funci@'on} lcharp (@var{obj}) 
Devuelve @code{true} si @var{obj} es un car@'acter de Lisp.
El uso de esta funci@'on por parte del usuario no ser@'a necesario.
@end deffn

@deffn {Funci@'on} lowercasep (@var{char})  
Devuelve  @code{true} si @var{char} es un car@'acter en min@'uscula.
@end deffn

@defvr {Variable} newline 
El car@'acter de nueva l@'{@dotless{i}}nea. 
@end defvr

@defvr {Variable} space   
El car@'acter de espacio.
@end defvr

@defvr {Variable} tab     
El car@'acter de tabulaci@'on.
@end defvr

@deffn {Funci@'on} uppercasep (@var{char})  
Devuelve @code{true} si @var{char} es un car@'acter en may@'uscula.
@end deffn

@node Funciones y variables para cadenas,  , Funciones y variables para caracteres, stringproc
@section Funciones y variables para cadenas

@deffn {Funci@'on} stringp (@var{obj}) 
Devuelve @code{true} si @var{obj} es una cadena.
V@'ease un ejemplo en la introducci@'on.
@end deffn

@deffn {Funci@'on} charat (@var{string}, @var{n})
Devuelve el @var{n}-@'esimo car@'acter de @var{string}.
Al primer car@'acter de @var{string} le corresponde @var{n} = 1.

@c ===beg===
@c charat("Lisp",1);
@c ===end===
@example
(%i1) charat("Lisp",1);
(%o1)                           L
@end example

@end deffn

@deffn {Funci@'on} charlist (@var{string}) 
Devuelve una lista con todos los caracteres de @var{string}. 

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

@end deffn

@deffn {Funci@'on} eval_string (@var{str})
Analiza sint@'acticamente la cadena @var{str} como una expresi@'on de Maxima
y la eval@'ua. La cadena @var{str} puede terminar o no con cualquiera de los 
s@'{@dotless{i}}mbolos de final de sentencia (d@'olar @code{$} o punto y coma @code{;}).
S@'olo se analiza la primera expresi@'on si hay m@'as de una.

Se emitir@'a un mensaje de error si @var{str} no es una cadena.

Ejemplos:

@c ===beg===
@c eval_string ("foo: 42; bar: foo^2 + baz");
@c eval_string ("(foo: 42, bar: foo^2 + baz)");
@c ===end===
@example
(%i1) eval_string ("foo: 42; bar: foo^2 + baz");
(%o1)                       42
(%i2) eval_string ("(foo: 42, bar: foo^2 + baz)");
(%o2)                   baz + 1764
@end example

V@'ease tambi@'en @code{parse_string}.
@end deffn

@deffn {Funci@'on} parse_string (@var{str})
Analiza sint@'acticamente la cadena @var{str} como una expresi@'on de Maxima,
pero no la eval@'ua. La cadena @var{str} puede terminar o no con cualquiera de los 
s@'{@dotless{i}}mbolos de final de sentencia (d@'olar @code{$} o punto y coma @code{;}).
S@'olo se analiza la primera expresi@'on si hay m@'as de una.

Se emitir@'a un mensaje de error si @var{str} no es una cadena.

Ejemplos:

@c ===beg===
@c parse_string ("foo: 42; bar: foo^2 + baz");
@c parse_string ("(foo: 42, bar: foo^2 + baz)");
@c ===end===
@example
(%i1) parse_string ("foo: 42; bar: foo^2 + baz");
(%o1)                    foo : 42
(%i2) parse_string ("(foo: 42, bar: foo^2 + baz)");
                                   2
(%o2)          (foo : 42, bar : foo  + baz)
@end example

V@'ease tambi@'en @code{eval_string}.
@end deffn

@deffn {Funci@'on} scopy (@var{string}) 
Devuelve una copia nueva de la cadena @var{string}. 
@end deffn

@deffn {Funci@'on} sdowncase (@var{string}) 
@deffnx {Funci@'on} sdowncase (@var{string}, @var{start}) 
@deffnx {Funci@'on} sdowncase (@var{string}, @var{start}, @var{end}) 
Convierte caracteres en min@'uscula a may@'uscula. V@'ease tambi@'en @code{supcase}.
@end deffn

@deffn {Funci@'on} sequal (@var{string_1}, @var{string_2}) 
Devuelve @code{true} si @var{string_1} y @var{string_2} son dos cadenas de caracteres iguales. 

@end deffn

@deffn {Funci@'on} sequalignore (@var{string_1}, @var{string_2})
Igual que @code{sequal} pero no diferencia entre min@'usculas y may@'usculas.. 

@end deffn

@deffn {Funci@'on} sexplode (@var{string})
El nombre @code{sexplode} es un seud@'onimo de la funci@'on @code{charlist}.

@end deffn

@deffn {Funci@'on} simplode (@var{list})  
@deffnx {Funci@'on} simplode (@var{list}, @var{delim})  
La funci@'on @code{simplode} admite como entrada una lista de expresiones para
luego convertirla en una cadena de caracteres. Si no se utiliza la opci@'on @var{delim}
para indicar el delimitador, entonces @code{simplode} no 
hace uso de ninguno. El valor de @var{delim} puede ser cualquier cadena.

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

@end deffn

@deffn {Funci@'on} sinsert (@var{seq}, @var{string}, @var{pos}) 
Devuelve la concatenaci@'on de las cadenas @code{substring (@var{string}, 1, @var{pos} - 1)},
@var{seq} y @code{substring (@var{string}, @var{pos})}.
N@'otese que al primer car@'acter de @var{string} le corresponde la posici@'on 1.

@c ===beg===
@c s: "A submarine."$
@c concat( substring(s,1,3),"yellow ",substring(s,3) );
@c sinsert("hollow ",s,3);
@c ===end===
@example
(%i1) s: "A submarine."$
(%i2) concat( substring(s,1,3),"yellow ",substring(s,3) );
(%o2)                  A yellow submarine.
(%i3) sinsert("hollow ",s,3);
(%o3)                  A hollow submarine.
@end example

@end deffn

@deffn {Funci@'on} sinvertcase (@var{string})  
@deffnx {Funci@'on} sinvertcase (@var{string}, @var{start})  
@deffnx {Funci@'on} sinvertcase (@var{string}, @var{start}, @var{end})  
Devuelve la misma cadena @var{string} pero con todos sus caracteres desde la
posici@'on @var{start} hasta @var{end} invertidos, esto es, las
may@'usculas se convierten en min@'usculas y @'estas en may@'usculas.
Si no se incluye el argumento @var{end}, se invierten todos los caracteres 
desde @var{start} hasta el final de la cadena.


@c ===beg===
@c sinvertcase("sInvertCase");
@c ===end===
@example
(%i1) sinvertcase("sInvertCase");
(%o1)                      SiNVERTcASE
@end example

@end deffn

@deffn {Funci@'on} slength (@var{string}) 
Devuelve el n@'umero de caracteres de @var{string}. 

@end deffn

@deffn {Funci@'on} smake (@var{num}, @var{char}) 
Construye una cadena de longitud @var{num} con todos sus
caracteres iguales a @var{char}. 

@c ===beg===
@c smake(3,"w");
@c ===end===
@example
(%i1) smake(3,"w");
(%o1)                          www
@end example

@end deffn

@deffn {Funci@'on} smismatch (@var{string_1}, @var{string_2}) 
@deffnx {Funci@'on} smismatch (@var{string_1}, @var{string_2}, @var{test}) 
Devuelve la posici@'on del primer car@'acter de @var{string_1} distinto del
correpondiente a @var{string_2}. La respuesta ser@'a @code{false} si no existe
tal car@'acter. Por defecto, la funci@'on de comparaci@'on es @code{sequal}.
Si se quiere ignorar la diferencia entre may@'usculas y min@'usculas, h@'agase uso de 
@code{sequalignore} para el argumento @var{test}.

@c ===beg===
@c smismatch("seven","seventh");
@c ===end===
@example
(%i1) smismatch("seven","seventh");
(%o1)                           6
@end example

@end deffn

@deffn {Funci@'on} split (@var{string})  
@deffnx {Funci@'on} split (@var{string}, @var{delim})  
@deffnx {Funci@'on} split (@var{string}, @var{delim}, @var{multiple}) 
Devuelve la lista de todos los lexemas (@i{tokens}) de @var{string}.
La funci@'on @code{split} utiliza @var{delim} como delimitador, y en caso
de no ser utilizado este argumento, ser@'a utilizado el espacio en blanco
como delimitador por defecto. El argumento @var{multiple} es una variable
booleana con valor @code{true} por defecto. Los delimitadores m@'ultiples 
se leen como uno solo, lo que resulta de utilidad si las tabulaciones son 
almacenadas como secuencias de espacios en blanco. Si a @var{multiple} se 
le asigna el valor @code{false}, se consirarar@'an todos los delimitadores.

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

@end deffn

@deffn {Funci@'on} sposition (@var{char}, @var{string}) 
Devuelve la posici@'on del primer car@'acter de @var{string} que
coincide con @var{char}. Al primer car@'acter de @var{string}
le corresponde la posici@'on 1.
Para cuando se quiera ignorar la diferencia entre may@'usculas y 
min@'usculas, v@'ease @var{ssearch}.
@end deffn

@deffn {Funci@'on} sremove (@var{seq}, @var{string})  
@deffnx {Funci@'on} sremove (@var{seq}, @var{string}, @var{test})  
@deffnx {Funci@'on} sremove (@var{seq}, @var{string}, @var{test}, @var{start})  
@deffnx {Funci@'on} sremove (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
Devuelve la cadena @var{string} pero sin las subcadenas que coinciden con @var{seq}.
La funci@'on de comparaci@'on por defecto es @code{sequal}.
Si se quiere ignorar la diferencia entre may@'usculas y min@'usculas, h@'agase uso de 
@code{sequalignore} para el argumento @var{test}.
Util@'{@dotless{i}}cense @var{start} y @var{end} para acotar la b@'usqueda.
Al primer car@'acter de @var{string} le corresponde la posici@'on 1.

@c ===beg===
@c sremove("n't","I don't like coffee.");
@c sremove ("DO ",%,'sequalignore);
@c ===end===
@example
(%i1) sremove("n't","I don't like coffee.");
(%o1)                   I do like coffee.
(%i2) sremove ("DO ",%,'sequalignore);
(%o2)                    I like coffee.
@end example

@end deffn

@deffn {Funci@'on} sremovefirst (@var{seq}, @var{string})  
@deffnx {Funci@'on} sremovefirst (@var{seq}, @var{string}, @var{test})  
@deffnx {Funci@'on} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start})  
@deffnx {Funci@'on} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})  
Act@'ua de forma similar a la funci@'on @code{sremove}, pero s@'olo elimina
la primera aparici@'on de la subcadena @code{seq}.

@end deffn

@deffn {Funci@'on} sreverse (@var{string}) 
Devuelve una cadena con todos los caracteres de @var{string} en orden inverso.

@end deffn

@deffn {Funci@'on} ssearch (@var{seq}, @var{string})  
@deffnx {Funci@'on} ssearch (@var{seq}, @var{string}, @var{test})  
@deffnx {Funci@'on} ssearch (@var{seq}, @var{string}, @var{test}, @var{start})  
@deffnx {Funci@'on} ssearch (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
Devuelve la posici@'on de la primera subcadena de @var{string} que coincide con
la cadena @var{seq}.
La funci@'on de comparaci@'on por defecto es @code{sequal}.
Si se quiere ignorar la diferencia entre may@'usculas y min@'usculas, h@'agase uso de 
@code{sequalignore} para el argumento @var{test}.
Util@'{@dotless{i}}cense @var{start} y @var{end} para acotar la b@'usqueda.
Al primer car@'acter de @var{string} le corresponde la posici@'on 1.

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

@end deffn

@deffn {Funci@'on} ssort (@var{string}) 
@deffnx {Funci@'on} ssort (@var{string}, @var{test}) 
Devuelve una cadena con todos los caracteres de @var{string} en un orden
tal que no haya dos caracteres sucesivos @var{c} y @var{d} que verifiquen
que @code{test (@var{c}, @var{d})} sea igual @code{false} y 
@code{test (@var{d}, @var{c})} igual a @code{true}.
La funci@'on de comparaci@'on @var{test} por defecto es  @var{clessp}, siendo
el conjunto de posibles valores para este argumento 
@code{@{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore@}}.

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

@end deffn

@deffn {Funci@'on} ssubst (@var{new}, @var{old}, @var{string}) 
@deffnx {Funci@'on} ssubst (@var{new}, @var{old}, @var{string}, @var{test}) 
@deffnx {Funci@'on} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}) 
@deffnx {Funci@'on} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end}) 
Devuelve una cadena similar a @var{string} pero en la que aquellas subcadenas 
coincidentes con @var{old} han sido sustituidas por @var{new}. Las subcadenas
@var{old} y @var{new} no necesitan ser de la misma longitud. 
La funci@'on de comparaci@'on por defecto es @code{sequal}.
Si se quiere ignorar la diferencia entre may@'usculas y min@'usculas durante
la b@'usqueda de @var{old}, h@'agase uso de 
@code{sequalignore} para el argumento @var{test}.
Util@'{@dotless{i}}cense @var{start} y @var{end} para acotar la b@'usqueda.
Al primer car@'acter de @var{string} le corresponde la posici@'on 1.

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

@end deffn

@deffn {Funci@'on} ssubstfirst (@var{new}, @var{old}, @var{string}) 
@deffnx {Funci@'on} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}) 
@deffnx {Funci@'on} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}) 
@deffnx {Funci@'on} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end}) 
Act@'ua de forma similar a la funci@'on @code{subst}, pero s@'olo hace
la sustituci@'on en la primera coincidencia con @var{old}. 
@end deffn

@deffn {Funci@'on} strim (@var{seq},@var{string}) 
Devuelve la cadena @var{string} pero recortando los caracteres
de @var{seq} que tuviese en sus extremos.

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

@end deffn

@deffn {Funci@'on} striml (@var{seq}, @var{string}) 
Act@'ua de forma similar a @code{strim}, pero s@'olo recorta
en el extremo final de @var{string}.
@end deffn

@deffn {Funci@'on} strimr (@var{seq}, @var{string}) 
Act@'ua de forma similar a @code{strim}, pero s@'olo recorta
en el extremo inicial de @var{string}.
@end deffn

@deffn {Funci@'on} substring (@var{string}, @var{start})
@deffnx {Funci@'on} substring (@var{string}, @var{start}, @var{end}) 
Devuelve la subcadena de @var{string} que comienza en la posici@'on
@var{start} y termina en la posici@'on @var{end}.
El car@'acter en la posici@'on @var{end} no se incluye.
En caso de no suministrarse el argumento @var{end}, la subcadena
se extender@'a hasta el final. 
Al primer car@'acter de @var{string} le corresponde la posici@'on 1.

@c ===beg===
@c substring("substring",4);
@c substring(%,4,6);
@c ===end===
@example
(%i1) substring("substring",4);
(%o1)                        string
(%i2) substring(%,4,6);
(%o2)                          in
@end example


@end deffn

@deffn {Funci@'on} supcase (@var{string}) 
@deffnx {Funci@'on} supcase (@var{string}, @var{start}) 
@deffnx {Funci@'on} supcase (@var{string}, @var{start}, @var{end}) 
Devuelve la cadena @var{string} con todos sus caracteres entre las posiciones
@var{start} y @var{end} en min@'uscula transformados a may@'uscula.
En caso de no suministrarse el argumento @var{end}, los cambios
se extender@'an hasta el final.

@c ===beg===
@c supcase("english",1,2);
@c ===end===
@example
(%i1) supcase("english",1,2);
(%o1)                        English
@end example

@end deffn

@deffn {Funci@'on} tokens (@var{string}) 
@deffnx {Funci@'on} tokens (@var{string}, @var{test}) 
Devuelve la lista de todos los lexemas (@i{tokens}) de @var{string}.
Los lexemas son subcadenas cuyos caracteres satisfacen la  condici@'on @var{test}.
Si no se suministra el argumento @var{test}, se utilizar@'a la condici@'on
@var{constituent}, siendo el conjunto de las otras alternativas
@code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}}.

@c ===beg===
@c tokens("24 October 2005");
@c tokens("05-10-24",'digitcharp);
@c map(parse_string,%);
@c ===end===
@example
(%i1) tokens("24 October 2005");
(%o1)                  [24, October, 2005]
(%i2) tokens("05-10-24",'digitcharp);
(%o2)                     [05, 10, 24]
(%i3) map(parse_string,%);
(%o3)                      [5, 10, 24]
@end example

@end deffn