~ubuntu-branches/debian/squeeze/maxima/squeeze

Crea un array de dimensi@'on @math{n}, que debe ser menor o igual que 5. Los sub@'{@dotless{i}}ndices de la @math{i}-@'esima dimensi@'on son enteros que toman valores entre 0 y @var{dim_i}.

La llamada @code{array (@var{nombre}, @var{dim_1}, ..., @var{dim_n})} crea un array de tipo general.

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@~no limitado o @code{flonum} para n@'umeros decimales en coma flotante.

La llamada @code{array ([@var{nombre_1}, ..., @var{nombre_m}], @var{dim_1}, ..., @var{dim_n})}

crea @math{m} arrays, todos ellos de igual dimensi@'on.

@c SAME TYPE AS WELL ??

@c THIS DISCUSSION OF UNDECLARED ARRAYS REALLY WANTS TO BE SOMEWHERE ELSE

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@'en conocidos por el nombre de "arrays de claves" (hashed arrays), son m@'as generales que los arrays declarados. El usuario no necesita declarar su tama@~no m@'aximo y pueden ir creciendo de forma din@'amica. Los sub@'{@dotless{i}}ndices de los arrays no declarados no necesitan ser necesariamente n@'umeros. Sin embargo, a menos que un array tenga sus elementos dispersos, probablemente sea m@'as eficiente declararlo siempre que sea posible antes que dejarlo como no declarado. La funci@'on @code{array} puede utilizarse para transformar un array no declarado a a uno declarado.

@c HOW DOES ONE CHANGE AN UNDECLARED ARRAY INTO A DECLARED ARRAY EXACTLY ??

@end deffn

@deffn {Funci@'on} arrayapply (@var{A}, [@var{i_1}, ..., @var{i_n}])

Eval@'ua @code{@var{A} [@var{i_1}, ..., @var{i_n}]}, donde @var{A} es un array y @var{i_1}, ..., @var{i_n} son enteros.

Esto es como @code{apply}, excepto por el hecho de que el primer argumento es un array en lugar de una funci@'on.

@end deffn

@deffn {Funci@'on} arrayinfo (@var{A})

Devuelve informaci@'on sobre el array@var{A}.

El argumento @var{A} puede ser un array declarado o no declarado,

una funci@'on array o una funci@'on subindicada.

En el caso de arrays declarados, @code{arrayinfo} devuelve una

lista que contiene el @'atomo @code{declared}, el n@'umero de

dimensiones y el tama@~no de cada dimensi@'on.

Los elementos del array, tanto los que tienen valores

asignados como los que no, son devueltos por @code{listarray}.

En el caso de arrays no declarados (@i{hashed arrays}), @code{arrayinfo}

devuelve una lista que contiene el @'atomo @code{hashed}, el n@'umero

de sub@'{@dotless{i}}ndices y los sub@'{@dotless{i}}ndices de aquellos

elementos que guarden un valor. Los valores son devueltos por @code{listarray}.

En el caso de funciones array, @code{arrayinfo} devuelve una lista que

contiene el @'atomo @code{hashed}, el n@'umero de sub@'{@dotless{i}}ndices

y los sub@'{@dotless{i}}ndices para los que la funci@'on tiene valores almacenados.

Los valores almacenados de la funci@'on array son devueltos por @code{listarray}.

En el caso de funciones subindicadas, @code{arrayinfo} devuelve una lista que

contiene el @'atomo @code{hashed}, el n@'umero de sub@'{@dotless{i}}ndices y

los sub@'{@dotless{i}}ndices para los que hay expresiones lambda.

Las expresiones lambda son devueltas por @code{listarray}.

Ejemplos:

@code{arrayinfo} y @code{listarray} aplicadas a una array declarado.

@c ===beg===

@c array (aa, 2, 3);

@c aa [2, 3] : %pi;

@c aa [1, 2] : %e;

@c arrayinfo (aa);

@c listarray (aa);

@c ===end===

@example

(%i1) array (aa, 2, 3);

(%o1) aa

(%i2) aa [2, 3] : %pi;

(%o2) %pi

(%i3) aa [1, 2] : %e;

(%o3) %e

(%i4) arrayinfo (aa);

(%o4) [declared, 2, [2, 3]]

(%i5) listarray (aa);

(%o5) [#####, #####, #####, #####, #####, #####, %e, #####,

#####, #####, #####, %pi]

@end example

@code{arrayinfo} y @code{listarray} aplicadas a una array no declarado (@i{hashed arrays}).

@c ===beg===

@c bb [FOO] : (a + b)^2;

@c bb [BAR] : (c - d)^3;

@c arrayinfo (bb);

@c listarray (bb);

@c ===end===

@example

(%i1) bb [FOO] : (a + b)^2;

(%o1) (b + a)

(%i2) bb [BAR] : (c - d)^3;

100

101

(%o2) (c - d)

102

(%i3) arrayinfo (bb);

103

(%o3) [hashed, 1, [BAR], [FOO]]

104

(%i4) listarray (bb);

105

3 2

106

(%o4) [(c - d) , (b + a) ]

107

@end example

108

109

@code{arrayinfo} y @code{listarray} aplicadas a una funci@'on array.

110

111

@c ===beg===

112

@c cc [x, y] := y / x;

113

@c cc [u, v];

114

@c cc [4, z];

115

@c arrayinfo (cc);

116

@c listarray (cc);

117

@c ===end===

118

@example

119

(%i1) cc [x, y] := y / x;

120

121

(%o1) cc := -

122

x, y x

123

(%i2) cc [u, v];

124

125

(%o2) -

126

127

(%i3) cc [4, z];

128

129

(%o3) -

130

131

(%i4) arrayinfo (cc);

132

(%o4) [hashed, 2, [4, z], [u, v]]

133

(%i5) listarray (cc);

134

z v

135

(%o5) [-, -]

136

4 u

137

@end example

138

139

@code{arrayinfo} y @code{listarray} aplicadas a una funci@'on subindicada.

140

141

@c ===beg===

142

@c dd [x] (y) := y ^ x;

143

@c dd [a + b];

144

@c dd [v - u];

145

@c arrayinfo (dd);

146

@c listarray (dd);

147

@c ===end===

148

@example

149

(%i1) dd [x] (y) := y ^ x;

150

151

(%o1) dd (y) := y

152

153

(%i2) dd [a + b];

154

b + a

155

(%o2) lambda([y], y )

156

(%i3) dd [v - u];

157

v - u

158

(%o3) lambda([y], y )

159

(%i4) arrayinfo (dd);

160

(%o4) [hashed, 1, [b + a], [v - u]]

161

(%i5) listarray (dd);

162

b + a v - u

163

(%o5) [lambda([y], y ), lambda([y], y )]

164

@end example

165

166

@end deffn

167

168

@deffn {Funci@'on} arraymake (@var{name}, [@var{i_1}, ..., @var{i_n}])

169

Devuelve la expresi@'on @code{@var{name} [@var{i_1}, ..., @var{i_n}]}.

170

171

Esta funci@'on 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@'on no evaluada.

172

173

@end deffn

174

175

@defvr {Variable del sistema} arrays

176

Valor por defecto: @code{[]}

177

La variable @code{arrays} es una lista con todos los arrays que han sido alojados,

178

lo que comprende a los arrays declarados por @code{array}, a los

179

no declarados (@i{hashed arrays}) construidos impl@'{@dotless{i}}citamente

180

(asignando algo al elemento de un array) y a las funciones array definidas

181

mediante @code{:=} y @code{define}.

182

Los arrays definidos mediante @code{make_array} no se incluyen en

183

este grupo.

184

185

V@'eanse tambi@'en

186

@code{array}, @code{arrayapply}, @code{arrayinfo}, @code{arraymake},

187

@code{fillarray}, @code{listarray} y @code{rearray}.

188

189

Ejemplos:

190

191

@c ===beg===

192

@c array (aa, 5, 7);

193

@c bb [FOO] : (a + b)^2;

194

@c cc [x] := x/100;

195

@c dd : make_array ('any, 7);

196

@c arrays;

197

@c ===end===

198

@example

199

(%i1) array (aa, 5, 7);

200

(%o1) aa

201

(%i2) bb [FOO] : (a + b)^2;

202

203

(%o2) (b + a)

204

(%i3) cc [x] := x/100;

205

206

(%o3) cc := ---

207

x 100

208

(%i4) dd : make_array ('any, 7);

209

(%o4) @{Array: #(NIL NIL NIL NIL NIL NIL NIL)@}

210

(%i5) arrays;

211

(%o5) [aa, bb, cc]

212

@end example

213

214

@end defvr

215

216

@deffn {Funci@'on} bashindices (@var{expr})

217

Transforma la expresi@'on @var{expr} d@'andole a cada suma y producto un @'unico @'{@dotless{i}}ndice. Esto le da a @code{changevar} mayor precisi@'on cuando opera con sumas y productos. La forma del @'unico @'{@dotless{i}}ndice es @code{j@var{number}}. La cantidad @var{number} se determina en funci@'on de @code{gensumnum}, valor que puede cambiar el usuario. Por ejemplo, haciendo @code{gensumnum:0$}.

218

219

@end deffn

220

221

@deffn {Funci@'on} fillarray (@var{A}, @var{B})

222

Rellena el array @var{A} con los valores de @var{B}, que puede ser una lista o array.

223

224

Si @var{A} es un array de n@'umeros decimales en coma flotante (enteros) entonces @var{B} debe ser o bien una lista de n@'umeros decimales en coma flotante (enteros), o bien otro array de n@'umeros en coma flotante (enteros).

225

226

Si las dimensiones de los areglos son diferentes, @var{A} se rellena seg@'un el orden de las filas. Si no hay suficientes elementos en @var{B} el @'ultimo elemento se utiliza para cubrir el resto de @var{A}. Si hay demasiados, los elementos sobrantes son ignorados.

227

228

La funci@'on @code{fillarray} devuelve su primer argumento.

229

230

@end deffn

231

232

233

@deffn {Funci@'on} listarray (@var{A})

234

Devuelve una lista con los elementos del array @var{A}.

235

El argumento @var{A} puede ser un array declarado o no declarado,

236

una funci@'on array o una funci@'on subindicada.

237

238

Los elementos se ordenan en primera instancia respecto del primer

239

@'{@dotless{i}}ndice, despu@'es respecto del segundo @'{@dotless{i}}ndice

240

y as@'{@dotless{i}} sucesivamente.

241

La ordenaci@'on de los @'{@dotless{i}}ndices es la misma que la

242

establecida por @code{orderless}.

243

244

En el caso de arrays no declarados, funciones array y funciones

245

subindicadas, los elementos corresponden a los @'{@dotless{i}}ndices

246

devueltos por @code{arrayinfo}.

247

248

Los elementos de los arrays declarados que no tienen valores asignados

249

(excepto @code{fixnum} y @code{flonum}) se devuelven como @code{#####}.

250

Los elementos sin valores asignados de los arrays @code{fixnum} y @code{flonum}

251

son devueltos como 0 y 0.0, respectivamente.

252

Los elementos sin valor asignado de los arrays no declarados,

253

funciones array y funciones subindicadas no son devueltos.

254

255

Ejemplos:

256

257

@code{listarray} y @code{arrayinfo} aplicadas a un array declarado.

258

259

@c ===beg===

260

@c array (aa, 2, 3);

261

@c aa [2, 3] : %pi;

262

@c aa [1, 2] : %e;

263

@c listarray (aa);

264

@c arrayinfo (aa);

265

@c ===end===

266

@example

267

(%i1) array (aa, 2, 3);

268

(%o1) aa

269

(%i2) aa [2, 3] : %pi;

270

(%o2) %pi

271

(%i3) aa [1, 2] : %e;

272

(%o3) %e

273

(%i4) listarray (aa);

274

(%o4) [#####, #####, #####, #####, #####, #####, %e, #####,

275

#####, #####, #####, %pi]

276

(%i5) arrayinfo (aa);

277

(%o5) [declared, 2, [2, 3]]

278

@end example

279

280

@code{listarray} y @code{arrayinfo} aplicadas a un array no declarado (@i{hashed array}).

281

282

@c ===beg===

283

@c bb [FOO] : (a + b)^2;

284

@c bb [BAR] : (c - d)^3;

285

@c listarray (bb);

286

@c arrayinfo (bb);

287

@c ===end===

288

@example

289

(%i1) bb [FOO] : (a + b)^2;

290

291

(%o1) (b + a)

292

(%i2) bb [BAR] : (c - d)^3;

293

294

(%o2) (c - d)

295

(%i3) listarray (bb);

296

3 2

297

(%o3) [(c - d) , (b + a) ]

298

(%i4) arrayinfo (bb);

299

(%o4) [hashed, 1, [BAR], [FOO]]

300

@end example

301

302

@code{listarray} y @code{arrayinfo} aplicadas a una funci@'on array.

303

304

@c ===beg===

305

@c cc [x, y] := y / x;

306

@c cc [u, v];

307

@c cc [4, z];

308

@c listarray (cc);

309

@c arrayinfo (cc);

310

@c ===end===

311

@example

312

(%i1) cc [x, y] := y / x;

313

314

(%o1) cc := -

315

x, y x

316

(%i2) cc [u, v];

317

318

(%o2) -

319

320

(%i3) cc [4, z];

321

322

(%o3) -

323

324

(%i4) listarray (cc);

325

z v

326

(%o4) [-, -]

327

4 u

328

(%i5) arrayinfo (cc);

329

(%o5) [hashed, 2, [4, z], [u, v]]

330

@end example

331

332

@code{listarray} y @code{arrayinfo} aplicadas a una funci@'on subindicada.

333

334

@c ===beg===

335

@c dd [x] (y) := y ^ x;

336

@c dd [a + b];

337

@c dd [v - u];

338

@c listarray (dd);

339

@c arrayinfo (dd);

340

@c ===end===

341

@example

342

(%i1) dd [x] (y) := y ^ x;

343

344

(%o1) dd (y) := y

345

346

(%i2) dd [a + b];

347

b + a

348

(%o2) lambda([y], y )

349

(%i3) dd [v - u];

350

v - u

351

(%o3) lambda([y], y )

352

(%i4) listarray (dd);

353

b + a v - u

354

(%o4) [lambda([y], y ), lambda([y], y )]

355

(%i5) arrayinfo (dd);

356

(%o5) [hashed, 1, [b + a], [v - u]]

357

@end example

358

359

@end deffn

360

361

@deffn {Funci@'on} make_array (@var{tipo}, @var{dim_1}, ..., @var{dim_n})

362

Construye y devuelve un array de Lisp. El argumento @var{tipo} puede ser @code{any}, @code{flonum}, @code{fixnum}, @code{hashed} o @code{functional}. Hay @math{n} @'{@dotless{i}}ndices, y el @'{@dotless{i}}ndice @math{i}-@'esimo va de 0 a @math{@var{dim_i} - 1}.

363

364

La ventaja de @code{make_array} sobre @code{array} estriba en que el valor retornado no tiene nombre, y una vez que un puntero deja de referenciarlo, el valor desaparece. Por ejemplo, si @code{y: make_array (...)} entonces @code{y} apunta a un objeto que ocupa cierto espacio en la memoria, pero despu@'es de @code{y: false}, @code{y} ya no apunta al objeto, por lo que @'este puede ser considerado basura y posteriormente eliminado.

365

366

@end deffn

367

368

@c DOES THIS MODIFY A OR DOES IT CREATE A NEW ARRAY ??

369

@deffn {Funci@'on} rearray (@var{A}, @var{dim_1}, ..., @var{dim_n})

370

Cambia las dimensiones de un array. El nuevo array ser@'a rellenado con los elementos del viejo seg@'un el orden de las filas. Si el array antiguo era demasiado peque@~no, 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.

371

372

@end deffn

373

374

@deffn {Funci@'on} remarray (@var{A_1}, ..., @var{A_n})

375

@deffnx {Funci@'on} remarray (all)

376

Borra los arrays y las funciones relacionadas con ellos, liberando el espacio de memoria ocupado.

377

Los argumentos pueden ser arrays declarados, arrays no declarados (@i{hashed arrays}),

378

funciones array y funciones subindicadas.

379

380

La llamada @code{remarray (all)} borra todos los elementos de la lista global @code{arrays}.

381

382

La funci@'on @code{remarray} devuelve la lista de los arrays borrados.

383

384

@end deffn

385

386

387

@deffn {Funci@'on} subvar (@var{x}, @var{i})

388

Eval@'ua la expresi@'on subindicada @code{@var{x}[@var{i}]}.

389

390

La funci@'on @code{subvar} eval@'ua sus argumentos.

391

392

La instrucci@'on @code{arraymake (@var{x}, [@var{i}]} construye la expresi@'on @code{@var{x}[@var{i}]},

393

pero no la eval@'ua.

394

395

Ejemplos:

396

397

@c ===beg===

398

@c x : foo $

399

@c i : 3 $

400

@c subvar (x, i);

401

@c foo : [aa, bb, cc, dd, ee]$

402

@c subvar (x, i);

403

@c arraymake (x, [i]);

404

@c ''%;

405

@c ===end===

406

@example

407

(%i1) x : foo $

408

409

(%i2) i : 3 $

410

411

(%i3) subvar (x, i);

412

(%o3) foo

413

414

(%i4) foo : [aa, bb, cc, dd, ee]$

415

416

(%i5) subvar (x, i);

417

(%o5) cc

418

(%i6) arraymake (x, [i]);

419

(%o6) foo

420

421

(%i7) ''%;

422

(%o7) cc

423

@end example

424

425

@end deffn

426

427

428

@c THIS IS REALLY CONFUSING

429

@defvr {Variable opcional} use_fast_arrays

430

Valor por defecto: @code{false}

431

432

Si @code{use_fast_arrays} vale @code{true} entonces tan solo se reconocen dos tipos de arrays.

433

434

@c AQUI QUEDAN TRES PARRAFOS SIN TRADUCIR

435

436

@end defvr

Older »