doc/info/es/Arrays.es.texi

   1 @c English version 2013-08-03
   2 @page
   3 @node Arrays, Estructuras, Listas, Tipos de datos y estructuras
   4 @section Arrays
   5
   6
   7 @menu
   8 * Introducción a los arrays::
   9 * Funciones y variables para los arrays::
  10 @end menu
  11
  12
  13
  14 @node Introducción a los arrays, Funciones y variables para los arrays, Arrays, Arrays
  15 @subsection Introducción a los arrays
  16
  17 Los arrays más flexibles son aquellos que no necesitan ser declarados, llamados
  18 también, en inglés, @i{hashed-arrays}, y se basan en que a una variable
  19 subindicada se le puede asignar un valor cualquiera. Los índices
  20 no necesitan ser números enteros, admitiéndose símbolos o
  21 expresiones. Los arrays no declarados crecen dinámicamente según se le van
  22 asignando valores a sus elementos. En el siguiente ejemplo se muestra cómo
  23 se va construyendo un array no declarado @code{a}. Para obtener un listado de
  24 los elementos de un array se utiliza la función @code{listarray}.
  25
  26 @example
  27 (%i1) a[1,2]: 99;
  28 (%o1)                          99
  29 (%i2) a[x,y]: x^y;
  30                                 y
  31 (%o2)                          x
  32 (%i3) listarray(a);
  33                                   y
  34 (%o3)                       [99, x ]
  35 @end example
  36
  37 Otro tipo de arrays son los declarados, los cuales admiten hasta cinco dimensiones
  38 y pueden guardar valores de un tipo concreto, como @code{fixnum} para enteros o
  39 @code{flonum} para reales de coma flotante. Maxima distingue dos tipos de arrays
  40 declarados; los primeros se pueden definir declarando un símbolo
  41 como array, haciendo uso de la función @code{array}; los segundos son arrays
  42 de Lisp, en los que un símbolo se declara como tal con la
  43 función @code{make_array}.
  44
  45 En el primer ejemplo se declara el símbolo @code{a} como array,
  46 mientras que en el segundo se declara @code{b} como array de Lisp.
  47
  48 @example
  49 (%i1) array(a, fixnum, 2, 2);
  50 (%o1)                           a
  51 (%i2) b: make_array(fixnum, 2, 2);
  52 (%o2)              @{Array:  #2A((0 0) (0 0))@}
  53 @end example
  54
  55 Cuando a la variable opcional @code{use_fast_arrays} se le asigna el valor
  56 @code{true}, la función @code{array} también generará un array de Lisp.
  57 Tal es lo que sucede en el ejemplo siguiente, en el que el símbolo
  58 @code{c} queda declarado como array de Lisp. Téngase en cuenta que por este
  59 método no se puede asignar el tipo de array, ya que al introducirle el tipo
  60 @code{fixnum} se genera un mensaje de error.
  61
  62 @example
  63 (%i3) use_fast_arrays: true;
  64 (%o3)                         true
  65 (%i4) array(c, 2, 2);
  66 (%o4)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
  67 (%i5) c;
  68 (%o5)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
  69 (%i6) array(c, fixnum, 2, 2);
  70
  71 make_array: dimensions must be integers; found [fixnum + 1, 3, 3]
  72  -- an error. To debug this try: debugmode(true);
  73 @end example
  74
  75 Maxima también dispone de funciones array, que pueden almacenar
  76 valores de funciones, y de funciones subindicadas.
  77
  78 Se puede encontrar más información en las descripciones de las
  79 funciones. Los siguientes símbolos y funciones de Maxima
  80 permiten trabajar con arrays:
  81
  82 @verbatim
  83    array         arrayapply     arrayinfo
  84    arraymake     arrays         fillarray
  85    listarray     make_array     rearray
  86    remarray      subvar         subvarp
  87    use_fast_arrays
  88 @end verbatim
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98 @node Funciones y variables para los arrays, , Introducción a los arrays, Arrays
  99 @subsection Funciones y variables para los arrays
 100
 101 @deffn {Función} array (@var{nombre}, @var{dim_1}, ..., @var{dim_n})
 102 @deffnx {Función} array (@var{nombre}, @var{type}, @var{dim_1}, ..., @var{dim_n})
 103 @deffnx {Función} array ([@var{nombre_1}, ..., @var{nombre_m}], @var{dim_1}, ..., @var{dim_n})
 104
 105 Crea un array de dimensión @math{n}, que debe ser menor o igual que 5. Los subíndices de la @math{i}-ésima dimensión son enteros que toman valores entre 0 y @var{dim_i}.
 106
 107 La llamada @code{array (@var{nombre}, @var{dim_1}, ..., @var{dim_n})} crea un array de tipo general.
 108
 109 La llamada @code{array (@var{nombre}, @var{type}, @var{dim_1}, ..., @var{dim_n})} crea un array con sus elementos del tipo especificado. El tipo @var{type} puede ser @code{fixnum} para enteros de tamaño limitado o @code{flonum} para números decimales en coma flotante.
 110
 111 La llamada @code{array ([@var{nombre_1}, ..., @var{nombre_m}], @var{dim_1}, ..., @var{dim_n})}
 112 crea @math{m} arrays,  todos ellos de igual dimensión.
 113 @c SAME TYPE AS WELL ??
 114
 115 @c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
 116 Si el usuario asigna un valor a una variable subindicada antes de declarar el array correspondiente, entonces se construye un array no declarado. Los arrays no declarados, también conocidos por el nombre de "arrays de claves" (hashed arrays), son más generales que los arrays declarados. El usuario no necesita declarar su tamaño máximo y pueden ir creciendo de forma dinámica. Los subíndices de los arrays no declarados no necesitan ser necesariamente números. Sin embargo, a menos que un array tenga sus elementos dispersos, probablemente sea más eficiente declararlo siempre que sea posible antes que dejarlo como no declarado. La función @code{array} puede utilizarse para transformar un array no declarado a a uno declarado.
 117 @c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??
 118
 119 @end deffn
 120
 121 @deffn {Función} arrayapply (@var{A}, [@var{i_1}, ..., @var{i_n}])
 122 Evalúa @code{@var{A} [@var{i_1}, ..., @var{i_n}]}, donde @var{A} es un array y @var{i_1}, ..., @var{i_n} son enteros.
 123
 124 Esto es como @code{apply}, excepto por el hecho de que el primer argumento es un array en lugar de una función.
 125
 126 @end deffn
 127
 128 @deffn {Función} arrayinfo (@var{A})
 129 Devuelve información sobre el array@var{A}.
 130 El argumento @var{A} puede ser un array declarado o no declarado,
 131 una función array o una función subindicada.
 132
 133 En el caso de arrays declarados, @code{arrayinfo} devuelve una
 134 lista que contiene el átomo @code{declared}, el número de
 135 dimensiones y el tamaño de cada dimensión.
 136 Los elementos del array, tanto los que tienen valores
 137 asignados como los que no, son devueltos por @code{listarray}.
 138
 139 En el caso de arrays no declarados (@i{hashed arrays}), @code{arrayinfo}
 140 devuelve una lista que contiene el átomo @code{hashed}, el número
 141 de subíndices y los subíndices de aquellos
 142 elementos que guarden un valor. Los valores son devueltos por @code{listarray}.
 143
 144 En el caso de funciones array, @code{arrayinfo} devuelve una lista que
 145 contiene el átomo @code{hashed}, el número de subíndices
 146 y los subíndices para los que la función tiene valores almacenados.
 147 Los valores almacenados de la función array son devueltos por @code{listarray}.
 148
 149 En el caso de funciones subindicadas, @code{arrayinfo} devuelve una lista que
 150 contiene el átomo @code{hashed}, el número de subíndices y
 151 los subíndices para los que hay expresiones lambda.
 152 Las expresiones lambda son devueltas por @code{listarray}.
 153
 154 Ejemplos:
 155
 156 @code{arrayinfo} y @code{listarray} aplicadas a una array declarado.
 157
 158 @c ===beg===
 159 @c array (aa, 2, 3);
 160 @c aa [2, 3] : %pi;
 161 @c aa [1, 2] : %e;
 162 @c arrayinfo (aa);
 163 @c listarray (aa);
 164 @c ===end===
 165 @example
 166 (%i1) array (aa, 2, 3);
 167 (%o1)                          aa
 168 (%i2) aa [2, 3] : %pi;
 169 (%o2)                          %pi
 170 (%i3) aa [1, 2] : %e;
 171 (%o3)                          %e
 172 (%i4) arrayinfo (aa);
 173 (%o4)                 [declared, 2, [2, 3]]
 174 (%i5) listarray (aa);
 175 (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
 176                                         #####, #####, #####, %pi]
 177 @end example
 178
 179 @code{arrayinfo} y @code{listarray} aplicadas a una array no declarado (@i{hashed arrays}).
 180
 181 @c ===beg===
 182 @c bb [FOO] : (a + b)^2;
 183 @c bb [BAR] : (c - d)^3;
 184 @c arrayinfo (bb);
 185 @c listarray (bb);
 186 @c ===end===
 187 @example
 188 (%i1) bb [FOO] : (a + b)^2;
 189                                    2
 190 (%o1)                       (b + a)
 191 (%i2) bb [BAR] : (c - d)^3;
 192                                    3
 193 (%o2)                       (c - d)
 194 (%i3) arrayinfo (bb);
 195 (%o3)               [hashed, 1, [BAR], [FOO]]
 196 (%i4) listarray (bb);
 197                               3         2
 198 (%o4)                 [(c - d) , (b + a) ]
 199 @end example
 200
 201 @code{arrayinfo} y @code{listarray} aplicadas a una función array.
 202
 203 @c ===beg===
 204 @c cc [x, y] := y / x;
 205 @c cc [u, v];
 206 @c cc [4, z];
 207 @c arrayinfo (cc);
 208 @c listarray (cc);
 209 @c ===end===
 210 @example
 211 (%i1) cc [x, y] := y / x;
 212                                      y
 213 (%o1)                      cc     := -
 214                              x, y    x
 215 (%i2) cc [u, v];
 216                                 v
 217 (%o2)                           -
 218                                 u
 219 (%i3) cc [4, z];
 220                                 z
 221 (%o3)                           -
 222                                 4
 223 (%i4) arrayinfo (cc);
 224 (%o4)              [hashed, 2, [4, z], [u, v]]
 225 (%i5) listarray (cc);
 226                               z  v
 227 (%o5)                        [-, -]
 228                               4  u
 229 @end example
 230
 231 @code{arrayinfo} y @code{listarray} aplicadas a una función subindicada.
 232
 233 @c ===beg===
 234 @c dd [x] (y) := y ^ x;
 235 @c dd [a + b];
 236 @c dd [v - u];
 237 @c arrayinfo (dd);
 238 @c listarray (dd);
 239 @c ===end===
 240 @example
 241 (%i1) dd [x] (y) := y ^ x;
 242                                      x
 243 (%o1)                     dd (y) := y
 244                             x
 245 (%i2) dd [a + b];
 246                                     b + a
 247 (%o2)                  lambda([y], y     )
 248 (%i3) dd [v - u];
 249                                     v - u
 250 (%o3)                  lambda([y], y     )
 251 (%i4) arrayinfo (dd);
 252 (%o4)             [hashed, 1, [b + a], [v - u]]
 253 (%i5) listarray (dd);
 254                          b + a                v - u
 255 (%o5)      [lambda([y], y     ), lambda([y], y     )]
 256 @end example
 257
 258 @end deffn
 259
 260 @deffn {Función} arraymake (@var{name}, [@var{i_1}, ..., @var{i_n}])
 261
 262 El resultado es una referencia a array no evaluada.
 263
 264 Devuelve la expresión @code{@var{name} [@var{i_1}, ..., @var{i_n}]}.
 265
 266 Esta función es similar a @code{funmake}, excepto que el valor retornado es referencia a un array no evaluado, en lugar de una llamada a una función no evaluada.
 267
 268 Ejemplos:
 269 @c ===beg===
 270 @c arraymake (A, [1]);
 271 @c arraymake (A, [k]);
 272 @c arraymake (A, [i, j, 3]);
 273 @c array (A, fixnum, 10);
 274 @c fillarray (A, makelist (i^2, i, 1, 11));
 275 @c arraymake (A, [5]);
 276 @c ''%;
 277 @c L : [a, b, c, d, e];
 278 @c arraymake ('L, [n]);
 279 @c ''%, n = 3;
 280 @c A2 : make_array (fixnum, 10);
 281 @c fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 282 @c arraymake ('A2, [8]);
 283 @c ''%;
 284 @c ===end===
 285
 286 @example
 287 (%i1) arraymake (A, [1]);
 288 (%o1)                          A
 289                                 1
 290 (%i2) arraymake (A, [k]);
 291 (%o2)                          A
 292                                 k
 293 (%i3) arraymake (A, [i, j, 3]);
 294 (%o3)                       A
 295                              i, j, 3
 296 (%i4) array (A, fixnum, 10);
 297 (%o4)                           A
 298 (%i5) fillarray (A, makelist (i^2, i, 1, 11));
 299 (%o5)                           A
 300 (%i6) arraymake (A, [5]);
 301 (%o6)                          A
 302                                 5
 303 (%i7) ''%;
 304 (%o7)                          36
 305 (%i8) L : [a, b, c, d, e];
 306 (%o8)                    [a, b, c, d, e]
 307 (%i9) arraymake ('L, [n]);
 308 (%o9)                          L
 309                                 n
 310 (%i10) ''%, n = 3;
 311 (%o10)                          c
 312 (%i11) A2 : make_array (fixnum, 10);
 313 (%o11)          @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
 314 (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 315 (%o12)          @{Array:  #(1 2 3 4 5 6 7 8 9 10)@}
 316 (%i13) arraymake ('A2, [8]);
 317 (%o13)                         A2
 318                                  8
 319 (%i14) ''%;
 320 (%o14)                          9
 321 @end example
 322
 323 @end deffn
 324
 325 @defvr {Variable del sistema} arrays
 326 Valor por defecto: @code{[]}
 327 La variable @code{arrays} es una lista con todos los arrays que han sido alojados,
 328 lo que comprende a los arrays declarados por @code{array}, a los
 329 no declarados (@i{hashed arrays}) construidos implícitamente
 330 (asignando algo al elemento de un array) y a las funciones array definidas
 331 mediante @code{:=} y @code{define}.
 332 Los arrays definidos mediante @code{make_array} no se incluyen en
 333 este grupo.
 334
 335 Véanse también
 336 @code{array}, @code{arrayapply}, @code{arrayinfo}, @code{arraymake},
 337 @code{fillarray}, @code{listarray} y @code{rearray}.
 338
 339 Ejemplos:
 340
 341 @c ===beg===
 342 @c array (aa, 5, 7);
 343 @c bb [FOO] : (a + b)^2;
 344 @c cc [x] := x/100;
 345 @c dd : make_array ('any, 7);
 346 @c arrays;
 347 @c ===end===
 348 @example
 349 (%i1) array (aa, 5, 7);
 350 (%o1)                          aa
 351 (%i2) bb [FOO] : (a + b)^2;
 352                                    2
 353 (%o2)                       (b + a)
 354 (%i3) cc [x] := x/100;
 355                                    x
 356 (%o3)                      cc  := ---
 357                              x    100
 358 (%i4) dd : make_array ('any, 7);
 359 (%o4)       @{Array:  #(NIL NIL NIL NIL NIL NIL NIL)@}
 360 (%i5) arrays;
 361 (%o5)                     [aa, bb, cc]
 362 @end example
 363
 364 @end defvr
 365
 366
 367 @deffn {Función} arraysetapply (@var{A}, [@var{i_1}, @dots{}, @var{i_n}], @var{x})
 368
 369 Asigna @var{x} a @code{@var{A}[@var{i_1}, ..., @var{i_n}]},
 370 siendo @var{A} un array y @var{i_1}, @dots{}, @var{i_n} enteros.
 371
 372 @code{arraysetapply} evalúa sus argumentos.
 373 @end deffn
 374
 375
 376
 377 @deffn {Función} fillarray (@var{A}, @var{B})
 378 Rellena el array @var{A} con los valores de @var{B}, que puede ser una lista o array.
 379
 380 Si se ha declarado @var{A} de un determinado tipo en el momento de su
 381 creación, sólo podrá contener elementos de ese tipo, produciéndose
 382 un error en caso de intentar asignarle un elemento de tipo distinto.
 383
 384 Si las dimensiones de los arrays @var{A} y @var{B} son diferentes,
 385 @var{A} se rellena según el orden de las filas. Si no hay
 386 suficientes elementos en @var{B} el último elemento se utiliza
 387 para cubrir el resto de @var{A}. Si hay demasiados, los elementos
 388 sobrantes son ignorados.
 389
 390 La función @code{fillarray} devuelve su primer argumento.
 391
 392 Ejemplos:
 393
 394 Creación de un array de 9 elementos y posterior relleno a partir de una lista.
 395 @c ===beg===
 396 @c array (a1, fixnum, 8);
 397 @c listarray (a1);
 398 @c fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
 399 @c listarray (a1);
 400 @c ===end===
 401
 402 @example
 403 (%i1) array (a1, fixnum, 8);
 404 (%o1)                          a1
 405 (%i2) listarray (a1);
 406 (%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
 407 (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
 408 (%o3)                          a1
 409 (%i4) listarray (a1);
 410 (%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]
 411 @end example
 412
 413 Si no hay suficientes elementos para cubrir el array, se repite el
 414 último elemento. Si hay demasiados, los elementos
 415 sobrantes son ignorados.
 416 @c ===beg===
 417 @c a2 : make_array (fixnum, 8);
 418 @c fillarray (a2, [1, 2, 3, 4, 5]);
 419 @c fillarray (a2, [4]);
 420 @c fillarray (a2, makelist (i, i, 1, 100));
 421 @c ===end===
 422
 423 @example
 424 (%i1) a2 : make_array (fixnum, 8);
 425 (%o1)             @{Array:  #(0 0 0 0 0 0 0 0)@}
 426 (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
 427 (%o2)             @{Array:  #(1 2 3 4 5 5 5 5)@}
 428 (%i3) fillarray (a2, [4]);
 429 (%o3)             @{Array:  #(4 4 4 4 4 4 4 4)@}
 430 (%i4) fillarray (a2, makelist (i, i, 1, 100));
 431 (%o4)             @{Array:  #(1 2 3 4 5 6 7 8)@}
 432 @end example
 433
 434 Arrays multidimensionales se rellenan según el orden de las filas.
 435 @c ===beg===
 436 @c a3 : make_array (fixnum, 2, 5);
 437 @c fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 438 @c a4 : make_array (fixnum, 5, 2);
 439 @c fillarray (a4, a3);
 440 @c ===end===
 441
 442 @example
 443 (%i1) a3 : make_array (fixnum, 2, 5);
 444 (%o1)        @{Array:  #2A((0 0 0 0 0) (0 0 0 0 0))@}
 445 (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 446 (%o2)        @{Array:  #2A((1 2 3 4 5) (6 7 8 9 10))@}
 447 (%i3) a4 : make_array (fixnum, 5, 2);
 448 (%o3)     @{Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))@}
 449 (%i4) fillarray (a4, a3);
 450 (%o4)     @{Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))@}
 451 @end example
 452
 453 @end deffn
 454
 455
 456 @deffn {Función} listarray (@var{A})
 457 Devuelve una lista con los elementos del array @var{A}.
 458 El argumento @var{A} puede ser un array declarado o no declarado,
 459 una función array o una función subindicada.
 460
 461 Los elementos se ordenan en primera instancia respecto del primer
 462 índice, después respecto del segundo índice
 463 y así sucesivamente.
 464 La ordenación de los índices es la misma que la
 465 establecida por @code{orderless}.
 466
 467 En el caso de arrays no declarados, funciones array y funciones
 468 subindicadas, los elementos corresponden a los índices
 469 devueltos por @code{arrayinfo}.
 470
 471 Los elementos de los arrays declarados que no tienen valores asignados
 472 (excepto @code{fixnum} y @code{flonum}) se devuelven como @code{#####}.
 473 Los elementos sin valores asignados de los arrays @code{fixnum} y @code{flonum}
 474 son devueltos como 0 y 0.0, respectivamente.
 475 Los elementos sin valor asignado de los arrays no declarados,
 476 funciones array y funciones subindicadas no son devueltos.
 477
 478 Ejemplos:
 479
 480 @code{listarray} y @code{arrayinfo} aplicadas a un array declarado.
 481
 482 @c ===beg===
 483 @c array (aa, 2, 3);
 484 @c aa [2, 3] : %pi;
 485 @c aa [1, 2] : %e;
 486 @c listarray (aa);
 487 @c arrayinfo (aa);
 488 @c ===end===
 489 @example
 490 (%i1) array (aa, 2, 3);
 491 (%o1)                          aa
 492 (%i2) aa [2, 3] : %pi;
 493 (%o2)                          %pi
 494 (%i3) aa [1, 2] : %e;
 495 (%o3)                          %e
 496 (%i4) listarray (aa);
 497 (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
 498                                         #####, #####, #####, %pi]
 499 (%i5) arrayinfo (aa);
 500 (%o5)                 [declared, 2, [2, 3]]
 501 @end example
 502
 503 @code{listarray} y @code{arrayinfo} aplicadas a un array no declarado (@i{hashed array}).
 504
 505 @c ===beg===
 506 @c bb [FOO] : (a + b)^2;
 507 @c bb [BAR] : (c - d)^3;
 508 @c listarray (bb);
 509 @c arrayinfo (bb);
 510 @c ===end===
 511 @example
 512 (%i1) bb [FOO] : (a + b)^2;
 513                                    2
 514 (%o1)                       (b + a)
 515 (%i2) bb [BAR] : (c - d)^3;
 516                                    3
 517 (%o2)                       (c - d)
 518 (%i3) listarray (bb);
 519                               3         2
 520 (%o3)                 [(c - d) , (b + a) ]
 521 (%i4) arrayinfo (bb);
 522 (%o4)               [hashed, 1, [BAR], [FOO]]
 523 @end example
 524
 525 @code{listarray} y @code{arrayinfo} aplicadas a una función array.
 526
 527 @c ===beg===
 528 @c cc [x, y] := y / x;
 529 @c cc [u, v];
 530 @c cc [4, z];
 531 @c listarray (cc);
 532 @c arrayinfo (cc);
 533 @c ===end===
 534 @example
 535 (%i1) cc [x, y] := y / x;
 536                                      y
 537 (%o1)                      cc     := -
 538                              x, y    x
 539 (%i2) cc [u, v];
 540                                 v
 541 (%o2)                           -
 542                                 u
 543 (%i3) cc [4, z];
 544                                 z
 545 (%o3)                           -
 546                                 4
 547 (%i4) listarray (cc);
 548                               z  v
 549 (%o4)                        [-, -]
 550                               4  u
 551 (%i5) arrayinfo (cc);
 552 (%o5)              [hashed, 2, [4, z], [u, v]]
 553 @end example
 554
 555 @code{listarray} y @code{arrayinfo} aplicadas a una función subindicada.
 556
 557 @c ===beg===
 558 @c dd [x] (y) := y ^ x;
 559 @c dd [a + b];
 560 @c dd [v - u];
 561 @c listarray (dd);
 562 @c arrayinfo (dd);
 563 @c ===end===
 564 @example
 565 (%i1) dd [x] (y) := y ^ x;
 566                                      x
 567 (%o1)                     dd (y) := y
 568                             x
 569 (%i2) dd [a + b];
 570                                     b + a
 571 (%o2)                  lambda([y], y     )
 572 (%i3) dd [v - u];
 573                                     v - u
 574 (%o3)                  lambda([y], y     )
 575 (%i4) listarray (dd);
 576                          b + a                v - u
 577 (%o4)      [lambda([y], y     ), lambda([y], y     )]
 578 (%i5) arrayinfo (dd);
 579 (%o5)             [hashed, 1, [b + a], [v - u]]
 580 @end example
 581
 582 @end deffn
 583
 584 @deffn {Función} make_array (@var{tipo}, @var{dim_1}, ..., @var{dim_n})
 585
 586 Construye y devuelve un array de Lisp. El argumento @var{tipo} puede ser
 587 @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} o @code{functional}.
 588 Hay @math{n} índices, y el índice @math{i}-ésimo
 589 va de  0 a @math{@var{dim_i} - 1}.
 590
 591 La ventaja de @code{make_array} sobre @code{array} estriba en que el valor
 592 retornado no tiene nombre, y una vez que un puntero deja de referenciarlo,
 593 el valor desaparece. Por ejemplo, si @code{y: make_array (...)} entonces
 594 @code{y} apunta a un objeto que ocupa cierto espacio en la memoria, pero
 595 después de @code{y: false}, @code{y} ya no apunta al objeto, por lo
 596 que éste puede ser considerado basura y posteriormente eliminado.
 597
 598 Ejemplos:
 599 @c ===beg===
 600 @c A1 : make_array (fixnum, 10);
 601 @c A1 [8] : 1729;
 602 @c A1;
 603 @c A2 : make_array (flonum, 10);
 604 @c A2 [2] : 2.718281828;
 605 @c A2;
 606 @c A3 : make_array (any, 10);
 607 @c A3 [4] : x - y - z;
 608 @c A3;
 609 @c A4 : make_array (fixnum, 2, 3, 5);
 610 @c fillarray (A4, makelist (i, i, 1, 2*3*5));
 611 @c A4 [0, 2, 1];
 612 @c ===end===
 613
 614 @example
 615 (%i1) A1 : make_array (fixnum, 10);
 616 (%o1)           @{Array:  #(0 0 0 0 0 0 0 0 0 0)@}
 617 (%i2) A1 [8] : 1729;
 618 (%o2)                         1729
 619 (%i3) A1;
 620 (%o3)          @{Array:  #(0 0 0 0 0 0 0 0 1729 0)@}
 621 (%i4) A2 : make_array (flonum, 10);
 622 (%o4) @{Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 623 (%i5) A2 [2] : 2.718281828;
 624 (%o5)                      2.718281828
 625 (%i6) A2;
 626 (%o6)
 627      @{Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
 628 (%i7) A3 : make_array (any, 10);
 629 (%o7) @{Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
 630 (%i8) A3 [4] : x - y - z;
 631 (%o8)                      - z - y + x
 632 (%i9) A3;
 633 (%o9) @{Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
 634  -1 $Y) ((MTIMES SIMP) -1 $Z))
 635   NIL NIL NIL NIL NIL)@}
 636 (%i10) A4 : make_array (fixnum, 2, 3, 5);
 637 (%o10) @{Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
 638 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))@}
 639 (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
 640 (%o11) @{Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
 641     ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))@}
 642 (%i12) A4 [0, 2, 1];
 643 (%o12)                         12
 644 @end example
 645
 646 @end deffn
 647
 648 @c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
 649 @deffn {Función} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})
 650 Cambia las dimensiones de un array. El nuevo array será rellenado con los elementos del viejo según el orden de las filas. Si el array antiguo era demasiado pequeño, los elementos restantes se rellenan con @code{false}, @code{0.0} o @code{0}, dependiendo del tipo del array. El tipo del array no se puede cambiar.
 651
 652 @end deffn
 653
 654 @deffn {Función} remarray (@var{A_1}, ..., @var{A_n})
 655 @deffnx {Función} remarray (all)
 656 Borra los arrays y las funciones relacionadas con ellos, liberando el espacio de memoria ocupado.
 657 Los argumentos pueden ser arrays declarados, arrays no declarados (@i{hashed arrays}),
 658 funciones array y funciones subindicadas.
 659
 660 La llamada @code{remarray (all)} borra todos los elementos de la lista global @code{arrays}.
 661
 662 La función @code{remarray} devuelve la lista de los arrays borrados.
 663
 664 La función @code{remarray} no evalúa sus argumentos.
 665
 666 @end deffn
 667
 668
 669 @deffn {Función} subvar (@var{x}, @var{i})
 670 Evalúa la expresión subindicada @code{@var{x}[@var{i}]}.
 671
 672 La función @code{subvar} evalúa sus argumentos.
 673
 674 La instrucción @code{arraymake (@var{x}, [@var{i}])} construye la expresión @code{@var{x}[@var{i}]},
 675 pero no la evalúa.
 676
 677 Ejemplos:
 678
 679 @c ===beg===
 680 @c x : foo $
 681 @c i : 3 $
 682 @c subvar (x, i);
 683 @c foo : [aa, bb, cc, dd, ee]$
 684 @c subvar (x, i);
 685 @c arraymake (x, [i]);
 686 @c ''%;
 687 @c ===end===
 688 @example
 689 (%i1) x : foo $
 690
 691 (%i2) i : 3 $
 692
 693 (%i3) subvar (x, i);
 694 (%o3)                         foo
 695                                  3
 696 (%i4) foo : [aa, bb, cc, dd, ee]$
 697
 698 (%i5) subvar (x, i);
 699 (%o5)                          cc
 700 (%i6) arraymake (x, [i]);
 701 (%o6)                         foo
 702                                  3
 703 (%i7) ''%;
 704 (%o7)                          cc
 705 @end example
 706
 707 @end deffn
 708
 709
 710
 711 @deffn {Función} subvarp (@var{expr})
 712 Devuelve @code{true} si @var{expr} es una variable subindicada, como @code{a[i]}.
 713
 714 @end deffn
 715
 716
 717
 718 @c THIS IS REALLY CONFUSING
 719 @defvr {Variable opcional} use_fast_arrays
 720 Valor por defecto: @code{false}
 721
 722 Si @code{use_fast_arrays} vale @code{true} entonces tan solo se reconocen dos tipos de arrays.
 723
 724 @c AQUI QUEDAN TRES PARRAFOS SIN TRADUCIR
 725
 726 @end defvr
 727
 728
 729