| blob | 0acc1cbe58025cd631fea292a8ef61760c403b50 |
1 @c
2 @c versao pt_BR baseada no md5sum abaixo:
3 @c 891f9d709b041d14d27e375d36e1fd01 Arrays.texi
4 @c
5 @c -----------------------------------------------------------------------------
6 @page
7 @node Arrays, Structures, Lists, Data Types and Structures
8 @section Arrays
9 @c -----------------------------------------------------------------------------
11 @menu
12 * Functions and Variables for Arrays::
13 @end menu
15 @c -----------------------------------------------------------------------------
16 @node Functions and Variables for Arrays, , Arrays, Arrays
17 @subsection Functions and Variables for Arrays
18 @c -----------------------------------------------------------------------------
20 @c -----------------------------------------------------------------------------
21 @anchor{array}
22 @deffn {Fun@,{c}@~{a}o} array @
23 @fname{array} (@var{name}, @var{dim_1}, @dots{}, @var{dim_n}) @
24 @fname{array} (@var{name}, @var{type}, @var{dim_1}, @dots{}, @var{dim_n}) @
25 @fname{array} ([@var{name_1}, @dots{}, @var{name_m}], @var{dim_1}, @dots{}, @var{dim_n})
27 Cria um vetor est@'{a}tico @math{n}-dimensional. O valor @math{n} pode ser menor ou equal a 5.
28 Os subscritos para a @math{i}'@'{e}sima dimens@~{a}o s@~{a}o os inteiros variando de 0 a
29 @var{dim_i}.
31 O comando @code{array (@var{nome}, @var{dim_1}, ..., @var{dim_n})} cria um vetor est@'{a}tico
32 gen@'{e}rico.
34 O comando @code{array (@var{nome}, @var{tipo}, @var{dim_1}, ..., @var{dim_n})} cria
35 um vetor est@'{a}tico, com elementos de um tipo espec@'{i}fico. O @var{tipo} pode ser @code{fixnum}
36 para inteiros de tamanho limitado ou @code{flonum} para n@'{u}meros em ponto flutuante.
38 O comando @code{array ([@var{nome_1}, ..., @var{nome_m}], @var{dim_1}, ..., @var{dim_n})}
39 cria @math{m} vetores est@'{a}ticos, todos de mesma dimens@~{a}o.
40 @c SAME TYPE AS WELL ??
42 @c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE
43 Se o usu@'{a}rio coloca um valor em uma vari@'{a}vel de subscrito antes de declarar o
44 vetor est@'{a}tico que a vai usar, um vetor est@'{a}tico n@~{a}o declarado @'{e} criado.
45 Vetores est@'{a}ticos n@~{a}o declarados, tamb@'{e}m conhecidos como vetor est@'{a}tico adapt@'{a}vel (por que a adapta@,{c}@~{a}o
46 @'{e} feita sobre os subscritos), s@~{a}o mais gerais que vetores est@'{a}ticos
47 declarados. O usu@'{a}rio n@~{a}o declara seu tamanho m@'{a}ximo, e eles crescem
48 dinamicamente sendo ajustados @`{a} medida que mais elementos do vetor est@'{a}tico recebem valores. Os
49 subscritos de vetores est@'{a}ticos n@~{a}o declarados n@~{a}o precisam nem mesmo ser n@'{u}meros. Todavia,
50 a menos que um vetor est@'{a}tico seja muito rarefeito, @'{e} provavelmente mais eficiente
51 declarar o vetor est@'{a}tico assim que for poss@'{i}vel que continuar o vetor est@'{a}tico como n@~{a}o declarado. A fun@,{c}@~{a}o
52 @code{array} pode ser usada para transformar um vetor est@'{a}tico n@~{a}o declarado e um vetor est@'{a}tico
53 declarado.
54 @c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??
56 @opencatbox
57 @category{Vetores est@'{a}ticos}
58 @closecatbox
59 @end deffn
61 @c -----------------------------------------------------------------------------
62 @anchor{arrayapply}
63 @deffn {Fun@,{c}@~{a}o} arrayapply (@var{A}, [@var{i_1}, @dots{}, @var{i_n}])
65 Avalia @code{@var{A} [@var{i_1}, ..., @var{i_n}]},
66 onde @var{A} @'{e} um vetor est@'{a}tico e @var{i_1}, @dots{}, @var{i_n} s@~{a}o inteiros.
68 @'{E} um clone de @mrefcomma{apply}
69 com a exce@,{c}@~{a}o de que o primeiro argumento @'{e} um vetor est@'{a}tico
70 ao inv@'{e}s de uma fun@,{c}@~{a}o.
72 @opencatbox
73 @category{Express@~{o}es} @category{Vetores est@'{a}ticos}
74 @closecatbox
75 @end deffn
77 @c -----------------------------------------------------------------------------
78 @anchor{arrayinfo}
79 @deffn {Fun@,{c}@~{a}o} arrayinfo (@var{A})
81 Retorna informa@,{c}@~{o}es sobre o vetor est@'{a}tico @var{A}.
82 O argumento @var{A} pode ser um vetor est@'{a}tico declarado, um vetor est@'{a}tico n@~{a}o declarado (cresce por ajuste),
83 uma fun@,{c}@~{a}o de vetor est@'{a}tico, ou uma fun@,{c}@~{a}o de subscrito.
85 Para vetores est@'{a}ticos declarados, @code{arrayinfo} retorna uma lista compreendendo o @'{a}tomo
86 @code{declared}, o n@'{u}mero de dimens@~{o}es, e o tamanhode cada dimens@~{a}o.
87 Os elementos do vetor est@'{a}tico, associados ou n@~{a}o, s@~{a}o retornados atrav@'{e}s de
88 @code{listarray}.
90 Para vetores est@'{a}ticos n@~{a}o declarados (hashed arrays), @code{arrayinfo} retorna uma lista
91 compreendendo o @'{a}tomo @code{hashed}, o n@'{u}mero de subscritos,
92 e os subscritos de todo elemento que tem um valor.
93 Os valores s@~{a}o retornados por @code{listarray}.
95 Quando o argumento de @var{A} for do tipo fun@,{c}@~{a}o de vetor est@'{a}tico, @code{arrayinfo} retorna uma lista que compreende o @'{a}tomo
96 @code{hashed}, o n@'{u}mero de subscritos,
97 e quaisquer valores de subscrito para os quais hoverem valores armazenados de fun@,{c}@~{a}o.
98 Os valores armazenados de fun@,{c}@~{a}o s@~{a}o retornados atrav@'{e}s da @code{listarray}.
100 Quando o argumento de @var{A} for do tipo fun@,{c}@~{a}o subscrita, @code{arrayinfo} retorna uma lista compreendendo o @'{a}tomo
101 @code{hashed}, o n@'{u}mero de subscritos,
102 e quaisquer valores de subscrito para os quais houverem express@~{o}es lambda.
103 As express@~{o}es lambda s@~{a}o retornadas atrav@'{e}s de @code{listarray}.
105 Veja tamb@'{e}m @mrefdot{listarray}
107 Exemplos:
109 A @code{arrayinfo} e a @code{listarray} aplicadas a um vetor est@'{a}tico declarado.
111 @c ===beg===
112 @c array (aa, 2, 3);
113 @c aa [2, 3] : %pi;
114 @c aa [1, 2] : %e;
115 @c arrayinfo (aa);
116 @c listarray (aa);
117 @c ===end===
118 @example
119 @group
120 (%i1) array (aa, 2, 3);
121 (%o1) aa
122 @end group
123 @group
124 (%i2) aa [2, 3] : %pi;
125 (%o2) %pi
126 @end group
127 @group
128 (%i3) aa [1, 2] : %e;
129 (%o3) %e
130 @end group
131 @group
132 (%i4) arrayinfo (aa);
133 (%o4) [declared, 2, [2, 3]]
134 @end group
135 @group
136 (%i5) listarray (aa);
137 (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
138 #####, #####, #####, %pi]
139 @end group
140 @end example
142 A @code{arrayinfo} e a @code{listarray} aplicadas a vetor est@'{a}tico n@~{a}o declarado (hashed).
144 @c ===beg===
145 @c bb [QUALQUERCOISA] : (a + b)^2;
146 @c bb [OUTRACOISA] : (c - d)^3;
147 @c arrayinfo (bb);
148 @c listarray (bb);
149 @c ===end===
150 @example
151 @group
152 (%i1) bb [QUALQUERCOISA] : (a + b)^2;
153 2
154 (%o1) (b + a)
155 @end group
156 @group
157 (%i2) bb [OUTRACOISA] : (c - d)^3;
158 3
159 (%o2) (c - d)
160 @end group
161 @group
162 (%i3) arrayinfo (bb);
163 (%o3) [hashed, 1, [OUTRACOISA], [QUALQUERCOISA]]
164 @end group
165 @group
166 (%i4) listarray (bb);
167 3 2
168 (%o4) [(c - d) , (b + a) ]
169 @end group
170 @end example
172 A @code{arrayinfo} e a @code{listarray} aplicadas a uma fun@,{c}@~{a}o de vetor est@'{a}tico.
174 @c ===beg===
175 @c cc [x, y] := y / x;
176 @c cc [u, v];
177 @c cc [4, z];
178 @c arrayinfo (cc);
179 @c listarray (cc);
180 @c ===end===
181 @example
182 @group
183 (%i1) cc [x, y] := y / x;
184 y
185 (%o1) cc := -
186 x, y x
187 @end group
188 @group
189 (%i2) cc [u, v];
190 v
191 (%o2) -
192 u
193 @end group
194 @group
195 (%i3) cc [4, z];
196 z
197 (%o3) -
198 4
199 @end group
200 @group
201 (%i4) arrayinfo (cc);
202 (%o4) [hashed, 2, [4, z], [u, v]]
203 @end group
204 @group
205 (%i5) listarray (cc);
206 z v
207 (%o5) [-, -]
208 4 u
209 @end group
210 @end example
212 A @code{arrayinfo} e a @code{listarray} aplicadas a uma fun@,{c}@~{a}o de subscrito.
214 @c ===beg===
215 @c dd [x] (y) := y ^ x;
216 @c dd [a + b];
217 @c dd [v - u];
218 @c arrayinfo (dd);
219 @c listarray (dd);
220 @c ===end===
221 @example
222 @group
223 (%i1) dd [x] (y) := y ^ x;
224 x
225 (%o1) dd (y) := y
226 x
227 @end group
228 @group
229 (%i2) dd [a + b];
230 b + a
231 (%o2) lambda([y], y )
232 @end group
233 @group
234 (%i3) dd [v - u];
235 v - u
236 (%o3) lambda([y], y )
237 @end group
238 @group
239 (%i4) arrayinfo (dd);
240 (%o4) [hashed, 1, [b + a], [v - u]]
241 @end group
242 @group
243 (%i5) listarray (dd);
244 b + a v - u
245 (%o5) [lambda([y], y ), lambda([y], y )]
246 @end group
247 @end example
249 @opencatbox
250 @category{Vetores est@'{a}ticos}
251 @closecatbox
252 @end deffn
254 @c -----------------------------------------------------------------------------
255 @anchor{arraymake}
256 @deffn {Fun@,{c}@~{a}o} arraymake (@var{A}, [@var{i_1}, @dots{}, @var{i_n}])
258 Retorna a express@~{a}o @code{@var{A}[@var{i_1}, ..., @var{i_n}]}.
259 O resultado @'{e} uma refer@^{e}ncia de vetor est@'{a}tico n@~{a}o declarado.
261 A @code{arraymake} @'{e} semelhante a @mrefcomma{funmake}
262 exceto que o valor de retorno
263 @'{e} uma referencia de vetor est@'{a}tico n@~{a}o declarado ao inv@'{e}s de uma chamada de fun@,{c}@~{a}o n@~{a}o avaliada.
265 Exemplos:
266 @c ===beg===
267 @c arraymake (A, [1]);
268 @c arraymake (A, [k]);
269 @c arraymake (A, [i, j, 3]);
270 @c array (A, fixnum, 10);
271 @c fillarray (A, makelist (i^2, i, 1, 11));
272 @c arraymake (A, [5]);
273 @c ''%;
274 @c L : [a, b, c, d, e];
275 @c arraymake ('L, [n]);
276 @c ''%, n = 3;
277 @c A2 : make_array (fixnum, 10);
278 @c fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
279 @c arraymake ('A2, [8]);
280 @c ''%;
281 @c ===end===
282 @example
283 @group
284 (%i1) arraymake (A, [1]);
285 (%o1) A
286 1
287 @end group
288 @group
289 (%i2) arraymake (A, [k]);
290 (%o2) A
291 k
292 @end group
293 @group
294 (%i3) arraymake (A, [i, j, 3]);
295 (%o3) A
296 i, j, 3
297 @end group
298 @group
299 (%i4) array (A, fixnum, 10);
300 (%o4) A
301 @end group
302 @group
303 (%i5) fillarray (A, makelist (i^2, i, 1, 11));
304 (%o5) A
305 @end group
306 @group
307 (%i6) arraymake (A, [5]);
308 (%o6) A
309 5
310 @end group
311 @group
312 (%i7) ''%;
313 (%o7) 36
314 @end group
315 @group
316 (%i8) L : [a, b, c, d, e];
317 (%o8) [a, b, c, d, e]
318 @end group
319 @group
320 (%i9) arraymake ('L, [n]);
321 (%o9) L
322 n
323 @end group
324 @group
325 (%i10) ''%, n = 3;
326 (%o10) c
327 @end group
328 @group
329 (%i11) A2 : make_array (fixnum, 10);
330 (%o11) @{Array: #(0 0 0 0 0 0 0 0 0 0)@}
331 @end group
332 @group
333 (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
334 (%o12) @{Array: #(1 2 3 4 5 6 7 8 9 10)@}
335 @end group
336 @group
337 (%i13) arraymake ('A2, [8]);
338 (%o13) A2
339 8
340 @end group
341 @group
342 (%i14) ''%;
343 (%o14) 9
344 @end group
345 @end example
347 @opencatbox
348 @category{Express@~{o}es} @category{Vetores est@'{a}ticos}
349 @closecatbox
350 @end deffn
352 @c -----------------------------------------------------------------------------
353 @anchor{arrays}
354 @defvr {Vari@'{a}vel de sistema} arrays
355 Valor padr@~{a}o: @code{[]}
357 A vari@'{a}vel de sistema @code{arrays} @'{e} uma lista de vetores est@'{a}ticos que tenha sido alocados.
358 Essa lista compreende vetores est@'{a}ticos declarados por @code{array}, vetores est@'{a}ticos adapt@'{a}veis constru@'{i}dos por
359 defini@,{c}@~{a}o inpl@'{i}cita (atribuindo alguma coisa ao elemento do vetor est@'{a}tico),
360 e fun@,{c}@~{o}es de vetor est@'{a}tico definidas por @code{:=} e por @code{define}.
361 Vetores est@'{a}ticos definidos por @mref{make_array}
362 n@~{a}o est@~{a}o incl@'{i}dos.
364 Veja tamb@'{e}m
365 @mrefcomma{array} @mrefcomma{arrayapply} @mrefcomma{arrayinfo}
366 @w{} @mrefcomma{arraymake} @mrefcomma{fillarray} @mrefcomma{listarray}
367 e @mrefdot{rearray}
368 @c IS THIS AN EXHAUSTIVE LIST ??
370 Exemplos:
372 @c ===beg===
373 @c array (aa, 5, 7);
374 @c bb [QUALQUERCOISA] : (a + b)^2;
375 @c cc [x] := x/100;
376 @c dd : make_array ('any, 7);
377 @c arrays;
378 @c ===end===
379 @example
380 @group
381 (%i1) array (aa, 5, 7);
382 (%o1) aa
383 @end group
384 @group
385 (%i2) bb [QUALQUERCOISA] : (a + b)^2;
386 2
387 (%o2) (b + a)
388 @end group
389 @group
390 (%i3) cc [x] := x/100;
391 x
392 (%o3) cc := ---
393 x 100
394 @end group
395 @group
396 (%i4) dd : make_array ('any, 7);
397 (%o4) @{Array: #(NIL NIL NIL NIL NIL NIL NIL)@}
398 @end group
399 @group
400 (%i5) arrays;
401 (%o5) [aa, bb, cc]
402 @end group
403 @end example
405 @opencatbox
406 @category{Vetores est@'{a}ticos} @category{Vari@'{a}veis globais}
407 @closecatbox
408 @end defvr
410 @c -----------------------------------------------------------------------------
411 @anchor{arraysetapply}
412 @deffn {Fun@,{c}@~{a}o} arraysetapply (@var{A}, [@var{i_1}, @dots{}, @var{i_n}], @var{x})
414 Atribui o mesmo valor @var{x} a todos do @code{@var{A}[@var{i_1}, ..., @var{i_n}]},
415 onde @var{A} @'{e} um vetor est@'{a}tico e @var{i_1}, @dots{}, @var{i_n} s@~{a}o inteiros.
417 A fun@,{c}@~{a}o @code{arraysetapply} avalia seus argumentos.
419 @opencatbox
420 @category{Express@~{o}es} @category{Vetores est@'{a}ticos}
421 @closecatbox
422 @end deffn
424 @c -----------------------------------------------------------------------------
425 @anchor{fillarray}
426 @deffn {Fun@,{c}@~{a}o} fillarray (@var{A}, @var{B})
428 Preenche o vetor est@'{a}tico @var{A} a partir de @var{B}, que @'{e} uma lista ou um vetor est@'{a}tico.
430 Se um tipo espec@'{i}fico for declarado para @var{A} quando ele tiver sido criado,
431 o vetor est@'{a}tico @var{A} pode somente ser preenchido com elementos daquele mesmo tipo especificado durante a cria@,{c}@~{a}o;
432 Constitui um erro se uma tentativa for feita paa copiar um elemento de tipo diferentes.
434 Se as dimens@~{o}es dos vetores est@'{a}ticos @var{A} e @var{B} forem
435 diferentes, @var{A} @'{e} preenchido seguindo a ordem principal por linha
436 @footnote{Nota do tradutor: o primeiro elemento de cada linha a partir
437 da segunda @'{e} preenchido ap@'{o}s o @'{u}ltimo elemento da linha que a precede ser
438 preenchido. Na ordem principal por coluna o primeiro elemento de cada coluna a partir
439 da segunda @'{e} preenchido ap@'{o}s o @'{u}ltimo elemento da coluna que a precede ser
440 preenchido.}. Se n@~{a}o ouverem elementos
441 suficientes em @var{B} o @'{u}ltimo elemento @'{e} usado para preencher o
442 restante de @var{A}. Se ouverem elementos demais, os que sobrarem ser@~{a}o igonorados.
444 A fun@,{c}@~{a}o @code{fillarray} returns its first argument.
446 Exemplos:
448 Cria um vetor est@'{a}tico de 9 elementos e preenche-o a partir de uma lista.
449 @c ===beg===
450 @c array (a1, fixnum, 8);
451 @c listarray (a1);
452 @c fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
453 @c listarray (a1);
454 @c ===end===
455 @example
456 @group
457 (%i1) array (a1, fixnum, 8);
458 (%o1) a1
459 @end group
460 @group
461 (%i2) listarray (a1);
462 (%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0]
463 @end group
464 @group
465 (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
466 (%o3) a1
467 @end group
468 @group
469 (%i4) listarray (a1);
470 (%o4) [1, 2, 3, 4, 5, 6, 7, 8, 9]
471 @end group
472 @end example
474 Quando ouverem elementos a menos para preencher o vetor est@'{a}tico,
475 o @'{u}ltimo elemento @'{e} repetido.
476 Quando ouverem elementos a mais para preencher o vetor est@'{a}tico,
477 os elementos extras s@~{a}o ignorados.
478 @c ===beg===
479 @c a2 : make_array (fixnum, 8);
480 @c fillarray (a2, [1, 2, 3, 4, 5]);
481 @c fillarray (a2, [4]);
482 @c fillarray (a2, makelist (i, i, 1, 100));
483 @c ===end===
484 @example
485 @group
486 (%i1) a2 : make_array (fixnum, 8);
487 (%o1) @{Array: #(0 0 0 0 0 0 0 0)@}
488 @end group
489 @group
490 (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
491 (%o2) @{Array: #(1 2 3 4 5 5 5 5)@}
492 @end group
493 @group
494 (%i3) fillarray (a2, [4]);
495 (%o3) @{Array: #(4 4 4 4 4 4 4 4)@}
496 @end group
497 @group
498 (%i4) fillarray (a2, makelist (i, i, 1, 100));
499 (%o4) @{Array: #(1 2 3 4 5 6 7 8)@}
500 @end group
501 @end example
503 /vetores est@'{a}ticos multidimensionais s@~{a}o preenchidos na ordem principal por linha.
505 @c ===beg===
506 @c a3 : make_array (fixnum, 2, 5);
507 @c fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
508 @c a4 : make_array (fixnum, 5, 2);
509 @c fillarray (a4, a3);
510 @c ===end===
511 @example
512 @group
513 (%i1) a3 : make_array (fixnum, 2, 5);
514 (%o1) @{Array: #2A((0 0 0 0 0) (0 0 0 0 0))@}
515 @end group
516 @group
517 (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
518 (%o2) @{Array: #2A((1 2 3 4 5) (6 7 8 9 10))@}
519 @end group
520 @group
521 (%i3) a4 : make_array (fixnum, 5, 2);
522 (%o3) @{Array: #2A((0 0) (0 0) (0 0) (0 0) (0 0))@}
523 @end group
524 @group
525 (%i4) fillarray (a4, a3);
526 (%o4) @{Array: #2A((1 2) (3 4) (5 6) (7 8) (9 10))@}
527 @end group
528 @end example
530 @opencatbox
531 @category{Vetores est@'{a}ticos}
532 @closecatbox
533 @end deffn
535 @c -----------------------------------------------------------------------------
536 @anchor{listarray}
537 @deffn {Fun@,{c}@~{a}o} listarray (@var{A})
539 Retorna uma lista dos elementos de vetor est@'{a}tico @var{A}.
540 O argumento @var{A} pode ser um vetor est@'{a}tico declarado, um vetor est@'{a}tico n@~{a}o declarado (desordenado),
541 uma fun@,{c}@~{a}o de vetor est@'{a}tico, ou uma fun@,{c}@~{a}o de sobrescrito.
543 Elementos s@~{a}o listados seguindo a ordem principal por linha.
544 Isto @'{e}, elementos s@~{a}o ordenados conforme o primeiro @'{i}ndice, a seguir conforme
545 o segundo @'{i}ndice, e assim por diante. A sequ@^{e}ncia de ordena@,{c}@~{a}o dos valores de @'{i}ndice @'{e} a mesma que
546 a ordem estabelecida por @mrefdot{orderless}
548 Para vetores est@'{a}ticos n@~{a}o declarados, fun@,{c}@~{o}es de vetor est@'{a}tico, e fun@,{c}@~{o}es de subscrito,
549 os elementos correspondem aos valores de @'{i}ndice retornados por @mrefdot{arrayinfo}
551 Elementos n@~{a}o associados de vetores est@'{a}ticos gerais declarados (isto @'{e}, n@~{a}o @code{fixnum} e n@~{a}o
552 @code{flonum}) s@~{a}o retornados como @code{#####}.
553 Elementos n@~{a}o associados de vetores est@'{a}ticos declarados do tipo @code{fixnum} ou @code{flonum}
554 s@~{a}o retornados como 0 ou como 0.0, respectivamente.
555 Elementos n@~{a}o associados de vetores est@'{a}ticos n@~{a}o declarados, fun@,{c}@~{o}es de vetor est@'{a}tico,
556 e fun@,{c}@~{o}es de subscrito n@~{a}o s@~{a}p retornados.
558 Exemplos:
560 A @code{listarray} e a @code{arrayinfo} aplicadas a um vetor est@'{a}tico declarado.
562 @c ===beg===
563 @c array (aa, 2, 3);
564 @c aa [2, 3] : %pi;
565 @c aa [1, 2] : %e;
566 @c listarray (aa);
567 @c arrayinfo (aa);
568 @c ===end===
569 @example
570 @group
571 (%i1) array (aa, 2, 3);
572 (%o1) aa
573 @end group
574 @group
575 (%i2) aa [2, 3] : %pi;
576 (%o2) %pi
577 @end group
578 @group
579 (%i3) aa [1, 2] : %e;
580 (%o3) %e
581 @end group
582 @group
583 (%i4) listarray (aa);
584 (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
585 #####, #####, #####, %pi]
586 @end group
587 @group
588 (%i5) arrayinfo (aa);
589 (%o5) [declared, 2, [2, 3]]
590 @end group
591 @end example
593 A @code{listarray} e a @code{arrayinfo} aplicadas a vetores est@'{a}ticos n@~{a}o declarados (desordenado).
595 @c ===beg===
596 @c bb [QUALQUERCOISA] : (a + b)^2;
597 @c bb [OUTRACOISA] : (c - d)^3;
598 @c listarray (bb);
599 @c arrayinfo (bb);
600 @c ===end===
601 @example
602 @group
603 (%i1) bb [QUALQUERCOISA] : (a + b)^2;
604 2
605 (%o1) (b + a)
606 @end group
607 @group
608 (%i2) bb [OUTRACOISA] : (c - d)^3;
609 3
610 (%o2) (c - d)
611 @end group
612 @group
613 (%i3) listarray (bb);
614 3 2
615 (%o3) [(c - d) , (b + a) ]
616 @end group
617 @group
618 (%i4) arrayinfo (bb);
619 (%o4) [hashed, 1, [OUTRACOISA], [QUALQUERCOISA]]
620 @end group
621 @end example
623 A @code{listarray} e a @code{arrayinfo} aplicadas a uma fun@,{c}@~{a}o de vetor est@'{a}tico.
625 @c ===beg===
626 @c cc [x, y] := y / x;
627 @c cc [u, v];
628 @c cc [4, z];
629 @c listarray (cc);
630 @c arrayinfo (cc);
631 @c ===end===
632 @example
633 @group
634 (%i1) cc [x, y] := y / x;
635 y
636 (%o1) cc := -
637 x, y x
638 @end group
639 @group
640 (%i2) cc [u, v];
641 v
642 (%o2) -
643 u
644 @end group
645 @group
646 (%i3) cc [4, z];
647 z
648 (%o3) -
649 4
650 @end group
651 @group
652 (%i4) listarray (cc);
653 z v
654 (%o4) [-, -]
655 4 u
656 @end group
657 @group
658 (%i5) arrayinfo (cc);
659 (%o5) [hashed, 2, [4, z], [u, v]]
660 @end group
661 @end example
663 A @code{listarray} e a @code{arrayinfo} aplicadas a uma fun@,{c}@~{a}o de subscritos.
665 @c ===beg===
666 @c dd [x] (y) := y ^ x;
667 @c dd [a + b];
668 @c dd [v - u];
669 @c listarray (dd);
670 @c arrayinfo (dd);
671 @c ===end===
672 @example
673 @group
674 (%i1) dd [x] (y) := y ^ x;
675 x
676 (%o1) dd (y) := y
677 x
678 @end group
679 @group
680 (%i2) dd [a + b];
681 b + a
682 (%o2) lambda([y], y )
683 @end group
684 @group
685 (%i3) dd [v - u];
686 v - u
687 (%o3) lambda([y], y )
688 @end group
689 @group
690 (%i4) listarray (dd);
691 b + a v - u
692 (%o4) [lambda([y], y ), lambda([y], y )]
693 @end group
694 @group
695 (%i5) arrayinfo (dd);
696 (%o5) [hashed, 1, [b + a], [v - u]]
697 @end group
698 @end example
700 @opencatbox
701 @category{Vetores est@'{a}ticos}
702 @closecatbox
703 @end deffn
705 @c NEEDS CLARIFICATION
707 @c -----------------------------------------------------------------------------
708 @anchor{make_array}
709 @deffn {Fun@,{c}@~{a}o} make_array (@var{tipo}, @var{dim_1}, @dots{}, @var{dim_n})
711 Cria e retorna um vetor est@'{a}tico de Lisp. O @var{tipo} pode
712 ser @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} ou
713 @code{functional}.
714 Exitem @math{n} @'{i}ndices,
715 e o @math{i}'-@'{e}simo @'{i}ndice vai de 0 a @math{@var{dim_i} - 1}.
717 A vantagem de @code{make_array} sobre @mref{array}
718 @'{e} que o valor de retorno
719 n@~{a}o tem um nome, e uma vez que um apontador para @code{make_array} se propaga, @code{make_array} ir@'{a} tambẽm se propagar.
720 Por exemplo, se @code{y: make_array (...)} ent@~{a}o @code{y} aponta para um objeto
721 que ocupa espa@,{c}o, mas ap@'{o}s @code{y: false}, @code{y} n@~{a}o mais
722 aponta para aquele objeto, ent@~{a}o o objeto pode ser apagado e seu espa@,{c}o de mem@'{o}ria liberado.
724 @c 'FUNCTIONAL ARGUMENT IN MAKE_ARRAY APPEARS TO BE BROKEN
725 @c EVEN AFTER READING THE CODE (SRC/AR.LISP) I CAN'T TELL HOW THIS IS SUPPOSED TO WORK
726 @c COMMENTING OUT THIS STUFF TO PREVENT CONFUSION AND HEARTBREAK
727 @c RESTORE IT WHEN MAKE_ARRAY ('FUNCTIONAL, ...) IS FIXED
728 @c @code{y: make_array ('functional, 'f, 'hashed, 1)} - the second argument to
729 @c @code{make_array} in this case is the function to call to calculate array
730 @c elements, and the rest of the arguments are passed recursively to
731 @c @code{make_array} to generate the "memory" for the array function object.
733 Exemplos:
735 @c ===beg===
736 @c A1 : make_array (fixnum, 10);
737 @c A1 [8] : 1729;
738 @c A1;
739 @c A2 : make_array (flonum, 10);
740 @c A2 [2] : 2.718281828;
741 @c A2;
742 @c A3 : make_array (any, 10);
743 @c A3 [4] : x - y - z;
744 @c A3;
745 @c A4 : make_array (fixnum, 2, 3, 5);
746 @c fillarray (A4, makelist (i, i, 1, 2*3*5));
747 @c A4 [0, 2, 1];
748 @c ===end===
749 @example
750 @group
751 (%i1) A1 : make_array (fixnum, 10);
752 (%o1) @{Array: #(0 0 0 0 0 0 0 0 0 0)@}
753 @end group
754 @group
755 (%i2) A1 [8] : 1729;
756 (%o2) 1729
757 @end group
758 @group
759 (%i3) A1;
760 (%o3) @{Array: #(0 0 0 0 0 0 0 0 1729 0)@}
761 @end group
762 @group
763 (%i4) A2 : make_array (flonum, 10);
764 (%o4) @{Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
765 @end group
766 @group
767 (%i5) A2 [2] : 2.718281828;
768 (%o5) 2.718281828
769 @end group
770 @group
771 (%i6) A2;
772 (%o6)
773 @{Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)@}
774 @end group
775 @group
776 (%i7) A3 : make_array (any, 10);
777 (%o7) @{Array: #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)@}
778 @end group
779 @group
780 (%i8) A3 [4] : x - y - z;
781 (%o8) - z - y + x
782 @end group
783 @group
784 (%i9) A3;
785 (%o9) @{Array: #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
786 -1 $Y) ((MTIMES SIMP) -1 $Z))
787 NIL NIL NIL NIL NIL)@}
788 @end group
789 @group
790 (%i10) A4 : make_array (fixnum, 2, 3, 5);
791 (%o10) @{Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
792 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))@}
793 @end group
794 @group
795 (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
796 (%o11) @{Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
797 ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))@}
798 @end group
799 @group
800 (%i12) A4 [0, 2, 1];
801 (%o12) 12
802 @end group
803 @end example
805 @opencatbox
806 @category{Vetores est@'{a}ticos}
807 @closecatbox
808 @end deffn
810 @c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??
812 @c -----------------------------------------------------------------------------
813 @anchor{rearray}
814 @deffn {Fun@,{c}@~{a}o} rearray (@var{A}, @var{dim_1}, @dots{}, @var{dim_n})
816 Muda a dimens@~{a}o de um vetor est@'{a}tico.
817 O novo vetor est@'{a}tico ser@'{a} preenchido com os elementos do antigo na
818 ordem principal por linha. Se o antigo for muito pequeno,
819 os restantes elementos s@~{a}o preenchidos com
820 @code{false}, @code{0.0} ou @code{0},
821 dependendo do tipo de declara@,{c}@~{a}o do veor est@'{a}tico que est@'{a} sendo modificado. O tipo de vetor est@'{a}tico n@~{a}o pode ser
822 modificado.
824 @opencatbox
825 @category{Vetores est@'{a}ticos}
826 @closecatbox
827 @end deffn
829 @c -----------------------------------------------------------------------------
830 @anchor{remarray}
831 @deffn {Fun@,{c}@~{a}o} remarray @
832 @fname{remarray} (@var{A_1}, @dots{}, @var{A_n}) @
833 @fname{remarray} (all)
835 Remove vetores est@'{a}ticos e fun@,{c}@~{o}es associadas a vetores est@'{a}ticos associados e libera o espa@,{c}o de armazenamento usado.
836 Os argumentos podem ser vetores est@'{a}ticos declarados, n@~{a}o declarados (desordenados), fun@,{c}@~{o}es de vetores
837 est@'{a}ticos, e fn@,{c}@~{o}es de subscritos.
839 O comando @code{remarray (all)} remove todos os itens na lista global @mrefdot{arrays}
841 @c WHAT DOES THIS MEAN EXACTLY ??
842 Pode ser necess@'{a}rio usar essa fun@,{c}@~{a}o se for
843 desejado redefinir os valores em um vetor est@'{a}tico desordenado.
845 A @code{remarray} retorna uma lista dos vetores est@'{a}ticos removidos.
847 A @code{remarray} n@~{a}o avalia seus argumentos.
849 @opencatbox
850 @category{Vetores est@'{a}ticos}
851 @closecatbox
852 @end deffn
854 @c -----------------------------------------------------------------------------
855 @anchor{subvar}
856 @deffn {Fun@,{c}@~{a}o} subvar (@var{x}, @var{i})
858 Avalia a express@~{a}o de subscrito @code{@var{x}[@var{i}]}.
860 A @code{subvar} avalia seus argumentos.
862 O comando @code{arraymake (@var{x}, [@var{i}])} constr@'{o}i a express@~{a}o
863 @code{@var{x}[@var{i}]}, mas n@~{a}o a avalia.
865 Exemplos:
867 @c ===beg===
868 @c x : foo $
869 @c i : 3 $
870 @c subvar (x, i);
871 @c foo : [aa, bb, cc, dd, ee]$
872 @c subvar (x, i);
873 @c arraymake (x, [i]);
874 @c ''%;
875 @c ===end===
876 @example
877 (%i1) x : foo $
878 (%i2) i : 3 $
879 @group
880 (%i3) subvar (x, i);
881 (%o3) foo
882 3
883 @end group
884 (%i4) foo : [aa, bb, cc, dd, ee]$
885 @group
886 (%i5) subvar (x, i);
887 (%o5) cc
888 @end group
889 @group
890 (%i6) arraymake (x, [i]);
891 (%o6) foo
892 3
893 @end group
894 @group
895 (%i7) ''%;
896 (%o7) cc
897 @end group
898 @end example
900 @opencatbox
901 @category{Express@~{o}es} @category{Vetores est@'{a}ticos}
902 @closecatbox
903 @end deffn
905 @c NEEDS EXPANSION AND EXAMPLES
907 @c -----------------------------------------------------------------------------
908 @anchor{subvarp}
909 @deffn {Fun@,{c}@~{a}o} subvarp (@var{expr})
911 Returna @code{true} se @var{expr} for uma vari@'{a}vel de subscrito, por exemplo
912 @code{a[i]}.
914 @opencatbox
915 @category{Fun@,{c}@~{o}es predicado}
916 @closecatbox
917 @end deffn
919 @c THIS IS REALLY CONFUSING
921 @c -----------------------------------------------------------------------------
922 @anchor{use_fast_arrays}
923 @defvr {Vari@'{a}vel de op@,{c}@~{a}o} use_fast_arrays
925 Se @code{true} ent@~{a}o somente dois tipos de vetores est@'{a}ticos s@~{a}o reconhecidos:
927 @enumerate
928 @item
929 O vetor est@'{a}tico art-q (t no "Common Lisp") que pode ter muitas dimens@~{o}es
930 indexadas por inteiros, e pode conter qualquer objeto do Lisp ou do Maxima como uma
931 entrada. Para construir tal vetor est@'{a}tico, insira @code{a:make_array(any,3,4);}
932 ent@~{a}o @code{a} ter@'{a} como valor, um vetor est@'{a}tico com 12 posi@,{c}@~{o}es, e o
933 primeiro @'{i}ndice @'{e} o inteiro zero.
935 @item
936 O vetor est@'{a}tico Hash_table que o tipo padr@~{a}o de vetor est@'{a}tico criado ao
937 se fazer @code{b[x+1]:y^2} (e se @code{b} j@'{a} n@~{a}o for um vetor est@'{a}tico, uma lista, ou uma
938 matriz -- se @code{b} for um desses um erro pode ser retornado uma vez que
939 @code{x+1} pode n@~{a}o ser um subscrito v@'{a}lido para um vetor est@'{a}tico art-q, uma lista ou
940 uma matriz). Seus @'{i}ndices (tamb@'{e}m conhecidos como chaves) podem ser quaisquer objetos.
941 O vetor est@'{a}tico Hash_table somente recebe uma chave de cada vez (@code{b[x+1,u]:y} pode ignorar @code{u}).
942 O referenciamento @'{e} feito por @code{b[x+1] ==> y^2}. Certamente a chave pode ser
943 uma lista, e.g. @code{b[[x+1,u]]:y} pode ser v@'{a}lido. @'{E} incompat@'{i}vel
944 com os antigos vetores est@'{a}ticos desordenados do Maxima, mas poupa recursos.
945 @end enumerate
947 Uma vantagem de armazenar os vetores est@'{a}ticos como valores do s@'{i}mbolo @'{e} que
948 as conven@,{c}@~{o}es usuais sobre vari@'{a}veis locais de uma fun@,{c}@~{a}o aplicam-se ao vetor est@'{a}tico
949 tamb@'{e}m. O tipo Hash_table tambẽm usa menos recursos e @'{e} mais eficiente
950 que o tipo antigo de hashar do Maxima. Para obter comportamento consistente em
951 c@'{o}digos traduzidos e compilados provenientes das vers@~{o}es antigas ajuste @code{translate_fast_arrays} para
952 @code{true}.
954 @opencatbox
955 @category{Vetores est@'{a}ticos} @category{Global flags}
956 @closecatbox
957 @end defvr