| blob | 42c3f42d5795ea1e0639989d739b29347debc376 |
1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
2 @c /Arrays.texi/1.15/Sat Jun 2 00:12:31 2007/-ko/
3 @menu
4 * Funções e Variáveis Definidas para Arrays::
5 @end menu
7 @node Funções e Variáveis Definidas para Arrays, , Arrays, Arrays
8 @section Funções e Variáveis Definidas para Arrays
10 @deffn {Função} array (@var{name}, @var{dim_1}, ..., @var{dim_n})
11 @deffnx {Função} array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})
12 @deffnx {Função} array ([@var{nome_1}, ..., @var{nome_m}], @var{dim_1}, ..., @var{dim_n})
14 Cria um array @math{n}-dimensional.
15 @math{n} pode ser menor ou igual a 5.
16 Os subscritos para
17 a @math{i}'ésima dimensão são inteiros no intervalo de 0 a @var{dim_i}.
19 @code{array (@var{name}, @var{dim_1}, ..., @var{dim_n})} cria um array genérico.
21 @code{array (@var{name}, @var{type}, @var{dim_1}, ..., @var{dim_n})} cria
22 um array, com elementos de um tipo especificado.
23 @var{type} pode ser @code{fixnum} para
24 inteiros de tamanho limitado ou @code{flonum} para números em ponto flutuante.
26 @code{array ([@var{nome_1}, ..., @var{nome_m}], @var{dim_1}, ..., @var{dim_n})}
27 cria @math{m} arrays, todos da mesma dimensão.
28 @c SAME TYPE AS WELL ??
30 @c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
31 Se o usuário atribui a uma variável subscrita antes de declarar o
32 array correspondente, um array não declarado é criado.
33 Arrays não declarados, também conhecidos como array desordenado (porque
34 o codigo desordenado termina nos subscritos), são mais gerais que arrays
35 declarados. O usuário não declara seu tamanho máximo, e ele cresce
36 dinamicamente e desordenadamente à medida que são atribuídos valores a mais elementos. Os
37 subscritos de um array não declarado não precisam sempre ser números. Todavia,
38 exceto para um array um tanto quanto esparso, é provavelmente mais eficiente
39 declarar isso quando possível que deixar não declarado. A função @code{array}
40 pode ser usada para transformar um array não declarado em um array
41 declarado.
42 @c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??
44 @end deffn
46 @deffn {Função} arrayapply (@var{A}, [@var{i_1}, ..., @var{i_n}])
47 Avalia @code{@var{A} [@var{i_1}, ..., @var{i_n}]},
48 quando @var{A} for um array e @var{i_1}, ..., @var{i_n} são inteiros.
50 Ela é remanescente de @code{apply}, exceto o primeiro argumento que é um array ao invés de uma função.
52 @end deffn
54 @deffn {Função} arrayinfo (@var{A})
55 Retorna informações sobre o array @var{A}.
56 O argumento @var{A} pode ser um array declarado, uma array não declarado ( que sofreu um hash),
57 uma função de array, ou uma função que possui subscrito.
59 Para arrays declarados, @code{arrayinfo} retorna uma lista
60 compreendendo o átomo @code{declared}, o n;umero de dimensões, e o tamanho de cada dimensão.
61 Os elementos do array, ambos associados e não associados, são retornados por @code{listarray}.
63 Para arrays não declarados (arrays que sofreram um hash),
64 @code{arrayinfo} retorna uma lista compreendendo o átomo @code{hashed}, o número de subscritos,
65 e os subscritos de de todo elemento que tiver um valor.
66 Os valores são retornados por meio de @code{listarray}.
68 Para funções de array,
69 @code{arrayinfo} retretorna uma lista compreendendo o átomo @code{hashed}, o número de subscritos,
70 e quaisquer valores de subscritos para os quais exista valores funcionais armazenados.
71 Os valores funcionais armazenados são retornados através de @code{listarray}.
73 Para funções que possuem subscritos,
74 @code{arrayinfo} retorna uma lista compreendendo o átomo @code{hashed}, o número de subscritos,
75 e qualquer valores subscritos para os quais existe uma expressões lambda.
76 As expressões lambda são retornadas por @code{listarray}.
78 Examples:
80 @code{arrayinfo} e @code{listarray} aplicado a um array declarado.
82 @c ===beg===
83 @c array (aa, 2, 3);
84 @c aa [2, 3] : %pi;
85 @c aa [1, 2] : %e;
86 @c arrayinfo (aa);
87 @c listarray (aa);
88 @c ===end===
89 @example
90 (%i1) array (aa, 2, 3);
91 (%o1) aa
92 (%i2) aa [2, 3] : %pi;
93 (%o2) %pi
94 (%i3) aa [1, 2] : %e;
95 (%o3) %e
96 (%i4) arrayinfo (aa);
97 (%o4) [declared, 2, [2, 3]]
98 (%i5) listarray (aa);
99 (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
100 #####, #####, #####, %pi]
101 @end example
103 @code{arrayinfo} e @code{listarray} aplicado a um array não declarado (no qual foi aplicado um hash).
105 @c ===beg===
106 @c bb [FOO] : (a + b)^2;
107 @c bb [BAR] : (c - d)^3;
108 @c arrayinfo (bb);
109 @c listarray (bb);
110 @c ===end===
111 @example
112 (%i1) bb [FOO] : (a + b)^2;
113 2
114 (%o1) (b + a)
115 (%i2) bb [BAR] : (c - d)^3;
116 3
117 (%o2) (c - d)
118 (%i3) arrayinfo (bb);
119 (%o3) [hashed, 1, [BAR], [FOO]]
120 (%i4) listarray (bb);
121 3 2
122 (%o4) [(c - d) , (b + a) ]
123 @end example
125 @code{arrayinfo} e @code{listarray} aplicado a uma função de array.
127 @c ===beg===
128 @c cc [x, y] := y / x;
129 @c cc [u, v];
130 @c cc [4, z];
131 @c arrayinfo (cc);
132 @c listarray (cc);
133 @c ===end===
134 @example
135 (%i1) cc [x, y] := y / x;
136 y
137 (%o1) cc := -
138 x, y x
139 (%i2) cc [u, v];
140 v
141 (%o2) -
142 u
143 (%i3) cc [4, z];
144 z
145 (%o3) -
146 4
147 (%i4) arrayinfo (cc);
148 (%o4) [hashed, 2, [4, z], [u, v]]
149 (%i5) listarray (cc);
150 z v
151 (%o5) [-, -]
152 4 u
153 @end example
155 @code{arrayinfo} e @code{listarray} aplicadas a funções com subscritos.
157 @c ===beg===
158 @c dd [x] (y) := y ^ x;
159 @c dd [a + b];
160 @c dd [v - u];
161 @c arrayinfo (dd);
162 @c listarray (dd);
163 @c ===end===
164 @example
165 (%i1) dd [x] (y) := y ^ x;
166 x
167 (%o1) dd (y) := y
168 x
169 (%i2) dd [a + b];
170 b + a
171 (%o2) lambda([y], y )
172 (%i3) dd [v - u];
173 v - u
174 (%o3) lambda([y], y )
175 (%i4) arrayinfo (dd);
176 (%o4) [hashed, 1, [b + a], [v - u]]
177 (%i5) listarray (dd);
178 b + a v - u
179 (%o5) [lambda([y], y ), lambda([y], y )]
180 @end example
181 @end deffn
183 @deffn {Função} arraymake (@var{A}, [@var{i_1}, ..., @var{i_n}])
184 Retorna a expressão @code{@var{A}[@var{i_1}, ..., @var{i_n}]}.
185 O resultado é uma referência a um array não avaliado.
187 @code{arraymake} é remanicência de @code{funmake},
188 exceto o valor retornado é um array de referência não avaliado
189 ao invés de uma chamada de função não avaliada.
191 Exemplos:
192 @c ===beg===
193 @c arraymake (A, [1]);
194 @c arraymake (A, [k]);
195 @c arraymake (A, [i, j, 3]);
196 @c array (A, fixnum, 10);
197 @c fillarray (A, makelist (i^2, i, 1, 11));
198 @c arraymake (A, [5]);
199 @c ''%;
200 @c L : [a, b, c, d, e];
201 @c arraymake ('L, [n]);
202 @c ''%, n = 3;
203 @c A2 : make_array (fixnum, 10);
204 @c fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
205 @c arraymake ('A2, [8]);
206 @c ''%;
207 @c ===end===
209 @example
210 (%i1) arraymake (A, [1]);
211 (%o1) A
212 1
213 (%i2) arraymake (A, [k]);
214 (%o2) A
215 k
216 (%i3) arraymake (A, [i, j, 3]);
217 (%o3) A
218 i, j, 3
219 (%i4) array (A, fixnum, 10);
220 (%o4) A
221 (%i5) fillarray (A, makelist (i^2, i, 1, 11));
222 (%o5) A
223 (%i6) arraymake (A, [5]);
224 (%o6) A
225 5
226 (%i7) ''%;
227 (%o7) 36
228 (%i8) L : [a, b, c, d, e];
229 (%o8) [a, b, c, d, e]
230 (%i9) arraymake ('L, [n]);
231 (%o9) L
232 n
233 (%i10) ''%, n = 3;
234 (%o10) c
235 (%i11) A2 : make_array (fixnum, 10);
236 (%o11) @{Array: #(0 0 0 0 0 0 0 0 0 0)@}
237 (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
238 (%o12) @{Array: #(1 2 3 4 5 6 7 8 9 10)@}
239 (%i13) arraymake ('A2, [8]);
240 (%o13) A2
241 8
242 (%i14) ''%;
243 (%o14) 9
244 @end example
246 @end deffn
248 @defvr {Variável de sistema} arrays
249 Valor padrão: @code{[]}
251 @code{arrays} é uma lista dos arrays que tiverem sido alocados.
252 Essa lista compreende arrays declarados através de @code{array},
253 arrays desordenados (hashed) construídos através de definição implícita (atribuindo alguma coisa a um elemento de array),
254 e funções de array definidas por meio de @code{:=} e @code{define}.
255 Arrays definidos por meio de @code{make_array} não estão incluídos.
257 Veja também
258 @code{array}, @code{arrayapply}, @code{arrayinfo}, @code{arraymake},
259 @code{fillarray}, @code{listarray}, e @code{rearray}.
260 @c IS THIS AN EXHAUSTIVE LIST ??
262 Exemplos:
264 @c ===beg===
265 @c array (aa, 5, 7);
266 @c bb [FOO] : (a + b)^2;
267 @c cc [x] := x/100;
268 @c dd : make_array ('any, 7);
269 @c arrays;
270 @c ===end===
271 @example
272 (%i1) array (aa, 5, 7);
273 (%o1) aa
274 (%i2) bb [FOO] : (a + b)^2;
275 2
276 (%o2) (b + a)
277 (%i3) cc [x] := x/100;
278 x
279 (%o3) cc := ---
280 x 100
281 (%i4) dd : make_array ('any, 7);
282 (%o4) @{Array: #(NIL NIL NIL NIL NIL NIL NIL)@}
283 (%i5) arrays;
284 (%o5) [aa, bb, cc]
285 @end example
287 @end defvr
289 @deffn {Função} bashindices (@var{expr})
290 Transforma a expressão @var{expr} dando a cada
291 somatório e a cada produto um único índice. Isso dá a @code{changevar} grande
292 precisão quando se está trabalhando com somatórios e produtos. A forma do
293 único índice é @code{j@var{number}}. A quantidade @var{number} é determindad por
294 referência a @code{gensumnum}, que pode ser alterada pelo usuário. Por
295 exemplo, @code{gensumnum:0$} reseta isso.
297 @end deffn
299 @deffn {Função} fillarray (@var{A}, @var{B})
300 Preenche o array @var{A} com @var{B}, que é uma lista ou um array.
302 Se um tipo específico for declarado para @var{A} no momento de sua criação,
303 @var{A} somente porde ser preenchido com elementos do tipo especificado;
304 Constitui um erro alguma tentativa feita para copiar um um elemento de um tipo diferente.
306 Se as dimensões dos arrays @var{A} e @var{B} forem
307 diferents, @var{A} é preenchido no ordem de maior fileira. Se não existirem elementos
308 livres em @var{B} o último elemento é usado para preencher todo o
309 resto de @var{A}. Se existirem muitos , esses restantes seram ignorados.
311 @code{fillarray} retorna esse primeiro argumento.
313 Exemplos:
315 Create an array of 9 elements and fill it from a list.
316 @c ===beg===
317 @c array (a1, fixnum, 8);
318 @c listarray (a1);
319 @c fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
320 @c listarray (a1);
321 @c ===end===
323 @example
324 (%i1) array (a1, fixnum, 8);
325 (%o1) a1
326 (%i2) listarray (a1);
327 (%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0]
328 (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
329 (%o3) a1
330 (%i4) listarray (a1);
331 (%o4) [1, 2, 3, 4, 5, 6, 7, 8, 9]
332 @end example
334 Quando existirem poucos elementos para preencher o array,
335 o último elemento é repetido.
336 Quando houverem muitos elementos,
337 os elementos extras são ignorados.
338 @c ===beg===
339 @c a2 : make_array (fixnum, 8);
340 @c fillarray (a2, [1, 2, 3, 4, 5]);
341 @c fillarray (a2, [4]);
342 @c fillarray (a2, makelist (i, i, 1, 100));
343 @c ===end===
345 @example
346 (%i1) a2 : make_array (fixnum, 8);
347 (%o1) @{Array: #(0 0 0 0 0 0 0 0)@}
348 (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
349 (%o2) @{Array: #(1 2 3 4 5 5 5 5)@}
350 (%i3) fillarray (a2, [4]);
351 (%o3) @{Array: #(4 4 4 4 4 4 4 4)@}
352 (%i4) fillarray (a2, makelist (i, i, 1, 100));
353 (%o4) @{Array: #(1 2 3 4 5 6 7 8)@}
354 @end example
356 Arrays multi-dimensionais são preenchidos em ordem de maior fileira.
357 @c ===beg===
358 @c a3 : make_array (fixnum, 2, 5);
359 @c fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
360 @c a4 : make_array (fixnum, 5, 2);
361 @c fillarray (a4, a3);
362 @c ===end===
364 @example
365 (%i1) a3 : make_array (fixnum, 2, 5);
366 (%o1) @{Array: #2A((0 0 0 0 0) (0 0 0 0 0))@}
367 (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
368 (%o2) @{Array: #2A((1 2 3 4 5) (6 7 8 9 10))@}
369 (%i3) a4 : make_array (fixnum, 5, 2);
370 (%o3) @{Array: #2A((0 0) (0 0) (0 0) (0 0) (0 0))@}
371 (%i4) fillarray (a4, a3);
372 (%o4) @{Array: #2A((1 2) (3 4) (5 6) (7 8) (9 10))@}
373 @end example
375 @end deffn
377 @deffn {Função} listarray (@var{A})
378 Retorna uma lista dos elementos do array @var{A}.
379 O argumento @var{A} pode ser um array declarado, um array não declarado (desordenado - hashed),
380 uma função de array, ou uma função com subscritos.
382 Elementos são listados em ordem de linha maior.
383 Isto é, elementos são ordenados conforme o primeiro índice, en seguida conforme o segundo índice, e assim sucessivamente.
384 A sequ@"{u}ência de ordenação por meio dos valores dos índices é a mesma ordem estabelecida por meio de @code{orderless}.
386 Para arrays não declarados , funções de arrays, e funções com subscritos,
387 os elementos correspondem aos valores de índice retornados através de @code{arrayinfo}.
389 Elemetos não associados de arrays genéricos declarados (isto é, não @code{fixnum} e não @code{flonum})
390 são retornados como @code{#####}.
391 Elementos não associados de arrays declarados @code{fixnum} ou @code{flonum}
392 são retornados como 0 ou 0.0, respectivamente.
393 Elementos não associados de arrays não declarados, funções de array,
394 e funções subscritas não são retornados.
396 Exemplos:
398 @code{listarray} e @code{arrayinfo} aplicados a um array declarado.
400 @c ===beg===
401 @c array (aa, 2, 3);
402 @c aa [2, 3] : %pi;
403 @c aa [1, 2] : %e;
404 @c listarray (aa);
405 @c arrayinfo (aa);
406 @c ===end===
407 @example
408 (%i1) array (aa, 2, 3);
409 (%o1) aa
410 (%i2) aa [2, 3] : %pi;
411 (%o2) %pi
412 (%i3) aa [1, 2] : %e;
413 (%o3) %e
414 (%i4) listarray (aa);
415 (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
416 #####, #####, #####, %pi]
417 (%i5) arrayinfo (aa);
418 (%o5) [declared, 2, [2, 3]]
419 @end example
421 @code{listarray} e @code{arrayinfo} aplicadas a arrays não declarados (hashed - desordenados).
423 @c ===beg===
424 @c bb [FOO] : (a + b)^2;
425 @c bb [BAR] : (c - d)^3;
426 @c listarray (bb);
427 @c arrayinfo (bb);
428 @c ===end===
429 @example
430 (%i1) bb [FOO] : (a + b)^2;
431 2
432 (%o1) (b + a)
433 (%i2) bb [BAR] : (c - d)^3;
434 3
435 (%o2) (c - d)
436 (%i3) listarray (bb);
437 3 2
438 (%o3) [(c - d) , (b + a) ]
439 (%i4) arrayinfo (bb);
440 (%o4) [hashed, 1, [BAR], [FOO]]
441 @end example
443 @code{listarray} e @code{arrayinfo} aplicada a uma função de array.
445 @c ===beg===
446 @c cc [x, y] := y / x;
447 @c cc [u, v];
448 @c cc [4, z];
449 @c listarray (cc);
450 @c arrayinfo (cc);
451 @c ===end===
452 @example
453 (%i1) cc [x, y] := y / x;
454 y
455 (%o1) cc := -
456 x, y x
457 (%i2) cc [u, v];
458 v
459 (%o2) -
460 u
461 (%i3) cc [4, z];
462 z
463 (%o3) -
464 4
465 (%i4) listarray (cc);
466 z v
467 (%o4) [-, -]
468 4 u
469 (%i5) arrayinfo (cc);
470 (%o5) [hashed, 2, [4, z], [u, v]]
471 @end example
473 @code{listarray} e @code{arrayinfo} aplicadas a funções com subscritos.
475 @c ===beg===
476 @c dd [x] (y) := y ^ x;
477 @c dd [a + b];
478 @c dd [v - u];
479 @c listarray (dd);
480 @c arrayinfo (dd);
481 @c ===end===
482 @example
483 (%i1) dd [x] (y) := y ^ x;
484 x
485 (%o1) dd (y) := y
486 x
487 (%i2) dd [a + b];
488 b + a
489 (%o2) lambda([y], y )
490 (%i3) dd [v - u];
491 v - u
492 (%o3) lambda([y], y )
493 (%i4) listarray (dd);
494 b + a v - u
495 (%o4) [lambda([y], y ), lambda([y], y )]
496 (%i5) arrayinfo (dd);
497 (%o5) [hashed, 1, [b + a], [v - u]]
498 @end example
500 @end deffn
502 @c NEEDS CLARIFICATION
503 @deffn {Função} make_array (@var{type}, @var{dim_1}, ..., @var{dim_n})
504 Cria e retorna um array de Lisp. @var{type} pode
505 ser @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} ou
506 @code{functional}.
507 Existem @math{n} indices,
508 e o @math{i}'enésimo indice está no intervalo de 0 a @math{@var{dim_i} - 1}.
510 A vantagem de @code{make_array} sobre @code{array} é que o valor de retorno não tem
511 um nome, e uma vez que um ponteiro a ele vai, ele irá também.
512 Por exemplo, se @code{y: make_array (...)} então @code{y} aponta para um objeto
513 que ocupa espaço, mas depois de @code{y: false}, @code{y} não mais
514 aponta para aquele objeto, então o objeto pode ser descartado.
516 @c NEEDS CLARIFICATION HERE
517 @c 'FUNCTIONAL ARGUMENT IN MAKE_ARRAY APPEARS TO BE BROKEN
518 @c EVEN AFTER READING THE CODE (SRC/AR.LISP) I CAN'T TELL HOW THIS IS SUPPOSED TO WORK
519 @c COMMENTING OUT THIS STUFF TO PREVENT CONFUSION AND HEARTBREAK
520 @c RESTORE IT WHEN MAKE_ARRAY ('FUNCTIONAL, ...) IS FIXED
521 @c @code{y: make_array ('functional, 'f, 'hashed, 1)} - the second argument to
522 @c @code{make_array} in this case is the function to call to calculate array
523 @c elements, and the rest of the arguments are passed recursively to
524 @c @code{make_array} to generate the "memory" for the array function object.
526 Exemplos:
527 @c ===beg===
528 @c A1 : make_array (fixnum, 10);
529 @c A1 [8] : 1729;
530 @c A1;
531 @c A2 : make_array (flonum, 10);
532 @c A2 [2] : 2.718281828;
533 @c A2;
534 @c A3 : make_array (any, 10);
535 @c A3 [4] : x - y - z;
536 @c A3;
537 @c A4 : make_array (fixnum, 2, 3, 5);
538 @c fillarray (A4, makelist (i, i, 1, 2*3*5));
539 @c A4 [0, 2, 1];
540 @c ===end===
542 @example
543 (%i1) A1 : make_array (fixnum, 10);
544 (%o1) @{Array: #(0 0 0 0 0 0 0 0 0 0)@}
545 (%i2) A1 [8] : 1729;
546 (%o2) 1729
547 (%i3) A1;
548 (%o3) @{Array: #(0 0 0 0 0 0 0 0 1729 0)@}
549 (%i4) A2 : make_array (flonum, 10);
550 (%o4) @{Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
551 (%i5) A2 [2] : 2.718281828;
552 (%o5) 2.718281828
553 (%i6) A2;
554 (%o6)
555 @{Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
556 (%i7) A3 : make_array (any, 10);
557 (%o7) @{Array: #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
558 (%i8) A3 [4] : x - y - z;
559 (%o8) - z - y + x
560 (%i9) A3;
561 (%o9) @{Array: #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
562 -1 $Y) ((MTIMES SIMP) -1 $Z))
563 NIL NIL NIL NIL NIL)@}
564 (%i10) A4 : make_array (fixnum, 2, 3, 5);
565 (%o10) @{Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
566 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))@}
567 (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
568 (%o11) @{Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
569 ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))@}
570 (%i12) A4 [0, 2, 1];
571 (%o12) 12
572 @end example
574 @end deffn
576 @c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
577 @deffn {Função} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})
578 Altera as dimenções de um array.
579 O novo array será preenchido com os elementos do antigo em
580 ordem da maior linha. Se o array antigo era muito pequeno,
581 os elementos restantes serão preenchidos com
582 @code{false}, @code{0.0} ou @code{0},
583 dependendo do tipo do array. O tipo do array não pode ser
584 alterado.
586 @end deffn
588 @deffn {Função} remarray (@var{A_1}, ..., @var{A_n})
589 @deffnx {Função} remarray (all)
590 Remove arrays e funções associadas
591 a arrays e libera o espaço ocupado.
592 Os argumentos podem ser arrays declarados, arrays não declarados (dsordenados - hashed), funções de array functions, e funções com subscritos.
594 @code{remarray (all)} remove todos os ítens na lista global @code{arrays}.
596 @c WHAT DOES THIS MEAN EXACTLY ??
597 Isso pode ser necessário para usar essa função se isso é
598 desejado para redefinir os valores em um array desordenado.
600 @code{remarray} retorna a lista dos arrays removidos.
602 @end deffn
603 @deffn {Função} subvar (@var{x}, @var{i})
604 Avalia a expressão subscrita @code{@var{x}[@var{i}]}.
606 @code{subvar} avalia seus argumentos.
608 @code{arraymake (@var{x}, [@var{i}]} constrói a expressão @code{@var{x}[@var{i}]},
609 mas não a avalia.
611 Exemplos:
613 @c ===beg===
614 @c x : foo $
615 @c i : 3 $
616 @c subvar (x, i);
617 @c foo : [aa, bb, cc, dd, ee]$
618 @c subvar (x, i);
619 @c arraymake (x, [i]);
620 @c ''%;
621 @c ===end===
622 @example
623 (%i1) x : foo $
624 (%i2) i : 3 $
625 @group
626 (%i3) subvar (x, i);
627 (%o3) foo
628 3
629 @end group
630 (%i4) foo : [aa, bb, cc, dd, ee]$
631 @group
632 (%i5) subvar (x, i);
633 (%o5) cc
634 @end group
635 @group
636 (%i6) arraymake (x, [i]);
637 (%o6) foo
638 3
639 @end group
640 @group
641 (%i7) ''%;
642 (%o7) cc
643 @end group
644 @end example
646 @end deffn
648 @c THIS IS REALLY CONFUSING
649 @defvr {Variável de pção} use_fast_arrays
650 - Se @code{true} somente dois tipos de arrays são reconhecidos.
652 1) O array art-q (t no Lisp Comum) que pode ter muitas dimensões
653 indexadas por inteiros, e pode aceitar qualquer objeto do Lisp ou do Maxima como uma
654 entrada. Para construir assim um array, insira @code{a:make_array(any,3,4);}
655 então @code{a} terá como valor, um array com doze posições, e o
656 índice é baseado em zero.
658 2) O array Hash_table que é o tipo padrão de array criado se um
659 faz @code{b[x+1]:y^2} (e @code{b} não é ainda um array, uma lista, ou uma
660 matriz -- se isso ou um desses ocorrer um erro pode ser causado desde
661 @code{x+1} não poderá ser um subscrito válido para um array art-q, uma lista ou
662 uma matriz). Esses índices (também conhecidos como chaves) podem ser quaisquer objetos.
663 Isso somente pega uma chave por vez a cada vez (@code{b[x+1,u]:y} ignorará o @code{u}).
664 A referência termina em @code{b[x+1] ==> y^2}. Certamente a chave poe ser uma lista
665 , e.g. @code{b[[x+1,u]]:y} poderá ser válido. Isso é incompatível
666 com os arrays antigos do Maxima, mas poupa recursos.
668 Uma vantagem de armazenar os arrays como valores de símbolos é que as
669 convenções usuais sobre variáveis locais de uma função aplicam-se a arrays
670 também. O tipo Hash_table também usa menos recursos e é mais eficiente
671 que o velho tipo hashar do Maxima. Para obter comportamento consistente em
672 códigos traduzidos e compilados posicione @code{translate_fast_arrays} para ser
673 @code{true}.
675 @end defvr