doc/info/es/stringproc.texi

   1 @c English version: 2013-08-07
   2 @menu
   3 * Introducción al procesamiento de cadenas::
   4 * Funciones y variables para entrada y salida::
   5 * Funciones y variables para caracteres::
   6 * Funciones y variables para cadenas::
   7 @end menu
   8
   9 @node Introducción al procesamiento de cadenas, Funciones y variables para entrada y salida, stringproc, stringproc
  10 @section Introducción al procesamiento de cadenas
  11
  12 El paquete @code{stringproc} amplía las capacidades de
  13 Maxima para manipular cadenas de caracteres, al tiempo que añade algunas
  14 funciones útiles para la lectura y escritura de ficheros.
  15
  16 Para dudas y fallos, por favor contáctese con @code{volkervannek at gmail dot com}.
  17
  18 En Maxima, una cadena de caracteres se construye fácilmente
  19 escribiéndola entre comillas dobles, como en @code{"texto"}.
  20 La función @code{stringp} comprueba si el argumento es una cadena.
  21
  22 @c ===beg===
  23 @c m: "text";
  24 @c stringp(m);
  25 @c ===end===
  26 @example
  27 (%i1) m: "text";
  28 (%o1)                         text
  29 (%i2) stringp(m);
  30 (%o2)                         true
  31 @end example
  32
  33 Los caracteres se representan como cadenas de longitud unidad.
  34 No se tratan como caracteres Lisp. Se pueden chequear con la
  35 función @code{charp} (o con @code{lcharp} para los caracteres Lisp).
  36 La conversión de caracteres Lisp a caracteres Maxima se realiza con
  37 la función @code{cunlisp}.
  38
  39 @c ===beg===
  40 @c c: "e";
  41 @c [charp(c),lcharp(c)];
  42 @c supcase(c);
  43 @c charp(%);
  44 @c ===end===
  45 @example
  46 (%i1) c: "e";
  47 (%o1)                           e
  48 (%i2) [charp(c),lcharp(c)];
  49 (%o2)                     [true, false]
  50 (%i3) supcase(c);
  51 (%o3)                           E
  52 (%i4) charp(%);
  53 (%o4)                         true
  54 @end example
  55
  56 Todos los caracteres devueltos por las funciones de @code{stringproc} son caracteres
  57 de Maxima. Puesto que los caracteres introducidos son cadenas de longitud igual a
  58 la unidad, se pueden utilizar las funciones de cadenas también para los
  59 caracteres, como se ha hecho con @code{supcase} en el anterior ejemplo.
  60
  61 Es importante tener en cuenta que el primer carácter en una cadena de Maxima
  62 ocupa la posición 1. Esto se ha diseñado así para mantener
  63 la compatibilidad con las listas de Maxima. Véanse las definiciones de
  64 @code{charat} y @code{charlist} para ver ejemplos.
  65
  66 Las funciones de cadena se utilizan frecuentemente cuando se trabaja con
  67 ficheros. El siguiente ejemplo muestra algunas de estas funciones en acción.
  68
  69 Ejemplo:
  70
  71 La función @code{openw} envía un flujo de salida hacia
  72 un fichero, entonces @code{printf} permitirá formatera la escritura en
  73 este fichero. Véase @code{printf} para más detalles.
  74
  75 @example
  76 (%i1) s: openw("E:/file.txt");
  77 (%o1)                    #<output stream E:/file.txt>
  78 (%i2) for n:0 thru 10 do printf( s, "~d ", fib(n) );
  79 (%o2)                                done
  80 (%i3) printf( s, "~%~d ~f ~a ~a ~f ~e ~a~%",
  81               42,1.234,sqrt(2),%pi,1.0e-2,1.0e-2,1.0b-2 );
  82 (%o3)                                false
  83 (%i4) close(s);
  84 (%o4)                                true
  85 @end example
  86
  87 Una vez cerrado el flujo, se podrá abrir nuevamente. La función @code{readline}
  88 devuelve el renglón entero como una única cadena. El paquete @code{stringproc}
  89 dispone de muchas funciones para manipular cadenas. La separación de palabras se
  90 puede hacer con @code{split} o @code{tokens}.
  91
  92 @example
  93 (%i5) s: openr("E:/file.txt");
  94 (%o5)                     #<input stream E:/file.txt>
  95 (%i6) readline(s);
  96 (%o6)                     0 1 1 2 3 5 8 13 21 34 55
  97 (%i7) line: readline(s);
  98 (%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
  99 (%i8) list: tokens(line);
 100 (%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
 101 (%i9) map( parsetoken, list );
 102 (%o9)           [42, 1.234, false, false, 0.01, 0.01, false]
 103 @end example
 104
 105 La función @code{parsetoken} sólo analiza sintácticamente números
 106 enteros y decimales. El análisis de símbolos y números
 107 decimales grandes (@i{big floats}) necesita @code{parse_string}, que se
 108 cargar automáticamente desde @code{eval_string.lisp}.
 109
 110 @example
 111 (%i5) s: openr("E:/file.txt");
 112 (%o5)                     #<input stream E:/file.txt>
 113 (%i6) readline(s);
 114 (%o6)                     0 1 1 2 3 5 8 13 21 34 55
 115 (%i7) line: readline(s);
 116 (%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
 117 (%i8) list: tokens(line);
 118 (%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
 119 (%i9) map( parse_string, list );
 120 (%o9)            [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
 121 (%i10) float(%);
 122 (%o10) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01,
 123                                                      0.01, 0.01]
 124 (%i11) readline(s);
 125 (%o11)                               false
 126 (%i12) close(s)$
 127 @end example
 128
 129 La función @code{readline} devuelve @code{false} cuando se alcanza el
 130 final del fichero.
 131
 132
 133 @node Funciones y variables para entrada y salida, Funciones y variables para caracteres, Introducción al procesamiento de cadenas, stringproc
 134 @section Funciones y variables para entrada y salida
 135
 136 Ejemplo:
 137
 138 @c ===beg===
 139 @c s: openw("E:/file.txt");
 140 @c control:
 141 @c  "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2tand an integer: ~20t~d~%"$
 142 @c printf( s,control, 'true,[1,2,3],42 )$
 143 @c close(s);
 144 @c s: openr("E:/file.txt");
 145 @c while stringp( tmp:readline(s) ) do print(tmp)$
 146 @c close(s)$
 147 @c ===end===
 148 @example
 149 (%i1) s: openw("E:/file.txt");
 150 (%o1)                     #<output stream E:/file.txt>
 151 (%i2) control:
 152 "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2t\
 153            and 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 @deffn {Función} close (@var{stream})
 168 Cierra el flujo de datos @var{stream} y devuelve @code{true} si @var{stream} había
 169 sido abierto.
 170
 171 @end deffn
 172
 173 @deffn {Función} flength (@var{stream})
 174 Devuelve el número de elementos en @var{stream},
 175 el cual debe ser un flujo de datos desde o hacia un fichero.
 176 @end deffn
 177
 178 @deffn {Función} fposition (@var{stream})
 179 @deffnx {Función} fposition (@var{stream}, @var{pos})
 180 Devuelve la posición actual en el flujo de datos @var{stream} si no se utiliza @var{pos}.
 181 Si se utiliza @var{pos}, @code{fposition} fija la posición en @var{stream}.
 182 @var{stream} debe ser un flujo de datos desde o hacia un fichero y @var{pos}
 183 debe ser un entero positivo que hace corresponder al primer elemento de
 184 @var{stream} la posición 1.
 185 @end deffn
 186
 187 @deffn {Función} freshline ()
 188 @deffnx {Función} freshline (@var{stream})
 189 Escribe una nueva línea (en el flujo de datos @var{stream})
 190 si la posición actual no corresponde al inicio de la línea.
 191
 192 Véase también @code{newline}.
 193 @end deffn
 194
 195
 196 @deffn {Función} get_output_stream_string (@var{stream})
 197 Devuelve una cadena con todos los caracteres presentes en @var{stream},
 198 que debe ser un flujo de datos de salida abiero.
 199 Los caracteres devueltos son eliminados de @var{stream}.
 200
 201 Para un ejemplo, véase @code{make_string_output_stream} .
 202 @end deffn
 203
 204
 205 @deffn {Función} make_string_input_stream (@var{string})
 206 @deffnx {Función} make_string_input_stream (@var{string}, @var{start})
 207 @deffnx {Función} make_string_input_stream (@var{string}, @var{start}, @var{end})
 208 Devuelve un flujo de entrada que contiene partes de @var{string} junto con
 209 el carácter de final de fichero. Sin argumentos opcionales, el flujo contiene
 210 la cadena entera y se posiciona frente al primer carácter.
 211 Los argumentos @var{start} y @var{end} definen la subcadena contenida en el
 212 flujo. El primer carácter está disponible en la posición 1.
 213
 214 Ejemplo:
 215
 216 @example
 217 (%i1) istream : make_string_input_stream("text", 1, 4);
 218 (%o1)              #<string-input stream from "text">
 219 (%i2) (while (c : readchar(istream)) # false do sprint(c), newline())$
 220 t e x
 221 (%i3) close(istream)$
 222 @end example
 223 @end deffn
 224
 225
 226
 227 @deffn {Función} make_string_output_stream ()
 228 Devuelve un flujo de salida que acepta caracteres. Los caracteres de
 229 este flujo podrán obtenerse con @code{get_output_stream_string}.
 230
 231 Ejemplo:
 232
 233 @example
 234 (%i1) ostream : make_string_output_stream();
 235 (%o1)               #<string-output stream 09622ea0>
 236 (%i2) printf(ostream, "foo")$
 237
 238 (%i3) printf(ostream, "bar")$
 239
 240 (%i4) string : get_output_stream_string(ostream);
 241 (%o4)                            foobar
 242 (%i5) printf(ostream, "baz")$
 243
 244 (%i6) string : get_output_stream_string(ostream);
 245 (%o6)                              baz
 246 (%i7) close(ostream)$
 247 @end example
 248 @end deffn
 249
 250
 251
 252 @deffn {Función} newline ()
 253 @deffnx {Función} newline (@var{stream})
 254 Escribe una nueva línea (en el flujo de datos  @var{stream}).
 255
 256 Véase @code{sprint} para un ejemplo de uso de @code{newline()}.
 257
 258 Nótese que hay algunos casos en los que @code{newline} no trabaja
 259 según lo esperado.
 260
 261 @end deffn
 262
 263 @deffn {Función} opena (@var{file})
 264 Devuelve un flujo de datos al fichero @var{file}.
 265 Si se abre un fichero ya existente, @code{opena} añade elementos al final
 266 del fichero.
 267
 268 @end deffn
 269
 270 @deffn {Función} openr (@var{file})
 271 Devuelve un flujo de datos de entrada al fichero @var{file}.
 272 Si @var{file} no existe, será creado.
 273 @end deffn
 274
 275 @deffn {Función} openw (@var{file})
 276 Devuelve un flujo de datos de salida al fichero @var{file}.
 277 Si @var{file} no existe, será creado.
 278 Si se abre un fichero ya existente, @code{openw} lo modifica
 279 borrando el contenido anterior.
 280 @end deffn
 281
 282 @deffn {Función} printf (@var{dest}, @var{string})
 283 @deffnx {Función} printf (@var{dest}, @var{string}, @var{expr_1}, ..., @var{expr_n})
 284 Genera una cadena de caracteres a partir de la cadena de control @var{string},
 285 teniendo en cuenta que las tildes introducen directivas. El carácter que
 286 va después de la tilde, posiblemente precedido por parámetros y modificadores,
 287 especifica el tipo de formato que se desea. La mayor parte de las directivas usan
 288 uno o más elementos de los argumentos @var{expr_1}, ..., @var{expr_n}
 289 para crear la salida.
 290
 291 Si @var{dest} es un flujo o vale @code{true}, entonces @code{printf} devuelve @code{false}.
 292 En otro caso, @code{printf} devuelve una cadena conteniendo la salida.
 293
 294 @code{printf} da acceso a la función @code{format} de Common Lisp.
 295 El siguiente ejemplo muestra la relación entre estas dos funciones.
 296
 297 @example
 298 (%i1) printf(true, "R~dD~d~%", 2, 2);
 299 R2D2
 300 (%o1)                                false
 301 (%i2) :lisp (format t "R~dD~d~%" 2 2)
 302 R2D2
 303 NIL
 304 @end example
 305
 306 La siguiente descripción es un simple resumen de las posibilidades de @code{printf}.
 307 La función @code{format} de Common Lisp se encuentra descrita en detalle en muchas
 308 referencias, como el manual libre "Common Lisp the Language" de Guy L. Steele; en
 309 particular, el capítulo 22.3.3.
 310
 311 @example
 312    ~%       nueva línea
 313    ~&       línea de refresco
 314    ~t       tabulación
 315    ~$       moneda
 316    ~d       entero en base decimal
 317    ~b       entero en base binaria
 318    ~o       entero en base octal
 319    ~x       entero en base hexadecimal
 320    ~br      entero en base b
 321    ~r       deletrea un entero
 322    ~p       plural
 323    ~f       decimal en coma flotante
 324    ~e       notación científica
 325    ~g       ~f o ~e, dependiendo de la magnitud
 326    ~h       número decimal grande (@i{bigfloat})
 327    ~a       utiliza la función @code{string} de Maxima
 328    ~s       como ~a, pero las cadenas se devuelven entre "comillas dobles"
 329    ~~       ~
 330    ~<       justificación, ~> termina
 331    ~(       conversor mayúscula/minúscula, ~) termina
 332    ~[       selección, ~] termina
 333    ~@{       iteración, ~@} termina
 334 @end example
 335
 336 La directiva @code{~h} para números decimales grandes no pertenece al estándar
 337 de Lisp, por lo que se ilustra más abajo.
 338
 339 La directiva @code{~*} no está soportada.
 340
 341 Ejemplos:
 342
 343 Si @var{dest} es un flujo o vale @code{true}, entonces @code{printf} devuelve @code{false}.
 344 En otro caso, @code{printf} devuelve una cadena conteniendo la salida.
 345
 346 @c ===beg===
 347 @c printf( false, "~a ~a ~4f ~a ~@@r",
 348 @c         "String",sym,bound,sqrt(12),144), bound = 1.234;
 349 @c printf( false,"~@{~a ~@}",["one",2,"THREE"] );
 350 @c printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
 351 @c         mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
 352 @c control: "~:(~r~) bird~p ~[is~;are~] singing."$
 353 @c printf( false,control, n,n,if n=1 then 1 else 2 ), n=2;
 354 @c ===end===
 355 @example
 356 (%i1) printf( false, "~a ~a ~4f ~a ~@@r",
 357               "String",sym,bound,sqrt(12),144), bound = 1.234;
 358 (%o1)                 String sym 1.23 2*sqrt(3) CXLIV
 359 (%i2) printf( false,"~@{~a ~@}",["one",2,"THREE"] );
 360 (%o2)                          one 2 THREE
 361 (%i3) printf(true,"~@{~@{~9,1f ~@}~%~@}",mat ),
 362           mat = args(matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]))$
 363       1.1       2.0       3.3
 364       4.0       5.0       6.0
 365       7.0       8.9       9.0
 366 (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
 367 (%i5) printf( false,control, n,n,if n=1 then 1 else 2 ), n=2;
 368 (%o5)                    Two birds are singing.
 369 @end example
 370
 371 La directiva @code{~h} se ha introducido para formatear decimales grandes.
 372
 373 @example
 374 ~w,d,e,x,o,p@@H
 375  w : width
 376  d : decimal digits behind floating point
 377  e : minimal exponent digits
 378  x : preferred exponent
 379  o : overflow character
 380  p : padding character
 381  @@ : display sign for positive numbers
 382 @end example
 383
 384 @example
 385 (%i1) fpprec : 1000$
 386 (%i2) printf(true, "|~h|~%", 2.b0^-64)$
 387 |0.0000000000000000000542101086242752217003726400434970855712890625|
 388 (%i3) fpprec : 26$
 389 (%i4) printf(true, "|~h|~%", sqrt(2))$
 390 |1.4142135623730950488016887|
 391 (%i5) fpprec : 24$
 392 (%i6) printf(true, "|~h|~%", sqrt(2))$
 393 |1.41421356237309504880169|
 394 (%i7) printf(true, "|~28h|~%", sqrt(2))$
 395 |   1.41421356237309504880169|
 396 (%i8) printf(true, "|~28,,,,,'*h|~%", sqrt(2))$
 397 |***1.41421356237309504880169|
 398 (%i9) printf(true, "|~,18h|~%", sqrt(2))$
 399 |1.414213562373095049|
 400 (%i10) printf(true, "|~,,,-3h|~%", sqrt(2))$
 401 |1414.21356237309504880169b-3|
 402 (%i11) printf(true, "|~,,2,-3h|~%", sqrt(2))$
 403 |1414.21356237309504880169b-03|
 404 (%i12) printf(true, "|~20h|~%", sqrt(2))$
 405 |1.41421356237309504880169|
 406 (%i13) printf(true, "|~20,,,,'+h|~%", sqrt(2))$
 407 |++++++++++++++++++++|
 408 @end example
 409 @end deffn
 410
 411
 412
 413 @deffn {Función} readchar (@var{stream})
 414 Elimina y devuelve el primer carácter de @var{stream}.
 415 Si se ha alcanzado el final del fichero, @code{readchar} devuelve @code{false}.
 416
 417 Para un ejemplo, véase @code{make_string_input_stream}.
 418 @end deffn
 419
 420
 421 @deffn {Función} readline (@var{stream})
 422 Devuelve una cadena con los caracteres desde la posición actual en el flujo
 423 de datos @var{stream} hasta el final de la línea, o @code{false}
 424 si se ha alcanzado el final del fichero.
 425 @end deffn
 426
 427 @deffn {Función} sprint (@var{expr_1}, ..., @var{expr_n})
 428 Evalúa y muestra sus argumentos uno tras otro en un renglón comenzando por
 429 su extremo izquierdo.
 430
 431 La función @code{newline()}, que se carga automáticamente desde @code{stringproc.lisp},
 432 puede ser de utilidad si se quiere intercalar un salto de línea.
 433
 434 @c ===beg===
 435 @c for n:0 thru 19 do sprint( fib(n) )$
 436 @c for n:0 thru 22 do (
 437 @c    sprint(fib(n)), if mod(n,10)=9 then newline() )$
 438 @c ===end===
 439 @example
 440 (%i1) for n:0 thru 19 do sprint( fib(n) )$
 441 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
 442 (%i2) for n:0 thru 22 do (
 443          sprint(fib(n)), if mod(n,10)=9 then newline() )$
 444 0 1 1 2 3 5 8 13 21 34
 445 55 89 144 233 377 610 987 1597 2584 4181
 446 6765 10946 17711
 447 @end example
 448
 449 @end deffn
 450
 451 @node Funciones y variables para caracteres, Funciones y variables para cadenas, Funciones y variables para entrada y salida, stringproc
 452 @section Funciones y variables para caracteres
 453
 454 @deffn {Función} alphacharp (@var{char})
 455 Devuelve @code{true} si @var{char} es una carácter alfabético.
 456 @end deffn
 457
 458 @deffn {Función} alphanumericp (@var{char})
 459 Devuelve @code{true} si @var{char} es una carácter alfabético o
 460 un dígito.
 461 @end deffn
 462
 463 @deffn {Función} ascii (@var{int})
 464 Devuelve el carácter correspondiente al número ASCII @var{int},
 465 debiendo ser @math{-1 < int < 256}.
 466
 467 @c ===beg===
 468 @c for n from 0 thru 255 do (
 469 @c   tmp: ascii(n),
 470 @c   if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
 471 @c ===end===
 472 @example
 473 (%i1) for n from 0 thru 255 do (
 474   tmp: ascii(n),
 475   if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
 476 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
 477 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
 478 @end example
 479
 480 @end deffn
 481
 482 @deffn {Función} cequal (@var{char_1}, @var{char_2})
 483 Devuelve @code{true} si @var{char_1} y @var{char_2} son el mismo carácter.
 484 @end deffn
 485
 486 @deffn {Función} cequalignore (@var{char_1}, @var{char_2})
 487 Como @code{cequal}, pero ignora si las letras están en mayúsculas o
 488 minúsculas.
 489 @end deffn
 490
 491 @deffn {Función} cgreaterp (@var{char_1}, @var{char_2})
 492 Devuelve  @code{true} si el número ASCII de @var{char_1} es mayor que el
 493 de @var{char_2}.
 494 @end deffn
 495
 496 @deffn {Función} cgreaterpignore (@var{char_1}, @var{char_2})
 497 Como @code{cgreaterp}, pero ignora si las letras están en mayúsculas o
 498 minúsculas.
 499 @end deffn
 500
 501 @deffn {Función} charp (@var{obj})
 502 Devuelve @code{true} si @var{obj} es un carácter de Maxima.
 503 @end deffn
 504
 505 @deffn {Función} cint (@var{char})
 506 Devuelve el número ASCII de @var{char}.
 507 @end deffn
 508
 509 @deffn {Función} clessp (@var{char_1}, @var{char_2})
 510 Devuelve  @code{true} si el número ASCII de @var{char_1} es menor que el
 511 de @var{char_2}.
 512 @end deffn
 513
 514 @deffn {Función} clesspignore (@var{char_1}, @var{char_2})
 515 Como @code{clessp}, pero ignora si las letras están en mayúsculas o
 516 minúsculas.
 517 @end deffn
 518
 519 @deffn {Función} constituent (@var{char})
 520 Devuelve @code{true} si @var{char} es un carácter gráfico y no el
 521 carácter espacio. Un carácter gráfico es el que se puede ver y con un
 522 espacio añadido; @code{constituent} está definido por Paul Graham,
 523 ANSI Common Lisp, 1996, page 67.
 524
 525 @c ===beg===
 526 @c for n from 0 thru 255 do (
 527 @c    tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
 528 @c ===end===
 529 @example
 530 (%i1) for n from 0 thru 255 do (
 531 tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
 532 ! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @@ A B
 533 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
 534 d e f g h i j k l m n o p q r s t u v w x y z @{ | @} ~
 535 @end example
 536
 537 @end deffn
 538
 539 @deffn {Función} cunlisp (@var{lisp_char})
 540 Convierte un carácter Lisp en uno de Maxima. El uso de esta función por
 541 parte del usuario no será necesario.
 542 @end deffn
 543
 544 @deffn {Función} digitcharp (@var{char})
 545 Devuelve @code{true} si @var{char} es un dígito.
 546 @end deffn
 547
 548 @deffn {Función} lcharp (@var{obj})
 549 Devuelve @code{true} si @var{obj} es un carácter de Lisp.
 550 El uso de esta función por parte del usuario no será necesario.
 551 @end deffn
 552
 553 @deffn {Función} lowercasep (@var{char})
 554 Devuelve  @code{true} si @var{char} es un carácter en minúscula.
 555 @end deffn
 556
 557 @defvr {Variable} newline
 558 El carácter de nueva línea.
 559 @end defvr
 560
 561 @defvr {Variable} space
 562 El carácter de espacio.
 563 @end defvr
 564
 565 @defvr {Variable} tab
 566 El carácter de tabulación.
 567 @end defvr
 568
 569 @deffn {Función} uppercasep (@var{char})
 570 Devuelve @code{true} si @var{char} es un carácter en mayúscula.
 571 @end deffn
 572
 573 @node Funciones y variables para cadenas,  , Funciones y variables para caracteres, stringproc
 574 @section Funciones y variables para cadenas
 575
 576
 577
 578 @deffn {Función} base64 (@var{string})
 579 Devuelve la representación en base 64 de @var{string} en formato de
 580 cadena de caracteres.
 581
 582 Ejemplo:
 583
 584 @example
 585 (%i1) base64 : base64("foo bar baz");
 586 (%o1)                       Zm9vIGJhciBiYXo=
 587 (%i2) string : base64_decode(base64);
 588 (%o2)                          foo bar baz
 589 @end example
 590 @end deffn
 591
 592
 593 @deffn {Función} base64_decode (@var{base64-string})
 594 Decodifica la cadena de caracteres @var{base64-string}, codificada
 595 en base 64, y devuelve la cadena original.
 596
 597 Para un ejemplo, véase @code{base64}.
 598 @end deffn
 599
 600
 601 @deffn {Función} charat (@var{string}, @var{n})
 602 Devuelve el @var{n}-ésimo carácter de @var{string}.
 603 Al primer carácter de @var{string} le corresponde @var{n} = 1.
 604
 605 @c ===beg===
 606 @c charat("Lisp",1);
 607 @c ===end===
 608 @example
 609 (%i1) charat("Lisp",1);
 610 (%o1)                           L
 611 @end example
 612
 613 @end deffn
 614
 615 @deffn {Función} charlist (@var{string})
 616 Devuelve una lista con todos los caracteres de @var{string}.
 617
 618 @c ===beg===
 619 @c charlist("Lisp");
 620 @c %[1];
 621 @c ===end===
 622 @example
 623 (%i1) charlist("Lisp");
 624 (%o1)                     [L, i, s, p]
 625 (%i2) %[1];
 626 (%o2)                           L
 627 @end example
 628
 629 @end deffn
 630
 631 @deffn {Función} eval_string (@var{str})
 632 Analiza sintácticamente la cadena @var{str} como una expresión de Maxima
 633 y la evalúa. La cadena @var{str} puede terminar o no con cualquiera de los
 634 símbolos de final de sentencia (dólar @code{$} o punto y coma @code{;}).
 635 Sólo se analiza la primera expresión si hay más de una.
 636
 637 Se emitirá un mensaje de error si @var{str} no es una cadena.
 638
 639 Ejemplos:
 640
 641 @c ===beg===
 642 @c eval_string ("foo: 42; bar: foo^2 + baz");
 643 @c eval_string ("(foo: 42, bar: foo^2 + baz)");
 644 @c ===end===
 645 @example
 646 (%i1) eval_string ("foo: 42; bar: foo^2 + baz");
 647 (%o1)                       42
 648 (%i2) eval_string ("(foo: 42, bar: foo^2 + baz)");
 649 (%o2)                   baz + 1764
 650 @end example
 651
 652 Véase también @code{parse_string}.
 653 @end deffn
 654
 655
 656
 657
 658
 659 @deffn {Función} md5sum (@var{string})
 660 Devuelve, en formato de cadena de caracteres, el resultado de la suma de verificación
 661 md5 del argumento @var{string}. Para obtener el valor devuelto por la función como
 662 número entero, fijar la base numérica de entrada a 16 y a~nadir como prefijo
 663 el cero.
 664
 665 Ejemplo:
 666
 667 @example
 668 (%i1) string : md5sum("foo bar baz");
 669 (%o1)                  ab07acbb1e496801937adfa772424bf7
 670 (%i2) ibase : obase : 16.$
 671
 672 (%i3) integer : parse_string(sconcat(0, string));
 673 (%o3)                 0ab07acbb1e496801937adfa772424bf7
 674 @end example
 675 @end deffn
 676
 677
 678
 679
 680
 681
 682 @deffn {Función} parse_string (@var{str})
 683 Analiza sintácticamente la cadena @var{str} como una expresión de Maxima,
 684 pero no la evalúa. La cadena @var{str} puede terminar o no con cualquiera de los
 685 símbolos de final de sentencia (dólar @code{$} o punto y coma @code{;}).
 686 Sólo se analiza la primera expresión si hay más de una.
 687
 688 Se emitirá un mensaje de error si @var{str} no es una cadena.
 689
 690 Ejemplos:
 691
 692 @c ===beg===
 693 @c parse_string ("foo: 42; bar: foo^2 + baz");
 694 @c parse_string ("(foo: 42, bar: foo^2 + baz)");
 695 @c ===end===
 696 @example
 697 (%i1) parse_string ("foo: 42; bar: foo^2 + baz");
 698 (%o1)                    foo : 42
 699 (%i2) parse_string ("(foo: 42, bar: foo^2 + baz)");
 700                                    2
 701 (%o2)          (foo : 42, bar : foo  + baz)
 702 @end example
 703
 704 Véase también @code{eval_string}.
 705 @end deffn
 706
 707 @deffn {Función} scopy (@var{string})
 708 Devuelve una copia nueva de la cadena @var{string}.
 709 @end deffn
 710
 711 @deffn {Función} sdowncase (@var{string})
 712 @deffnx {Función} sdowncase (@var{string}, @var{start})
 713 @deffnx {Función} sdowncase (@var{string}, @var{start}, @var{end})
 714 Convierte caracteres en minúscula a mayúscula. Véase también @code{supcase}.
 715 @end deffn
 716
 717 @deffn {Función} sequal (@var{string_1}, @var{string_2})
 718 Devuelve @code{true} si @var{string_1} y @var{string_2} son dos cadenas de caracteres iguales.
 719
 720 @end deffn
 721
 722 @deffn {Función} sequalignore (@var{string_1}, @var{string_2})
 723 Igual que @code{sequal} pero no diferencia entre minúsculas y mayúsculas..
 724
 725 @end deffn
 726
 727 @deffn {Función} sexplode (@var{string})
 728 El nombre @code{sexplode} es un seudónimo de la función @code{charlist}.
 729
 730 @end deffn
 731
 732 @deffn {Función} simplode (@var{list})
 733 @deffnx {Función} simplode (@var{list}, @var{delim})
 734 La función @code{simplode} admite como entrada una lista de expresiones para
 735 luego convertirla en una cadena de caracteres. Si no se utiliza la opción @var{delim}
 736 para indicar el delimitador, entonces @code{simplode} no
 737 hace uso de ninguno. El valor de @var{delim} puede ser cualquier cadena.
 738
 739 @c ===beg===
 740 @c simplode(["xx[",3,"]:",expand((x+y)^3)]);
 741 @c simplode( sexplode("stars")," * " );
 742 @c simplode( ["One","more","coffee."]," " );
 743 @c ===end===
 744 @example
 745 (%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
 746 (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
 747 (%i2) simplode( sexplode("stars")," * " );
 748 (%o2)                   s * t * a * r * s
 749 (%i3) simplode( ["One","more","coffee."]," " );
 750 (%o3)                   One more coffee.
 751 @end example
 752
 753 @end deffn
 754
 755 @deffn {Función} sinsert (@var{seq}, @var{string}, @var{pos})
 756 Devuelve la concatenación de las cadenas @code{substring (@var{string}, 1, @var{pos} - 1)},
 757 @var{seq} y @code{substring (@var{string}, @var{pos})}.
 758 Nótese que al primer carácter de @var{string} le corresponde la posición 1.
 759
 760 @c ===beg===
 761 @c s: "A submarine."$
 762 @c concat( substring(s,1,3),"yellow ",substring(s,3) );
 763 @c sinsert("hollow ",s,3);
 764 @c ===end===
 765 @example
 766 (%i1) s: "A submarine."$
 767 (%i2) concat( substring(s,1,3),"yellow ",substring(s,3) );
 768 (%o2)                  A yellow submarine.
 769 (%i3) sinsert("hollow ",s,3);
 770 (%o3)                  A hollow submarine.
 771 @end example
 772
 773 @end deffn
 774
 775 @deffn {Función} sinvertcase (@var{string})
 776 @deffnx {Función} sinvertcase (@var{string}, @var{start})
 777 @deffnx {Función} sinvertcase (@var{string}, @var{start}, @var{end})
 778 Devuelve la misma cadena @var{string} pero con todos sus caracteres desde la
 779 posición @var{start} hasta @var{end} invertidos, esto es, las
 780 mayúsculas se convierten en minúsculas y éstas en mayúsculas.
 781 Si no se incluye el argumento @var{end}, se invierten todos los caracteres
 782 desde @var{start} hasta el final de la cadena.
 783
 784
 785 @c ===beg===
 786 @c sinvertcase("sInvertCase");
 787 @c ===end===
 788 @example
 789 (%i1) sinvertcase("sInvertCase");
 790 (%o1)                      SiNVERTcASE
 791 @end example
 792
 793 @end deffn
 794
 795 @deffn {Función} slength (@var{string})
 796 Devuelve el número de caracteres de @var{string}.
 797
 798 @end deffn
 799
 800 @deffn {Función} smake (@var{num}, @var{char})
 801 Construye una cadena de longitud @var{num} con todos sus
 802 caracteres iguales a @var{char}.
 803
 804 @c ===beg===
 805 @c smake(3,"w");
 806 @c ===end===
 807 @example
 808 (%i1) smake(3,"w");
 809 (%o1)                          www
 810 @end example
 811
 812 @end deffn
 813
 814 @deffn {Función} smismatch (@var{string_1}, @var{string_2})
 815 @deffnx {Función} smismatch (@var{string_1}, @var{string_2}, @var{test})
 816 Devuelve la posición del primer carácter de @var{string_1} distinto del
 817 correpondiente a @var{string_2}. La respuesta será @code{false} si no existe
 818 tal carácter. Por defecto, la función de comparación es @code{sequal}.
 819 Si se quiere ignorar la diferencia entre mayúsculas y minúsculas, hágase uso de
 820 @code{sequalignore} para el argumento @var{test}.
 821
 822 @c ===beg===
 823 @c smismatch("seven","seventh");
 824 @c ===end===
 825 @example
 826 (%i1) smismatch("seven","seventh");
 827 (%o1)                           6
 828 @end example
 829
 830 @end deffn
 831
 832 @deffn {Función} split (@var{string})
 833 @deffnx {Función} split (@var{string}, @var{delim})
 834 @deffnx {Función} split (@var{string}, @var{delim}, @var{multiple})
 835 Devuelve la lista de todos los lexemas (@i{tokens}) de @var{string}.
 836 La función @code{split} utiliza @var{delim} como delimitador, y en caso
 837 de no ser utilizado este argumento, será utilizado el espacio en blanco
 838 como delimitador por defecto. El argumento @var{multiple} es una variable
 839 booleana con valor @code{true} por defecto. Los delimitadores múltiples
 840 se leen como uno solo, lo que resulta de utilidad si las tabulaciones son
 841 almacenadas como secuencias de espacios en blanco. Si a @var{multiple} se
 842 le asigna el valor @code{false}, se consirararán todos los delimitadores.
 843
 844 @c ===beg===
 845 @c split("1.2   2.3   3.4   4.5");
 846 @c split("first;;third;fourth",";",false);
 847 @c ===end===
 848 @example
 849 (%i1) split("1.2   2.3   3.4   4.5");
 850 (%o1)                 [1.2, 2.3, 3.4, 4.5]
 851 (%i2) split("first;;third;fourth",";",false);
 852 (%o2)               [first, , third, fourth]
 853 @end example
 854
 855 @end deffn
 856
 857 @deffn {Función} sposition (@var{char}, @var{string})
 858 Devuelve la posición del primer carácter de @var{string} que
 859 coincide con @var{char}. Al primer carácter de @var{string}
 860 le corresponde la posición 1.
 861 Para cuando se quiera ignorar la diferencia entre mayúsculas y
 862 minúsculas, véase @var{ssearch}.
 863 @end deffn
 864
 865 @deffn {Función} sremove (@var{seq}, @var{string})
 866 @deffnx {Función} sremove (@var{seq}, @var{string}, @var{test})
 867 @deffnx {Función} sremove (@var{seq}, @var{string}, @var{test}, @var{start})
 868 @deffnx {Función} sremove (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
 869 Devuelve la cadena @var{string} pero sin las subcadenas que coinciden con @var{seq}.
 870 La función de comparación por defecto es @code{sequal}.
 871 Si se quiere ignorar la diferencia entre mayúsculas y minúsculas, hágase uso de
 872 @code{sequalignore} para el argumento @var{test}.
 873 Utilícense @var{start} y @var{end} para acotar la búsqueda.
 874 Al primer carácter de @var{string} le corresponde la posición 1.
 875
 876 @c ===beg===
 877 @c sremove("n't","I don't like coffee.");
 878 @c sremove ("DO ",%,'sequalignore);
 879 @c ===end===
 880 @example
 881 (%i1) sremove("n't","I don't like coffee.");
 882 (%o1)                   I do like coffee.
 883 (%i2) sremove ("DO ",%,'sequalignore);
 884 (%o2)                    I like coffee.
 885 @end example
 886
 887 @end deffn
 888
 889 @deffn {Función} sremovefirst (@var{seq}, @var{string})
 890 @deffnx {Función} sremovefirst (@var{seq}, @var{string}, @var{test})
 891 @deffnx {Función} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start})
 892 @deffnx {Función} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
 893 Actúa de forma similar a la función @code{sremove}, pero sólo elimina
 894 la primera aparición de la subcadena @code{seq}.
 895
 896 @end deffn
 897
 898 @deffn {Función} sreverse (@var{string})
 899 Devuelve una cadena con todos los caracteres de @var{string} en orden inverso.
 900
 901 @end deffn
 902
 903 @deffn {Función} ssearch (@var{seq}, @var{string})
 904 @deffnx {Función} ssearch (@var{seq}, @var{string}, @var{test})
 905 @deffnx {Función} ssearch (@var{seq}, @var{string}, @var{test}, @var{start})
 906 @deffnx {Función} ssearch (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
 907 Devuelve la posición de la primera subcadena de @var{string} que coincide con
 908 la cadena @var{seq}.
 909 La función de comparación por defecto es @code{sequal}.
 910 Si se quiere ignorar la diferencia entre mayúsculas y minúsculas, hágase uso de
 911 @code{sequalignore} para el argumento @var{test}.
 912 Utilícense @var{start} y @var{end} para acotar la búsqueda.
 913 Al primer carácter de @var{string} le corresponde la posición 1.
 914
 915 @example
 916 (%i1) ssearch("~s","~@{~S ~@}~%",'sequalignore);
 917 (%o1)                                  4
 918 @end example
 919
 920 @end deffn
 921
 922 @deffn {Función} ssort (@var{string})
 923 @deffnx {Función} ssort (@var{string}, @var{test})
 924 Devuelve una cadena con todos los caracteres de @var{string} en un orden
 925 tal que no haya dos caracteres sucesivos @var{c} y @var{d} que verifiquen
 926 que @code{test (@var{c}, @var{d})} sea igual @code{false} y
 927 @code{test (@var{d}, @var{c})} igual a @code{true}.
 928 La función de comparación @var{test} por defecto es  @var{clessp}, siendo
 929 el conjunto de posibles valores para este argumento
 930 @code{@{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore@}}.
 931
 932 @c ===beg===
 933 @c ssort("I don't like Mondays.");
 934 @c ssort("I don't like Mondays.",'cgreaterpignore);
 935 @c ===end===
 936 @example
 937 (%i1) ssort("I don't like Mondays.");
 938 (%o1)                    '.IMaddeiklnnoosty
 939 (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
 940 (%o2)                 ytsoonnMlkIiedda.'
 941 @end example
 942
 943 @end deffn
 944
 945 @deffn {Función} ssubst (@var{new}, @var{old}, @var{string})
 946 @deffnx {Función} ssubst (@var{new}, @var{old}, @var{string}, @var{test})
 947 @deffnx {Función} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start})
 948 @deffnx {Función} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end})
 949 Devuelve una cadena similar a @var{string} pero en la que aquellas subcadenas
 950 coincidentes con @var{old} han sido sustituidas por @var{new}. Las subcadenas
 951 @var{old} y @var{new} no necesitan ser de la misma longitud.
 952 La función de comparación por defecto es @code{sequal}.
 953 Si se quiere ignorar la diferencia entre mayúsculas y minúsculas durante
 954 la búsqueda de @var{old}, hágase uso de
 955 @code{sequalignore} para el argumento @var{test}.
 956 Utilícense @var{start} y @var{end} para acotar la búsqueda.
 957 Al primer carácter de @var{string} le corresponde la posición 1.
 958
 959 @c ===beg===
 960 @c ssubst("like","hate","I hate Thai food. I hate green tea.");
 961 @c ssubst("Indian","thai",%,'sequalignore,8,12);
 962 @c ===end===
 963 @example
 964 (%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
 965 (%o1)          I like Thai food. I like green tea.
 966 (%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
 967 (%o2)         I like Indian food. I like green tea.
 968 @end example
 969
 970 @end deffn
 971
 972 @deffn {Función} ssubstfirst (@var{new}, @var{old}, @var{string})
 973 @deffnx {Función} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test})
 974 @deffnx {Función} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start})
 975 @deffnx {Función} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end})
 976 Actúa de forma similar a la función @code{subst}, pero sólo hace
 977 la sustitución en la primera coincidencia con @var{old}.
 978 @end deffn
 979
 980 @deffn {Función} strim (@var{seq},@var{string})
 981 Devuelve la cadena @var{string} pero recortando los caracteres
 982 de @var{seq} que tuviese en sus extremos.
 983
 984 @c ===beg===
 985 @c "/* comment */"$
 986 @c strim(" /*",%);
 987 @c slength(%);
 988 @c ===end===
 989 @example
 990 (%i1) "/* comment */"$
 991 (%i2) strim(" /*",%);
 992 (%o2)                        comment
 993 (%i3) slength(%);
 994 (%o3)                           7
 995 @end example
 996
 997 @end deffn
 998
 999 @deffn {Función} striml (@var{seq}, @var{string})
1000 Actúa de forma similar a @code{strim}, pero sólo recorta
1001 en el extremo final de @var{string}.
1002 @end deffn
1003
1004 @deffn {Función} strimr (@var{seq}, @var{string})
1005 Actúa de forma similar a @code{strim}, pero sólo recorta
1006 en el extremo inicial de @var{string}.
1007 @end deffn
1008
1009 @deffn {Función} stringp (@var{obj})
1010 Devuelve @code{true} si @var{obj} es una cadena.
1011 Véase un ejemplo en la introducción.
1012 @end deffn
1013
1014 @deffn {Función} substring (@var{string}, @var{start})
1015 @deffnx {Función} substring (@var{string}, @var{start}, @var{end})
1016 Devuelve la subcadena de @var{string} que comienza en la posición
1017 @var{start} y termina en la posición @var{end}.
1018 El carácter en la posición @var{end} no se incluye.
1019 En caso de no suministrarse el argumento @var{end}, la subcadena
1020 se extenderá hasta el final.
1021 Al primer carácter de @var{string} le corresponde la posición 1.
1022
1023 @c ===beg===
1024 @c substring("substring",4);
1025 @c substring(%,4,6);
1026 @c ===end===
1027 @example
1028 (%i1) substring("substring",4);
1029 (%o1)                        string
1030 (%i2) substring(%,4,6);
1031 (%o2)                          in
1032 @end example
1033
1034
1035 @end deffn
1036
1037 @deffn {Función} supcase (@var{string})
1038 @deffnx {Función} supcase (@var{string}, @var{start})
1039 @deffnx {Función} supcase (@var{string}, @var{start}, @var{end})
1040 Devuelve la cadena @var{string} con todos sus caracteres entre las posiciones
1041 @var{start} y @var{end} en minúscula transformados a mayúscula.
1042 En caso de no suministrarse el argumento @var{end}, los cambios
1043 se extenderán hasta el final.
1044
1045 @c ===beg===
1046 @c supcase("english",1,2);
1047 @c ===end===
1048 @example
1049 (%i1) supcase("english",1,2);
1050 (%o1)                        English
1051 @end example
1052
1053 @end deffn
1054
1055 @deffn {Función} tokens (@var{string})
1056 @deffnx {Función} tokens (@var{string}, @var{test})
1057 Devuelve la lista de todos los lexemas (@i{tokens}) de @var{string}.
1058 Los lexemas son subcadenas cuyos caracteres satisfacen la  condición @var{test}.
1059 Si no se suministra el argumento @var{test}, se utilizará la condición
1060 @var{constituent}, siendo el conjunto de las otras alternativas
1061 @code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}}.
1062
1063 @c ===beg===
1064 @c tokens("24 October 2005");
1065 @c tokens("05-10-24",'digitcharp);
1066 @c map(parse_string,%);
1067 @c ===end===
1068 @example
1069 (%i1) tokens("24 October 2005");
1070 (%o1)                  [24, October, 2005]
1071 (%i2) tokens("05-10-24",'digitcharp);
1072 (%o2)                     [05, 10, 24]
1073 (%i3) map(parse_string,%);
1074 (%o3)                      [5, 10, 24]
1075 @end example
1076
1077 @end deffn
1078