1
This is maxima.info, produced by makeinfo version 4.7 from maxima.texi.
3
Este es el Manual de Maxima en versión Texinfo
5
Copyright 1994, 2001 William F. Schelter
8
* Maxima: (maxima). Un sistema de cálculo simbólico
12
File: maxima.info, Node: Definiciones para polinomios ortogonales, Prev: Introducción a polinomios ortogonales, Up: orthopoly
14
61.2 Definiciones para polinomios ortogonales
15
=============================================
17
-- Función: assoc_legendre_p (<n>, <m>, <x>)
18
Función asociada de Legendre de primera especie.
20
Referencia: Abramowitz y Stegun, ecuaciones 22.5.37, página 779,
21
8.6.6 (segunda ecuación), página 334 y 8.2.5, página 333.
23
-- Función: assoc_legendre_q (<n>, <m>, <x>)
24
Función asociada de Legendre de segunda especie.
26
Referencia: Abramowitz y Stegun, ecuaciones 8.5.3 y 8.1.8.
28
-- Función: chebyshev_t (<n>, <x>)
29
Función de Chebyshev de primera especie.
31
Referencia: Abramowitz y Stegun, ecuación 22.5.47, página 779.
33
-- Función: chebyshev_u (<n>, <x>)
34
Función de Chebyshev de segunda especie.
36
Referencia: Abramowitz y Stegun, ecuación 22.5.48, página 779.
38
-- Función: gen_laguerre (<n>, <a>, <x>)
39
Polinomio de Laguerre generalizado.
41
Referencia: Abramowitz y Stegun, ecuación 22.5.54, página 780.
43
-- Función: hermite (<n>, <x>)
46
Referencia: Abramowitz y Stegun, ecuación 22.5.55, página 780.
48
-- Función: intervalp (<e>)
49
Devuelve `true' si la entrada es un intervalo y `false' en caso
52
-- Función: jacobi_p (<n>, <a>, <b>, <x>)
55
Los polinomios de Jacobi están definidos para todo <a> y <b>; sin
56
embargo, el peso `(1 - <x>)^<a> (1 + <x>)^<b>' no es integrable
57
para `<a> <= -1' o `<b> <= -1'.
59
Referencia: Abramowitz y Stegun, ecuación 22.5.42, página 779.
61
-- Función: laguerre (<n>, <x>)
62
Polinomio de Laguerre.
64
Referencia: Abramowitz y Stegun, ecuaciones 22.5.16 y 22.5.54,
67
-- Función: legendre_p (<n>, <x>)
68
Polinomio de Legendre de primera especie.
70
Referencia: Abramowitz y Stegun, ecuaciones 22.5.50 y 22.5.51,
73
-- Función: legendre_q (<n>, <x>)
74
Polinomio de Legendre de segunda especie.
76
Referencia: Abramowitz y Stegun, ecuaciones 8.5.3 y 8.1.8.
78
-- Función: orthopoly_recur (<f>, <args>)
79
Devuelve una relación recursiva para la familia de funciones
80
ortogonales <f> con argumentos <args>. La recursión se hace con
81
respecto al grado del polinomio.
83
(%i1) orthopoly_recur (legendre_p, [n, x]);
84
(2 n - 1) P (x) x + (1 - n) P (x)
86
(%o1) P (x) = -----------------------------------------
89
El segundo argumento de `orthopoly_recur' debe ser una lista con
90
el número correcto de argumentos para la función <f>; si no lo es,
91
Maxima emite un mensaje de error.
93
(%i1) orthopoly_recur (jacobi_p, [n, x]);
95
Function jacobi_p needs 4 arguments, instead it received 2
96
-- an error. Quitting. To debug this try debugmode(true);
98
Además, si <f> no es el nombre de ninguna de las familias de
99
polinomios ortogonales, se emite otro mensaje de error.
101
(%i1) orthopoly_recur (foo, [n, x]);
103
A recursion relation for foo isn't known to Maxima
104
-- an error. Quitting. To debug this try debugmode(true);
106
-- Variable opcional: orthopoly_returns_intervals
107
Valor por defecto: `true'
109
Si `orthopoly_returns_intervals' vale `true', los números
110
decimales en coma flotante se retornan con el formato `interval
111
(<c>, <r>)', donde <c> es el centro del intervalo y <r> su radio.
112
El centro puede ser un número complejo, en cuyo caso el intervalo
113
es un disco en el plano complejo.
115
-- Función: orthopoly_weight (<f>, <args>)
116
Devuelve una lista con tres elementos; el primer elemento es la
117
fórmula del peso para la familia de polinomios ortogonales <f> con
118
los argumentos dados por la lista <args>; el segundo y tercer
119
elementos son los extremos inferior y superior del intervalo de
120
ortogonalidad. Por ejemplo,
122
(%i1) w : orthopoly_weight (hermite, [n, x]);
125
(%o1) [%e , - inf, inf]
126
(%i2) integrate (w[1] * hermite (3, x) * hermite (2, x), x, w[2], w[3]);
129
La variable principal de <f> debe ser un símbolo, en caso
130
contrario Maxima emite un mensaje de error.
132
-- Función: pochhammer (<n>, <x>)
133
Símbolo de Pochhammer. Para enteros no negativos <n> con `<n> <=
134
pochhammer_max_index', la expresión `pochhammer (<x>, <n>)' se
135
evalúa como el producto `<x> (<x> + 1) (<x> + 2) ... (<x> + n -
136
1)' si `<n> > 0' y como 1 si `<n> = 0'. Para <n> negativo,
137
`pochhammer (<x>, <n>)' se define como `(-1)^<n> / pochhammer (1 -
138
<x>, -<n>)'. Así por ejemplo,
140
(%i1) pochhammer (x, 3);
141
(%o1) x (x + 1) (x + 2)
142
(%i2) pochhammer (x, -3);
144
(%o2) - -----------------------
145
(1 - x) (2 - x) (3 - x)
147
A fin de convertir el símbolo de Pochhammer en un cociente de
148
funciones gamma (véase Abramowitz y Stegun, ecuación 6.1.22),
149
hágase uso de `makegamma'. Por ejemplo,
151
(%i1) makegamma (pochhammer (x, n));
156
Si <n> es mayor que `pochhammer_max_index' o si <n> es simbólico,
157
`pochhammer' devuelve una forma nominal.
159
(%i1) pochhammer (x, n);
163
-- Variable opcional: pochhammer_max_index
164
Valor por defecto: 100
166
`pochhammer (<n>, <x>)' se evalúa como un producto si y sólo si
167
`<n> <= pochhammer_max_index'.
171
(%i1) pochhammer (x, 3), pochhammer_max_index : 3;
172
(%o1) x (x + 1) (x + 2)
173
(%i2) pochhammer (x, 4), pochhammer_max_index : 3;
177
Referencia: Abramowitz y Stegun, ecuación 6.1.16, página 256.
179
-- Función: spherical_bessel_j (<n>, <x>)
180
Función de Bessel esférica de primera especie.
182
Referencia: Abramowitz y Stegun, ecuaciones 10.1.8, página 437 y
185
-- Función: spherical_bessel_y (<n>, <x>)
186
Función de Bessel esférica de segunda especie.
188
Referencia: Abramowitz y Stegun, ecuaciones 10.1.9, página 437 y
191
-- Función: spherical_hankel1 (<n>, <x>)
192
Función esférica de Hankel de primera especie.
194
Referencia: Abramowitz y Stegun, ecuación 10.1.36, página 439.
196
-- Función: spherical_hankel2 (<n>, <x>)
197
Función esférica de Hankel de segunda especie.
199
Referencia: Abramowitz y Stegun, ecuación 10.1.17, página 439.
201
-- Función: spherical_harmonic (<n>, <m>, <x>, <y>)
202
Función armónica esférica.
204
Referencia: Merzbacher 9.64.
206
-- Función: unit_step (<x>)
207
Función de escalón unidad continua por la izquierda, definida de
208
tal forma que `unit_step (<x>)' se anula para `<x> <= 0' y es
209
igual a 1 para `<x> > 0'.
211
En caso de ser necesaria una función escalón unidad que tome el
212
valor 1/2 en el origen, utilícese `(1 + signum (<x>))/2'.
214
-- Función: ultraspherical (<n>, <a>, <x>)
215
Polinomio ultraesférico o de Gegenbauer.
217
Referencia: Abramowitz y Stegun, ecuación 22.5.46, página 779.
220
File: maxima.info, Node: plotdf, Next: simplex, Prev: orthopoly, Up: Top
227
* Introducción a plotdf::
228
* Definiciones para plotdf::
231
File: maxima.info, Node: Introducción a plotdf, Next: Definiciones para plotdf, Prev: plotdf, Up: plotdf
233
62.1 Introducción a plotdf
234
==========================
236
La función `plotdf' crea un gráfico del campo de direcciones para una
237
Ecuación Diferencial Ordinaria (EDO) de primer orden, o para un sistema
238
de dos EDO's autónomas, de primer orden.
240
Para dibujar el campo de direcciones de una única EDO, esa ecución
241
deberá escribirse en la forma siguiente:
246
y la función <F> será dada como argumento para el comando `plotdf'.
247
La variable independiente tiene que ser siempre <x> y la variable
248
dependiente <y>. A esas dos variables no podrá estar asociado ningún
251
Para dibujar el campo de direcciones de un sistema autónomo de dos
252
EDO's, Las dos ecuaciones deben ser escritas en la forma siguiente
254
-- = G(x,y) -- = F(x,y)
257
y el argumento para el comando `plotdf' será una lista con dos
258
expresiones para las funciones <F> y <G>.
260
Cuando se trabaja con una única ecuación, `plotdf' asume
261
implícitamente que `x=t' y `G(x,y)=1', transformando la ecuación en un
262
sistema autónomo con dos ecuaciones.
265
File: maxima.info, Node: Definiciones para plotdf, Prev: Introducción a plotdf, Up: plotdf
267
62.2 Definiciones para plotdf
268
=============================
270
-- Function: plotdf (<dydx>,...opciones...)
271
-- Function: plotdf (`['<dxdt>,<dydt>`]',...opciones...)
272
Dibuja un campo de direcciones en dos dimensiones <x> and <y>.
274
<dydx>, <dxdt> y <dydt> son expresiones que dependen de <x> y <y>.
275
Además de esas dos variables, las dos expresiones pueden depender
276
de un conjunto de parámetros, con valores numéricos que son dados
277
por medio de la opción `parameters' (la sintaxis de esa opción se
278
explica mas al frente), o con un rango de posibles valores
279
definidos con la opción <sliders>.
281
Varias otras opciones se pueden incluir dentro del comando, o en
282
el menú que aparece cuando se hace click en la esquina superior
283
izquierda de la ventana del gráfico. Haciendo click en un punto
284
del gráfico se puede hacer que sea dibujada la curva integral que
285
pasa por ese punto; lo mismo puede ser hecho dando las coordenadas
286
del punto con la opción `trajectory_at' dentro del comando plotdf.
287
La dirección de integración se puede controlar con la opción
288
`direction', que acepta valores de "forward", "backward" o "both".
289
El número de pasos realizado en la integración numérica se
290
controla con la opción `nsteps' y el incremento del tiempo en cada
291
paso con la opción `tstep'. Se usa el método de Adams Moulton para
292
hacer la integración numérica; también es posible cambiar para el
293
método de Runge-Kutta de cuarto orden con ajuste de pasos.
295
Menú de la ventana del gráfico:
297
El menú de la ventana gráfica dispone de las siguientes opciones:
298
"Zoom", que permite cambiar el comportamiento del ratón, de manera
299
que hará posible el hacer zoom en la región del gráfico haciendo
300
clic con el botón izquierdo. Cada clic agranda la imagen
301
manteniendo como centro de la misma el punto sobre el cual se ha
302
hecho clic. Manteniendo pulsada la tecla SHIFT mientras se hace
303
clic, retrocede al tamaño anterior. Para reanudar el cálculo de
304
las trayectorias cuando se hace clic, selecciónese la opción
305
"Integrate" del menú.
307
La opción "Config" del menú se puede utilizar para cambiar la(s)
308
EDO(S) y algunos otros ajustes. Después de hacer los cambios, se
309
debe utilizar la opción "Replot" para activar los nuevos ajustes.
310
Si en el campo "Trajectory at" del menú de diálogo de "Config" se
311
introducen un par de coordenadas y luego se pulsa la tecla
312
"retorno", se mostrará una nueva curva integral, además de las ya
313
dibujadas. Si se selecciona la opción "Replot", sólo se mostrará
314
la última curva integral seleccionada.
316
Manteniendo pulsado el botón derecho del ratón mientras se mueve
317
el cursor, se puede arrastrar el gráfico horizontal y
318
verticalmente. Otros parámetros, como pueden ser el número de
319
pasos, el valor inicial de <t>, las coordenadas del centro y el
320
radio, pueden cambiarse en el submenú de la opción "Config".
322
Con la opción "Save", se puede obtener una copia del gráfico en una
323
impresora Postscript o guardarlo en un fichero Postscript. Para
324
optar entre la impresión o guardar en fichero, se debe seleccionar
325
"Print Options" en la ventana de diálogo de "Config". Una vez
326
cubiertos los campos de la ventana de diálogo de "Save", será
327
necesario seleccionar la opción "Save" del primer menú para crear
328
el fichero o imprimir el gráfico.
332
La función `plotdf' admite varias opciones, cada una de las cuales
333
es una lista de dos o más elementos. El primer elemento es el
334
nombre de la opción, y el resto está formado por el valor o
335
valores asignados a dicha opción.
337
La función `plotdf' reconoce las siguientes opciones:
339
* Opción: `tstep' establece la amplitud de los incrementos en la
340
variable independiente <t>, utilizados para calcular la curva
341
integral. Si se sólo se aporta una expresión <dydx>, la
342
variable <x> será directamente proporcional a <t>: `x -
343
xinitial = t - tinitial'.
345
El valor por defecto es 0.1.
347
* Opción: `nsteps' establece el número de pasos de longitud
348
`tstep' que se utilizarán en la variable independiente para
349
calcular la curva integral.
351
El valor por defecto es 100.
353
* Opción: `direction' establece la dirección de la variable
354
independiente que será seguida para calcular una curva
355
integral. Valores posibles son: `forward', para hacer que la
356
variable independiente aumente `nsteps' veces, con
357
incrementos `tstep'; `backward', para hacer que la variable
358
independiente disminuya; `both', para extender la curva
359
integral `nsteps' pasos hacia adelante y `nsteps' pasos hacia
360
atrás. Las palabras `right' y `left' se pueden utilizar como
361
sinónimos de `forward' y `backward'.
363
El valor por defecto es `both'.
365
* Opción: `tinitial' establece el valor inicial de la variable
366
<t> utilizado para calcular curvas integrales. Puesto que las
367
ecuaciones diferenciales son autónomas, esta opción sólo
368
aparecerá en los gráficos de las curvas como funciones de <t>.
370
El valor por defecto es 0.
372
* Opción: `versus_t' se utiliza para crear una segunda ventana
373
gráfica, con el gráfico de una curva integral, como dos
374
funciones <x>, <y>, de variable independiente <t>. Si se le
375
da a `versus_t' cualquier valor diferente de 0, se mostrará la
376
segunda ventana gráfica, la cual incluye otro menú, similar
377
al de la ventana principal.
379
El valor por defecto es 0.
381
* Opción: `trajectory_at' establece las coordenadas <xinitial>
382
y <yinitial> para el extremo inicial de la curva integral.
383
[trajectory_at,0.1,3.2]
384
No tiene asignado valor por defecto.
386
* Opción: `parameters' establece una lista de parámetros, junto
387
con sus valores numéricos, que son utilizados en la
388
definición de la ecuación diferencial. Los nombres de los
389
parámetros y sus valores deben escribirse en formato de cadena
390
de caracteres como una secuencia de pares `nombre=valor'
392
[parameters,"k=1.1,m=2.5"]
394
* Opción: `sliders' establece una lista de parámetros que se
395
cambiarán interactivamente utilizando barras de deslizamiento,
396
así como los rangos de variación de dichos parámetros. Los
397
nombres de los parámetros y sus rangos deben escribirse en
398
formato de cadena de caracteres como una secuencia de pares
399
`nombre=min:max' separados por comas.
400
[sliders,"k=0:4,m=1:3"]
402
* Opción: `xfun' establece una cadena de caracteres con
403
funciones de <x> separadas por puntos y comas para ser
404
representadas por encima del campo de direcciones. Estas
405
funciones serán interpretadas por Tcl, no por Maxima.
406
[xfun,"x^2;sin(x);exp(x)"]
408
* Opción: `xradius' es la mitad de la longitud del rango de
409
valores a representar en la dirección x.
411
El valor por defecto es 10.
413
* Opción: `yradius' es la mitad de la longitud del rango de
414
valores a representar en la dirección y.
416
El valor por defecto es 10.
418
* Opción: `xcenter' es la coordenada x del punto situado en el
421
El valor por defecto es 0.
423
* Opción: `ycenter' es la coordenada y del punto situado en el
426
El valor por defecto es 0.
428
* Opción: `width' establece el ancho de la ventana gráfica en
431
El valor por defecto es 500.
433
* Opción: `height' establece la altura de la ventana gráfica en
436
El valor por defecto es 500.
441
NOTA: debido a un fallo en `openmath', todas las funciones,
442
incluida `plotdf', deben terminar en punto y coma, no con el
443
símbolo de dólar, el cual puede ser válido en otros contextos
444
gráficos; para evitar problemas, se usará el punto y coma en los
447
* Para mostrar el campo de direcciones de la ecuación
448
diferencial y' = exp(-x) + y y la solución que pasa por (2,
450
(%i1) load("plotdf")$
452
(%i2) plotdf(exp(-x)+y,[trajectory_at,2,-0.1]);
454
* Para mostrar el campo de direcciones de la ecuación diff(y,x)
455
= x - y^2 y la solución de condición inicial y(-1) = 3, se
456
puede utilizar la sentencia:
457
(%i3) plotdf(x-y^2,[xfun,"sqrt(x);-sqrt(x)"],
458
[trajectory_at,-1,3], [direction,forward],
459
[yradius,5],[xcenter,6]);
460
El gráfico también muestra la función y = sqrt(x).
462
* El siguiente ejemplo muestra el campo de direcciones de un
463
oscilador armónico, definido por las ecuaciones dx/dt = y y
464
dy/dt = -k*x/m, y la curva integral que pasa por (x,y) =
465
(6,0), con una barra de deslizamiento que permitirá cambiar
466
el valor de m interactivamente (k está permanece fijo a 2):
467
(%i4) plotdf([y,-k*x/m],[parameters,"m=2,k=2"],
468
[sliders,"m=1:5"], [trajectory_at,6,0]);
470
* Para representar el campo de direcciones de la ecuación de
471
Duffing, m*x"+c*x'+k*x+b*x^3 = 0, se introduce la variable
473
(%i5) plotdf([y,-(k*x + c*y + b*x^3)/m],
474
[parameters,"k=-1,m=1.0,c=0,b=1"],
475
[sliders,"k=-2:2,m=-1:1"],[tstep,0.1]);
477
* El campo de direcciones de un péndulo amortiguado, incluyendo
478
la solución para condiciones iniciales dadas, con una barra
479
de deslizamiento que se puede utilizar para cambiar el valor
480
de la masa, m, y con el gráfico de las dos variables de
481
estado como funciones del tiempo:
483
(%i6) plotdf([y,-g*sin(x)/l - b*y/m/l],
484
[parameters,"g=9.8,l=0.5,m=0.3,b=0.05"],
485
[trajectory_at,1.05,-9],[tstep,0.01],
486
[xradius,6],[yradius,14],
487
[xcenter,-4],[direction,forward],[nsteps,300],
488
[sliders,"m=0.1:1"], [versus_t,1]);
491
Para hacer uso de esta función, ejecútese primero `load("plotdf")'.
494
File: maxima.info, Node: simplex, Next: simplification, Prev: plotdf, Up: Top
501
* Introducción a simplex::
502
* Definiciones para simplex::
505
File: maxima.info, Node: Introducción a simplex, Next: Definiciones para simplex, Prev: simplex, Up: simplex
507
63.1 Introducción a simplex
508
===========================
510
El paquete `simplex' utiliza el algoritmo simplex para programación
515
(%i1) load("simplex")$
516
(%i2) minimize_sx(x+y, [3*x+2*y>2, x+4*y>3]);
518
(%o2) [--, [y = --, x = -]]
522
File: maxima.info, Node: Definiciones para simplex, Prev: Introducción a simplex, Up: simplex
524
63.2 Definiciones para simplex
525
==============================
527
-- Variable opcional: epsilon_sx
528
Valor por defecto: `10^-8'
530
Error epsilon utilizado en los cálculos numéricos de
533
Véase también `linear_program'.
536
-- Función: linear_program (<A>, <b>, <c>)
537
La función `linear_program' es una implementación del algoritmo
538
simplex. La instrucción `linear_program(A, b, c)' calcula un
539
vector <x> tal que minimiza `c.x' bajo las restricciones `A.x = b'
540
y `x >= 0'. El argumento <A> es una matriz y los argumentos <b> y
543
La función `linear_program' devuelve una lista que contiene el
544
vector solución <x> y el valor mínimo de `c.x'. Si el problema no
545
está acotado, devuelve el mensaje "Problem not bounded!" y si el
546
problema no es factible, devuelve el mensaje "Problem not
549
Para usar esta función, cárguese primero el paquete con la
550
instrucción `load(simplex);'.
554
(%i1) A: matrix([1,1,-1,0], [2,-3,0,-1], [4,-5,0,0])$
557
(%i4) linear_program(A, b, c);
560
(%o4) linear_program([ 2 - 3 0 - 1 ], [1, 1, 6],
565
Véanse también `minimize_sx', `scale_sx' y `epsilon_sx'.
568
-- Función: maximize_sx (<obj>, <cond>, [<pos>])
569
Maximiza la función objetivo lineal <obj> sujeta a ciertas
570
restricciones lineales <cond>. Véase `minimize_sx' para una
571
descripción detallada de los argumentos y de la respuesta dada por
575
-- Función: minimize_sx (<obj>, <cond>, [<pos>])
576
Minimiza la función objetivo lineal <obj> sujeta a ciertas
577
restricciones lineales <cond>, siendo ésta una lista de ecuaciones
578
o inecuaciones lineales. En las inecuaciones estrictas se
579
reemplaza `>' por `>=' y `<' por `<='. El argumento opcional <pos>
580
es una lista de variables de decisión que se suponen positivas.
582
Si el mínimo existe, `minimize_sx' devuelve una lista que contiene
583
el valor mínimo de la función objetivo y una lista de valores para
584
las variables de decisión con los que se alcanza el mínimo. Si el
585
problema no está acotado, devuelve el mensaje "Problem not
586
bounded!" y si el problema no es factible, devuelve el mensaje
587
"Problem not feasible!".
589
Las variables de decisión no se suponen no negativas. Si todas las
590
variables de decisión son no negativas, asígnese el valor `true' a
591
la variable `nonegative_sx'. Si sólo algunas de las variables de
592
decisión son positivas, lístense en el argumento opcional <pos>,
593
lo cual es más eficiente que añadir restricciones.
595
La función `minimize_sx' utiliza el algoritmo simplex implementado
596
en la función `linear_program' de Maxima.
598
Para usar esta función, cárguese primero el paquete con la
599
instrucción `load(simplex);'.
603
(%i1) minimize_sx(x+y, [3*x+y=0, x+2*y>2]);
604
(%o1) minimize_sx(y + x, [y + 3 x = 0, 2 y + x > 2])
605
(%i2) minimize_sx(x+y, [3*x+y>0, x+2*y>2]), nonegative_sx=true;
606
(%o2) minimize_sx(y + x, [y + 3 x > 0, 2 y + x > 2])
607
(%i3) minimize_sx(x+y, [3*x+y=0, x+2*y>2]), nonegative_sx=true;
608
(%o3) minimize_sx(y + x, [y + 3 x = 0, 2 y + x > 2])
609
(%i4) minimize_sx(x+y, [3*x+y>0]);
610
(%o4) minimize_sx(y + x, [y + 3 x > 0])
612
Véanse también `maximize_sx', `nonegative_sx' y `epsilon_sx'.
615
-- Variable opcional: nonegative_sx
616
Valor por defecto: `false'
618
Si `nonegative_sx' vale `true' todas las variables de decisión
619
pasadas a `minimize_sx' y a `maximize_sx' se suponen positivas.
621
Véase también `minimize_sx'.
625
File: maxima.info, Node: simplification, Next: solve_rec, Prev: simplex, Up: Top
632
* Introducción a simplification::
633
* Definiciones para simplification::
636
File: maxima.info, Node: Introducción a simplification, Next: Definiciones para simplification, Prev: simplification, Up: simplification
638
64.1 Introducción a simplification
639
==================================
641
El directorio `maxima/share/simplification' contiene programas que
642
implementan algunas reglas y funciones para simplificar expresiones,
643
así como ciertas funciones no relacionadas con la simplificación.
646
File: maxima.info, Node: Definiciones para simplification, Prev: Introducción a simplification, Up: simplification
648
64.2 Definiciones para simplification
649
=====================================
651
64.2.1 Paquete absimp
652
---------------------
654
El paquete `absimp' contiene reglas para aplicar patrones que extienden
655
el sistema de reglas nativo de Maxima para las funciones `abs' y
656
`signum', respetando las relaciones establecidas con la función
657
`assume' o con declaraciones tales como `modedeclare (m, even, n, odd)'
658
para enteros pares o impares.
660
En el paquete `absimp' se definen las funciones `unitramp' y
661
`unitstep' en términos de `abs' y `signum'.
663
La instrucción `load (absimp)' carga este paquete y `demo (absimp)'
664
desarrolla una demostración sobre el uso del mismo.
672
(%i3) diff (abs (x), x);
676
(%i4) cosh (abs (x));
679
64.2.2 Paquete facexp
680
---------------------
682
El paquete `facexp' contiene varias funciones que le aportan al usuario
683
la posibilidad de estructurar expresiones controlando su expansión.
684
Esta capacidad es especialmente útil cuando la expresión contiene
685
variables con significado físico, ya que se suele dar el caso de que la
686
forma más sencilla para estas expresiones se obtiene cuando se expanden
687
respecto de estas variables y luego se factoriza respecto de sus
688
coeficientes. Si bien es cierto que este procedimiento no es difícil de
689
llevar a cabo con las funciones estándar de Maxima, pueden ser
690
necesarios algunos retoques adicionales que sí pueden ser más difíciles
693
La función `facsum' y sus formas relacionadas proporcionan un método
694
para controlar la estructura de expresiones. La función `collectterms'
695
puede usarse para añadir dos o más expresiones que ya hayan sido
696
simplificadas de la forma indicada, sin necesidad de volver a
697
simplificar la expresión completa. Esta función puede ser útil cuando
698
las expresiones sean largas.
700
La instrucción `load (facexp)' carga este paquete y `demo (facexp)'
701
hace una demostración sobre su uso.
703
-- Función: facsum (<expr>, <arg_1>, ..., <arg_n>)
704
Devuelve una expresión equivalente a <expr>, la cual depende de
705
los argumentos <arg_1>, ..., <arg_n>, y éstos pueden ser de
706
cualquiera de las formas aceptables para `ratvars', o listas de
707
estas formas. Si los argumentos no son listas, la forma devuelta
708
se expande completamente con respecto de los argumentos, siendo los
709
coeficientes de tales argumentos factorizados. Estos coeficientes
710
no contienen a ninguno de los argumentos, excepto quizás de una
713
En caso de que cualquiera de los argumentos sea una lista, entonces
714
todos ellos se combinan en una única lista, y en lugar de llamar a
715
`factor' para los coeficientes de los argumentos, `facsum' se
716
llama a sí misma utilizando esta nueva lista única como lista de
719
Es posible que se quiera utilizar `facsum' con respecto a
720
expresiones más complicadas, tales como `log (x + y)'. Estos
721
argumentos son también admisibles. Si no se especifican variables,
722
como en `facsum (<expr>)', el resultado devuelto es el mismo que
723
el conseguido mediante `ratsimp (<expr>)'.
725
En ocasiones puede ser necesario obtener cualquiera de las formas
726
anteriores especificadas por sus operadores principales. Por
727
ejemplo, se puede querer aplicar `facsum' con respecto a todos los
728
`log'; en este caso, se puede incluir entre los argumentos bien
729
los `log' específicos que se quieran tratar de esta manera, bien
730
la expresión `operator (log)' o `'operator (log)'. Si se quiere
731
aplicar `facsum' a <expr> con respecto a los operadores <op_1>,
732
..., <op_n>, se debe evaluar `facsum (<expr>, operator (<op_1>,
733
..., <op_n>))'. La forma `operator' puede aparecer también dentro
734
de las listas de argumentos.
736
Además, dándole valores a las variables opcionales `facsum_combine'
737
y `nextlayerfactor' se puede controlar el resultado de `facsum'.
739
-- Variable global: nextlayerfactor
740
Valor por defecto: `false'
742
Si `nextlayerfactor' vale `true', las llamadas recursivas de
743
`facsum' se aplican a los factores de la forma factorizada de los
744
coeficientes de los argumentos.
746
Si vale `false', `facsum' se aplica a cada coeficiente como un
747
todo cada vez que se efectúen llamadas recursivas a `facsum'.
749
La inclusión del átomo `nextlayerfactor' en la lista de argumentos
750
de `facsum' tiene el mismo efecto que `nextlayerfactor: true',
751
pero solamente para el siguiente nivel de la expresión. Puesto que
752
`nextlayerfactor' toma siempre uno de los valores `true' o
753
`false', debe aparecer comentado (comilla simple) cada vez que
754
aparezca en la lista de argumentos de `facsum'.
756
-- Variable global: facsum_combine
757
Valor por defecto: `true'
759
La variable `facsum_combine' controla la forma del resultado final
760
devuelto por `facsum' si su argumento es un cociente de polinomios.
761
Si `facsum_combine' vale `false', el resultado será una suma
762
completamente expandida, pero si vale `true', la expresión devuelta
763
es un cociente de polinomios.
766
-- Función: factorfacsum (<expr>, <arg_1>, ... <arg_n>)
767
Devuelve una expresión equivalente a <expr> obtenida aplicando
768
`facsum' a los factores de <expr>, de argumentos <arg_1>, ...
769
<arg_n>. Si alguno de los factores de <expr> se eleva a una
770
potencia, tanto el factor como el exponente se procesarán de esta
773
-- Función: collectterms (<arg_1>, ..., <arg_n>)
774
Si algunas expresiones fueron ya simplificadas con `facsum',
775
`factorfacsum', `factenexpand', `facexpten' o `factorfacexpten',
776
debiendo ser luego sumadas, puede ser conveniente combinarlas
777
utilizando la función `collecterms', la cual admite como
778
argumentos todos aquéllos que se puedan pasar a las anteriormente
779
citadas funciones, con la excepción de `nextlayerfactor', que no
780
tiene efecto alguno sobre `collectterms'. La ventaja de
781
`collectterms' es que devuelve una forma similar a la de `facsum',
782
pero debido a que suma expresiones que ya han sido previamente
783
procesadas, no necesita repetir esta operación, lo cual resulta
784
ser especialmente útil cuando las expresiones a sumar son muy
787
64.2.3 Paquete functs
788
---------------------
790
-- Función: rempart (<expr>, <n>)
791
Elimina la parte <n> de la expresión <expr>.
793
Si <n> es una lista de la forma `[<l>, <m>]', entonces las partes
794
desde <l> a <m> serán eliminadas.
796
Para hacer uso de esta función ejecutar `load(functs)'.
798
-- Función: wronskian ([<f_1>, ..., <f_n>], <x>)
799
Devuelve la matriz wronskiana de las funciones <f_1>, ..., <f_n>
800
dependeientes de la variable <x>.
802
Los argumentos <f_1>, ..., <f_n> pueden ser nombres de funciones
803
definidas por el usuario, o expresiones de variable <x>.
805
El determinante de la matriz wronskiana es el determinante
806
wronskiano del conjunto de funciones. Las funciones serán
807
linealmente dependientes si este determinante es nulo.
809
Para hacer uso de esta función ejecutar `load(functs)'.
811
-- Función: tracematrix (<M>)
812
Devuelve la traza (suma de los elementos de la diagonal) de la
815
Para hacer uso de esta función ejecutar `load(functs)'.
817
-- Función: rational (<z>)
818
Multiplica el numerador y denominador de <z> por el complejo
819
conjugado del denominador, racionalizando así el denominador.
820
Devuelve la expresión canónica racional (canonical rational
821
expression, CRE) si el argumento <z> es de esta forma, en caso
822
contrario devuelve una expresión en formato común.
824
Para hacer uso de esta función ejecutar `load(functs)'.
826
-- Función: logand (<x>,<y>)
827
Devuelve el "y" lógico binario de los argumentos <x> e <y>.
829
Para hacer uso de esta función ejecutar `load(functs)'.
831
-- Función: logor (<x>,<y>)
832
Devuelve el "o" lógico binario de los argumentos <x> e <y>.
834
Para hacer uso de esta función ejecutar `load(functs)'.
836
-- Función: logxor (<x>,<y>)
837
Devuelve el "o-excusivo" lógico binario de los argumentos <x> e
840
Para hacer uso de esta función ejecutar `load(functs)'.
842
-- Función: nonzeroandfreeof (<x>, <expr>)
843
Devuelve `true' si <expr> es diferente de cero y `freeof (<x>,
844
<expr>)' devuelve `true'. En caso contrario devuelve `false'.
846
Para hacer uso de esta función ejecutar `load(functs)'.
848
-- Función: linear (<expr>, <x>)
849
Si <expr> es una expresión lineal respecto de la variable <x>,
850
`linear' devuelve `<a>*<x> + <b>', siendo <a> no nula y, junto con
851
<b>, no incluye a <x>. En otro caso, `linear' devuelve <expr>.
853
Para hacer uso de esta función ejecutar `load(functs)'.
855
-- Función: gcdivide (<p>, <q>)
856
Si `takegcd' vale `true', `gcdivide' divide los polinomios <p> y
857
<q> por su máximo común divisor y devuelve el cociente de los
860
Si `takegcd' vale `false', `gcdivide' devuelve el cociente
863
Para hacer uso de esta función ejecutar `load(functs)'.
865
-- Función: arithmetic (<a>, <d>, <n>)
866
Devuelve el <n>-ésimo término de la progresión aritmética `<a>,
867
<a> + <d>, <a> + 2*<d>, ..., <a> + (<n> - 1)*<d>'.
869
Para hacer uso de esta función ejecutar `load(functs)'.
871
-- Función: geometric (<a>, <r>, <n>)
872
Devuelve el <n>-ésimo término de la progresión geométrica `<a>,
873
<a>*<r>, <a>*<r>^2, ..., <a>*<r>^(<n> - 1)'.
875
Para hacer uso de esta función ejecutar `load(functs)'.
877
-- Función: harmonic (<a>, <b>, <c>, <n>)
878
Devuelve el <n>-ésimo término de la progresión armónica `<a>/<b>,
879
<a>/(<b> + <c>), <a>/(<b> + 2*<c>), ..., <a>/(<b> + (<n> -
882
Para hacer uso de esta función ejecutar `load(functs)'.
884
-- Función: arithsum (<a>, <d>, <n>)
885
Devuelve la suma de la progresión aritmética desde hasta el
888
Para hacer uso de esta función ejecutar `load(functs)'.
890
-- Función: geosum (<a>, <r>, <n>)
891
Devuelve la suma de la sucesión geométrica hasta el <n>-ésimo
892
término. Si <n> es infinito (`inf') la suma será finita sólo si
893
el valor absoluto de <r> es menor que 1.
895
Para hacer uso de esta función ejecutar `load(functs)'.
897
-- Función: gaussprob (<x>)
898
Devuelve la función de densidad de probabilidad, normal
899
`%e^(-<x>^2/2) / sqrt(2*%pi)'.
901
Para hacer uso de esta función ejecutar `load(functs)'.
904
Devuelve la función de Gudermann, `2 * atan(%e^<x> - %pi/2)'.
906
Para hacer uso de esta función ejecutar `load(functs)'.
908
-- Función: agd (<x>)
909
Devuelve la inversa de la función de Gudermann, `log (tan (%pi/4 +
912
Para hacer uso de esta función ejecutar `load(functs)'.
914
-- Función: vers (<x>)
915
Devuelve `1 - cos (x)'.
917
Para hacer uso de esta función ejecutar `load(functs)'.
919
-- Función: covers (<x>)
920
Devuelve `1 - sin (<x>)'.
922
Para hacer uso de esta función ejecutar `load(functs)'.
924
-- Función: exsec (<x>)
925
Devuelve `sec (<x>) - 1'.
927
Para hacer uso de esta función ejecutar `load(functs)'.
929
-- Función: hav (<x>)
930
Devuelve `(1 - cos(x))/2'.
932
Para hacer uso de esta función ejecutar `load(functs)'.
934
-- Función: combination (<n>, <r>)
935
Calcula el número de combinaciones de <n> objetos tomados de <r>
938
Para hacer uso de esta función ejecutar `load(functs)'.
940
-- Función: permutation (<n>, <r>)
941
Calcula el número de permutaciones de <r>, seleccionados de un
944
Para hacer uso de esta función ejecutar `load(functs)'.
949
El paquete `ineq' contiene reglas de simplificación para desigualdades
951
Una sesión de ejemplo:
954
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
955
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
956
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
957
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
958
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
959
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
960
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
961
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
962
(%i2) a>=4; /* a sample inequality */
964
(%i3) (b>c)+%; /* add a second, strict inequality */
966
(%i4) 7*(x<y); /* multiply by a positive number */
968
(%i5) -2*(x>=3*z); /* multiply by a negative number */
970
(%i6) (1+a^2)*(1/(1+a^2)<=1); /* Maxima knows that 1+a^2 > 0 */
973
(%i7) assume(x>0)$ x*(2<3); /* assuming x>0 */
975
(%i8) a>=b; /* another inequality */
977
(%i9) 3+%; /* add something */
979
(%i10) %-3; /* subtract it out */
981
(%i11) a>=c-b; /* yet another inequality */
983
(%i12) b+%; /* add b to both sides */
985
(%i13) %-c; /* subtract c from both sides */
986
(%o13) - c + b + a >= 0
987
(%i14) -%; /* multiply by -1 */
988
(%o14) c - b - a <= 0
989
(%i15) (z-1)^2>-2*z; /* determining truth of assertion */
991
(%o15) (z - 1) > - 2 z
992
(%i16) expand(%)+2*z; /* expand this and add 2*z to both sides */
998
Debe tenerse cuidado con el uso de paréntesis que incluyan
999
desigualdades; si se escribe `(A > B) + (C = 5)' el resultado es `A + C
1000
> B + 5', pero `A > B + C = 5' es un error sintáctico y `(A > B + C) =
1001
5' es una cosa completamente diferente.
1003
Ejecútese `disprule (all)' para ver la lista completa de las reglas
1006
Maxima preguntará al usuario cuando desconozca el signo de una
1007
cantidad que multiplica a una desigualdad.
1009
Los fallos más comunes son:
1015
Otro problema es el producto de una desigualdad por cero. Si se
1016
escribe `x*<some_inequality>' y Maxima pregunta por el signo de `x' y
1017
se responde que vale `zero' (o `z'), el programa devuelve
1018
`x*<some_inequality>' sin hacer uso de la información de que `x' es 0.
1019
En tal caso se debería escribir `ev (%, x: 0)', ya que la base de datos
1020
sólo será utilizada para fines comparativos y no para evaluar `x'.
1022
El usuario puede apreciar que las respuestas son más lentas al
1023
cargarse este paquete, ya que el simplificador deberá examinar más
1024
reglas que cuando no se hace uso del paquete, por lo que puede ser
1025
conveniente borrar estas reglas cuando ya no se haga uso de ellas.
1026
Ejecútese `kill (rules)' para eliminar todas las reglas (incluidas las
1027
definidas por el usuario); también es posible eliminar parte de ellas o
1028
utilizar `remrule' sobre una reglas específica.
1030
Nótese que si se carga este paquete después de haber definido otras
1031
reglas de igual nombre,se borrarán las antiguas. Las reglas de este
1032
paquete son: `*rule1', ..., `*rule8', `+rule1', ..., `+rule18',
1033
debiéndose encerrar entre comillas el nombre de la reglas para
1034
referenciarse a ellas, como en `remrule ("+", "+rule1")' para eliminar
1035
la primera regla sobre `"+"', o `disprule ("*rule2")' para mostrar la
1036
definición de la segunda regla multiplicativa.
1038
64.2.5 Paquete rducon
1039
---------------------
1041
-- Función: reduce_consts (<expr>)
1042
Sustituye subexpresiones constantes de <expr> por átomos,
1043
guardando la definición de todos ellos en la lista de ecuaciones
1044
`const_eqns' y devolviendo el expresión <expr> ya modificada. Se
1045
consideran partes constantes de <expr> aquellas que devuelven
1046
`true' cuando se les aplica la función `constantp', por lo que
1047
antes de llamar a `reduce_consts' se debe ejecutar
1049
declare ([<objetos a los que se quiera dar la propiedad de ser constantes>], constant)$
1051
para crear la base de datos de las cantidades constantes presentes
1054
Si se pretende generar código Fortran después de estos cálculos
1055
simbólicos, una de las primeras secciones del código debe ser el
1056
cálculo de las constantes. Para generar este segmento de código
1059
map ('fortran, const_eqns)$
1061
Junto a `const_eqns', otras variables que afectan a
1062
`reduce_consts' son:
1064
`const_prefix' (Valor por defecto: `xx') es la cadena de
1065
caracteres utilizada como prefijo para todos los símbolos
1066
generados por `reduce_consts' para representar subexpresiones
1069
`const_counter' (Valor por defecto: 1) es el índice entero
1070
utilizado para generar los símbolos que representen a las
1071
subexpresiones constantes encontradas por `reduce_consts'.
1073
La instrucción `load (rducon)' carga esta función y `demo (rducon)'
1074
hace una demostración sobre su uso.
1076
64.2.6 Paquete scifac
1077
---------------------
1079
-- Función: gcfac (<expr>)
1080
Es una función de factorización que intenta aplicar la misma
1081
heurística que los humanos cuando tratan de hacer las expresiones
1082
más simples, limitándose a la factorización de monomios. En caso
1083
de sumas, `gcfac' hace lo siguiente:
1085
1. Factoriza los enteros.
1087
2. Factoriza las potencias mayores de los términos que aparecen
1088
como coeficientes, independientemente de su complejidad.
1090
3. Utiliza (1) y (2) en la factorización de pares de términos
1093
4. Aplica estas técnicas repetida y recursivamente hasta que la
1094
expresión deje de sufrir cambios.
1096
En general, el apartado (3) no hace una factorización óptima
1097
debido a la naturaleza combinatoria y compleja de encontrar cuál
1098
de todas las ordenaciones posibles de los pares da lugar a la
1099
expresión más compacta.
1101
La instrucción `load (scifac)' carga esta función y `demo (scifac)'
1102
hace una demostración sobre su uso.
1104
64.2.7 Paquete sqdnst
1105
---------------------
1107
-- Función: sqrtdenest (<expr>)
1108
Reduce expresiones en las que se encuentren raíces cuadradas
1109
anidadas, siempre que sea posible
1113
(%i1) load (sqdnst)$
1114
(%i2) sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
1118
(%o2) ---------------------
1119
sqrt(11 sqrt(2) - 12)
1120
(%i3) sqrtdenest(%);
1128
A veces conviene aplicar `sqrtdenest' más de una vez, como en el
1129
caso `(19601-13860 sqrt(2))^(7/4)'.
1131
La sentencia `load (sqdnst)' carga esta función.
1134
File: maxima.info, Node: solve_rec, Next: stirling, Prev: simplification, Up: Top
1141
* Introducción a solve_rec::
1142
* Definiciones para solve_rec::
1145
File: maxima.info, Node: Introducción a solve_rec, Next: Definiciones para solve_rec, Prev: solve_rec, Up: solve_rec
1147
65.1 Introducción a solve_rec
1148
=============================
1150
El paquete `solve_rec' resuelve expresiones recurrentes lineales con
1151
coeficientes polinomiales.
1153
Ejecútese `demo(solve_rec);' para ver una demostración sobre la
1154
utilización de este paquete.
1158
(%i1) load("solve_rec")$
1159
(%i2) solve_rec((n+4)*s[n+2] + s[n+1] - (n+1)*s[n], s[n]);
1161
%k (2 n + 3) (- 1) %k
1163
(%o2) s = -------------------- + ---------------
1164
n (n + 1) (n + 2) (n + 1) (n + 2)
1167
File: maxima.info, Node: Definiciones para solve_rec, Prev: Introducción a solve_rec, Up: solve_rec
1169
65.2 Definiciones para solve_rec
1170
================================
1172
-- Función: closed_form (<expr>)
1173
Intenta reducir todas las sumas que aparecen en <expr> a una forma
1174
cerrada. La función `closed_form' utiliza los algoritmos de Gosper
1175
y Zeilberger para reducir las sumas.
1177
Para utilizar esta función cárguese previamente el paquete
1178
`closed_form' ejecutando la instrucción `load(closed_form)'.
1182
(%i1) load("closed_form")$
1183
(%i2) sum(binom(n+k,k)/2^k, k, 0, n) + sum(binom(2*n, 2*k), k, 0, n);
1186
\ binomial(n + k, k) \
1187
(%o2) > ------------------ + > binomial(2 n, 2 k)
1191
(%i3) closed_form(%);
1198
-- Función: reduce_order (<rec>, <sol>, <var>)
1199
Reduce el orden de la expresión recurrente lineal <rec> cuando se
1200
conoce una solución particular <sol>. La recurrencia reducida
1201
puede utilizarse para obterner más soluciones.
1205
(%i3) rec: x[n+2] = x[n+1] + x[n]/n;
1210
(%i4) solve_rec(rec, x[n]);
1211
WARNING: found some hypergeometrical solutions!
1214
(%i5) reduce_order(rec, n, x[n]);
1226
(%o6) (- n - 2) %u - %u
1228
(%i6) solve_rec((n+2)*%u[n+1] + %u[n], %u[n]);
1232
(%o6) %u = ----------
1235
So the general solution is
1240
%k n > -------- + %k n
1246
-- Variable opcional: simplify_products
1247
Valor por defecto: `true'
1249
Si `simplify_products' vale `true', `solve_rec' intentará
1250
simplificar los productos del resultado.
1252
Véase también `solve_rec'.
1255
-- Función: solve_rec (<eqn>, <var>, [<init>])
1256
Obtiene las soluciones hipergeométricas de la expresión recurrente
1257
<eqn> con coeficientes lineales en la variable <var>. Los
1258
argumentos opcionales <init> son condiciones iniciales.
1260
La función `solve_rec' puede resolver expresiones recurrentes con
1261
coeficientes constantes, encuentra soluciones hipergeométricas de
1262
expresiones recurrentes lineales homogéneas con coeficientes
1263
polinomiales, obtiene soluciones racionales de expresiones
1264
recurrentes lineales con coeficientes lineales y resuelve también
1265
expresiones recurrentes de Ricatti.
1267
Nótese que el tiempo de ejecución del algoritmo para encontrar
1268
soluciones hipergeométricas es exponencial respecto del grado del
1269
coeficiente principal.
1271
Para hacer uso de esta función ejecútese previamente
1274
Ejemplo de recurrencia lineal con coeficientes constantes:
1276
(%i2) solve_rec(a[n]=a[n-1]+a[n-2]+n/2^n, a[n]);
1278
(sqrt(5) - 1) %k (- 1)
1280
(%o2) a = ------------------------- - ----
1286
+ ------------------ - ----
1290
Ejemplo de recurrencia lineal con coeficientes polinomiales:
1292
(%i7) 2*x*(x+1)*y[x] - (x^2+3*x-2)*y[x+1] + (x-1)*y[x+2];
1294
(%o7) (x - 1) y - (x + 3 x - 2) y + 2 x (x + 1) y
1296
(%i8) solve_rec(%, y[x], y[1]=1, y[3]=3);
1302
Ejemplo de recurrencia de Ricatti:
1304
(%i2) x*y[x+1]*y[x] - y[x+1]/(x+2) + y[x]/(x-1) = 0;
1307
(%o2) x y y - ------ + ----- = 0
1309
(%i3) solve_rec(%, y[x], y[3]=5)$
1310
(%i4) ratsimp(minfactorial(factcomb(%)));
1313
(%o4) y = - -------------------------------------------------
1315
5 x - 3 x - 25 x + 15 x + 20 x - 12 x - 1584
1317
Véanse también `solve_rec_rat', `simplify_products' y
1318
`product_use_gamma'.
1321
-- Función: solve_rec_rat (<eqn>, <var>, [<init>])
1322
Calcula las soluciones racionales de las expresiones recurrentes
1323
lineales. Véase `solve_rec' para la descripción de sus argumentos.
1325
Para hacer uso de esta función ejecútese previamente
1330
(%i1) (x+4)*a[x+3] + (x+3)*a[x+2] - x*a[x+1] + (x^2-1)*a[x];
1331
(%o1) (x + 4) a + (x + 3) a - x a
1336
(%i2) solve_rec_rat(% = (x+2)/(x+1), a[x]);
1338
(%o2) a = ---------------
1341
Véase también `solve_rec'.
1344
-- Variable opcional: product_use_gamma
1345
Valor por defecto:`true'
1347
Si `product_use_gamma' vale `true', `solve_rec' introduce la
1348
función gamma en la expresión del resultado cuando se simplifican
1351
Véanse también `simplify_products' y `solve_rec'.
1354
-- Función: summand_to_rec (<summand>, <k>, <n>)
1355
Devuelve la expresión recurrente que satisface la suma
1365
donde el sumando es hipergeométrico en <k> y <n>.
1367
Para hacer uso de esta función deben cargarse previamente los
1368
paquetes `zeilberger' y `solve_rec' mediante la ejecución de las
1369
sentencias `load(solve_rec)' y `load(zeilberger)'.
1371
(%i17) load("zeilberger")$
1372
(%i18) summand: binom(3*k+1,k)*binom(3*(n-k),n-k)/(3*k+1)$
1373
(%i19) summand_to_rec(summand, k, n);
1374
Dependent equations eliminated: (3 2)
1375
(%o19) - 4 (n + 2) (2 n + 3) (2 n + 5) sm
1378
+ 12 (2 n + 3) (9 n + 27 n + 22) sm
1380
- 81 (n + 1) (3 n + 2) (3 n + 4) sm
1382
(%i21) sum(''summand, k, 0, n), n=0;
1384
(%i22) sum(''summand, k, 0, n), n=1;
1386
(%i23) product_use_gamma: false$
1387
(%i24) solve_rec(%o19, sm[n], sm[0]=1, sm[1]=4);
1391
( ! ! (3 %j + 2)) ( ! ! (3 %j + 4)) 3
1394
(%o24) sm = ------------------------------------------
1398
( ! ! (2 %j + 3)) 2 n!
1404
File: maxima.info, Node: stirling, Next: stringproc, Prev: solve_rec, Up: Top
1411
* Definiciones para stirling::
1414
File: maxima.info, Node: Definiciones para stirling, Prev: stirling, Up: stirling
1416
66.1 Definiciones para stirling
1417
===============================
1419
-- Función: stirling (<z>,<n>)
1420
Sustituye `gamma(x)' por la fórmula de Stirling O(1/x^(2n-1)). Si
1421
<n> no es un entero no negativo, emite un mensaje de error.
1423
Referencia: Abramowitz & Stegun, " Handbook of mathematical
1427
(%i1) load (stirling)$
1429
(%i2) stirling(gamma(%alpha+x)/gamma(x),1);
1430
1/2 - x x + %alpha - 1/2
1431
(%o2) x (x + %alpha)
1433
--------------- - ---- - %alpha
1434
12 (x + %alpha) 12 x
1436
(%i3) taylor(%,x,inf,1);
1438
%alpha x %alpha - x %alpha
1439
(%o3)/T/ x + -------------------------------- + . . .
1441
(%i4) map('factor,%);
1443
%alpha (%alpha - 1) %alpha x
1444
(%o4) x + -------------------------------
1447
La función `stirling' conoce la diferencia existente entre la
1448
variable 'gamma' y la función gamma:
1450
(%i5) stirling(gamma + gamma(x),0);
1452
(%o5) gamma + sqrt(2) sqrt(%pi) x %e
1453
(%i6) stirling(gamma(y) + gamma(x),0);
1455
(%o6) sqrt(2) sqrt(%pi) y %e
1457
+ sqrt(2) sqrt(%pi) x %e
1459
Antes de hacer uso de esta función ejecútese `load("stirling")'.
1462
File: maxima.info, Node: stringproc, Next: unit, Prev: stirling, Up: Top
1469
* Introducción al procesamiento de cadenas::
1470
* Definiciones para entrada y salida::
1471
* Definiciones para caracteres::
1472
* Definiciones para cadenas::
1475
File: maxima.info, Node: Introducción al procesamiento de cadenas, Next: Definiciones para entrada y salida, Prev: stringproc, Up: stringproc
1477
67.1 Introducción al procesamiento de cadenas
1478
=============================================
1480
El paquete `stringproc' amplía las capacidades de Maxima para manipular
1481
cadenas de caracteres; para cargarlo basta con ejecutar la sentencia
1482
`load("stringproc")'.
1484
En Maxima, una cadena de caracteres se construye fácilmente
1485
escribiéndola entre comillas dobles (`"'). Téngase en cuenta que las
1486
cadenas de Maxima no son cadenas de Lisp, pudiéndose ejecutar las
1487
funciones de chequeo `stringp' y `lstringp' con el fin de dilucidar qué
1488
tipo de cadena es su argumento. Si por cualquier motivo el usuario
1489
tiene una cadena de Lisp y la quiere convertir a una cadena de Maxima
1490
habrá de utilizar la función conversora `sunlisp'.
1492
(%i1) load("stringproc")$
1495
(%i3) [stringp(m),lstringp(m)];
1497
(%i4) l: sconcat("text");
1499
(%i5) [stringp(l),lstringp(l)];
1501
(%i6) stringp( sunlisp(l) );
1504
Todas las cadenas devueltas por las funciones de `stringproc' son
1507
Los caracteres individuales se introducen como cadenas de Maxima de
1508
longitud igual a la unidad. Estos caracteres no son caracteres de Lisp
1509
y se pueden chequear con las funciones `charp' y `lcharp', pudiéndose
1510
convertir los caracteres de Lisp a Maxima mediante `cunlisp'.
1512
(%i1) load("stringproc")$
1515
(%i3) [charp(c),lcharp(c)];
1522
Todos los caracteres devueltos por las funciones de `stringproc' son
1523
caracteres de Maxima. Puesto que los caracteres introducidos son
1524
cadenas de longitud igual a la unidad, se pueden utilizar las funciones
1525
de cadenas también para los caracteres, como se ha hecho con `supcase'
1526
en el anterior ejemplo.
1528
Es importante tener en cuenta que el primer carácter en una cadena
1529
de Maxima ocupa la posición 1. Esto se ha diseñado así para mantener la
1530
compatibilidad con las listas de Maxima. Véanse las definiciones de
1531
`charat' y `charlist' para ver ejemplos.
1533
Las funciones de cadenas se utilizan frecuentemente cuando se
1534
trabaja con ficheros. El paquete `stringproc' dispone de algunas
1535
funciones de escritura que pueden ser útiles. Por ejemplo, si un
1536
fichero contiene instrucciones de entrada y salidas de Maxima, la
1537
función `extracti' extrae los valores de todas las etiquetas de entrada
1538
para un fichero que puede ser leído por Maxima y cuya ruta es devuelta
1539
por la función. El fichero podrá ser ejecutado inmediatamente con
1540
`batch(%)'. Nótese que `extracti' falla si al menos una de las
1541
etiquetas está dañada, quizás debido a haber borrado `).', o si algunas
1542
entradas procedían de la lectura de ficheros externos (mediante
1543
`batch'), o si existen caracteres más allá de los símbolos de
1544
terminación de sentencia `;' o `$'.
1546
extracti(file):= block(
1547
[ s1: openr(file), ifile: sconc(file,".in"), line, nl: false ],
1550
while ( stringp(line: readline(s1)) ) do (
1551
if ssearch( sconc("(",inchar),line ) = 1 then (
1552
line: strim(" ",substring( line,ssearch(")",line)+1 )),
1553
printf( s2,"~a~%",line ),
1556
line: strimr(" ",line),
1557
printf( s2,"~a~%",line ),
1560
close(s1), close(s2),
1563
checklast(line):= block(
1564
[ last: charat( line,slength(line) ) ],
1565
if cequal(last,";") or cequal(last,"$") then
1566
nl:false else nl:true )$
1568
Contenido del fichero 'C:\home\maxima\test.out':
1570
(%i1) f(x):= sin(x)$
1574
(%o3) df(x) := cos(x)
1580
(%i11) extracti("C:\\home\\maxima\\test.out");
1581
(%o11) C:\home\maxima\test.out.in
1584
batching #pC:/home/maxima/test.out.in
1585
(%i13) f(x) := sin(x)
1586
(%i14) diff(f(x), x)
1588
(%i15) df(x) := cos(x)
1589
(%o15) df(x) := cos(x)
1594
File: maxima.info, Node: Definiciones para entrada y salida, Next: Definiciones para caracteres, Prev: Introducción al procesamiento de cadenas, Up: stringproc
1596
67.2 Definiciones para entrada y salida
1597
=======================================
1601
(%i1) s: openw("C:\\home\\file.txt");
1602
(%o1) #<output stream C:\home\file.txt>
1603
(%i2) control: "~2tAn atom: ~20t~a~%~2tand a list: ~20t~{~r ~}~%~2tand an integer: ~20t~d~%"$
1604
(%i3) printf( s,control, 'true,[1,2,3],42 )$
1608
(%i5) s: openr("C:\\home\\file.txt");
1609
(%o5) #<input stream C:\home\file.txt>
1610
(%i6) while stringp( tmp:readline(s) ) do print(tmp)$
1612
and a list: one two three
1616
-- Función: close (<stream>)
1617
Cierra el flujo de datos <stream> y devuelve `true' si <stream>
1621
-- Función: flength (<stream>)
1622
Devuelve el número de elementos en el flujo de datos <stream>.
1625
-- Función: fposition (<stream>)
1626
-- Función: fposition (<stream>, <pos>)
1627
Devuelve la posición actual en el flujo de datos <stream> si no se
1628
utiliza <pos>. Si se utiliza <pos>, `fposition' ajusta la
1629
posición en <stream>. El argumento <pos> debe ser un número
1630
positivo, ocupando el primer elemento en <stream> la posición 1.
1633
-- Función: freshline ()
1634
-- Función: freshline (<stream>)
1635
Escribe una nueva línea en el flujo de datos <stream> si la
1636
posición actual no corresponde al inicio de la línea. La función
1637
`freshline' no trabaja correctamente con los flujos de datos
1641
-- Función: newline ()
1642
-- Función: newline (<stream>)
1643
Escribe una nueva línea en el flujo de datos <stream>. La
1644
función `freshline' no trabaja correctamente con los flujos de
1645
datos `true' y `false'. Véase `sprint' para un ejemplo de
1646
utilización de `newline'.
1649
-- Función: opena (<file>)
1650
Devuelve un flujo de datos al fichero <file>. Si se abre un
1651
fichero ya existente, `opena' añade elementos al final del fichero.
1654
-- Función: openr (<file>)
1655
Devuelve un flujo de datos de entrada al fichero <file>. Si
1656
<file> no existe, será creado.
1658
-- Función: openw (<file>)
1659
Devuelve un flujo de datos de salida al fichero <file>. Si <file>
1660
no existe, será creado. Si se abre un fichero ya existente,
1661
`openw' lo modifica borrando el contenido anterior.
1663
-- Función: printf (<dest>, <string>)
1664
-- Función: printf (<dest>, <string>, <expr_1>, ..., <expr_n>)
1665
La función `printf' se comporta de forma similar a la de FORMAT en
1666
Common Lisp. Véanse las referencias de Lisp para más información.
1667
Téngase en cuenta que hay alhunas directivas que funcionan en
1668
Lisp, pero no en Maxima. Por ejemplo, `~:[' falla.
1670
La función `printf' ha sido diseñada para que `~s' se interprete
1671
igual que `~a'. Además la directiva de selección `~[' se indexa a
1675
~& línea de refresco
1678
~d entero en base decimal
1679
~b entero en base binaria
1680
~o entero en base octal
1681
~x entero en base hexadecimal
1682
~br entero en base b
1683
~r deletrea un entero
1685
~f decimal en coma flotante
1686
~e notación científica
1687
~g ~f o ~e, dependiendo de la magnitud
1688
~a tal como imprime la función de Maxima `print'
1691
~< justificación, ~> termina
1692
~( conversor mayúscula/minúscula, ~) termina
1693
~[ selección, ~] termina
1694
~{ iteración, ~} termina
1696
(%i1) printf( false, "~s ~a ~4f ~a ~@r",
1697
"String",sym,bound,sqrt(8),144), bound = 1.234;
1698
(%o1) String sym 1.23 2*sqrt(2) CXLIV
1699
(%i2) printf( false,"~{~a ~}",["one",2,"THREE"] );
1701
(%i3) printf( true,"~{~{~9,1f ~}~%~}",mat ),
1702
mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
1706
(%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
1707
(%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
1708
(%o5) Two birds are singing.
1710
Si <dest> es un flujo de datos o `true', entonces `printf'
1711
devuelve `false'. En otro caso, `printf' devuelve una cadena con
1714
-- Función: readline (<stream>)
1715
Devuelve una cadena con los caracteres desde la posición actual en
1716
el flujo de datos <stream> hasta el final de la línea, o `false'
1717
si está al final del fichero.
1719
-- Función: sprint (<expr_1>, ..., <expr_n>)
1720
Evalúa y muestra sus argumentos uno tras otro en un renglón
1721
comenzando en su extremo izquierdo.
1723
(%i1) load("stringproc")$
1724
(%i2) for n:0 thru 16 do sprint( fib(n) )$
1725
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
1727
Si se quiere un salto de línea antes de cada impresión, añádase
1730
Véase `ascii' para un ejemplo.
1733
File: maxima.info, Node: Definiciones para caracteres, Next: Definiciones para cadenas, Prev: Definiciones para entrada y salida, Up: stringproc
1735
67.3 Definiciones para caracteres
1736
=================================
1738
-- Función: alphacharp (<char>)
1739
Devuelve `true' si <char> es una carácter alfabético.
1741
-- Función: alphanumericp (<char>)
1742
Devuelve `true' si <char> es una carácter alfabético o un dígito.
1744
-- Función: ascii (<int>)
1745
Devuelve el carácter correspondiente al número ASCII <int>,
1746
debiendo ser -1 < int < 256.
1748
(%i1) for n from 0 thru 255 do ( tmp: ascii(n),
1749
if alphacharp(tmp) then sprint(tmp) ), newline()$
1750
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g
1751
h i j k l m n o p q r s t u v w x y z
1754
-- Función: cequal (<char_1>, <char_2>)
1755
Devuelve `true' si <char_1> y <char_2> son el mismo carácter.
1757
-- Función: cequalignore (<char_1>, <char_2>)
1758
Como `cequal', pero ignora si las letras están en mayúsculas o
1761
-- Función: cgreaterp (<char_1>, <char_2>)
1762
Devuelve `true' si el número ASCII de <char_1> es mayor que el de
1765
-- Función: cgreaterpignore (<char_1>, <char_2>)
1766
Como `cgreaterp', pero ignora si las letras están en mayúsculas o
1769
-- Función: charp (<obj>)
1770
Devuelve `true' si <obj> es un carácter de Maxima.
1772
-- Función: cint (<char>)
1773
Devuelve el número ASCII de <char>.
1775
-- Función: clessp (<char_1>, <char_2>)
1776
Devuelve `true' si el número ASCII de <char_1> es menor que el de
1779
-- Función: clesspignore (<char_1>, <char_2>)
1780
Como `clessp', pero ignora si las letras están en mayúsculas o
1783
-- Función: constituent (<char>)
1784
Devuelve `true' si <char> es un carácter gráfico y no el carácter
1785
espacio. Un carácter gráfico es el que se puede ver y con un
1786
espacio añadido; `constituent' está definido por Paul Graham, ANSI
1787
Common Lisp, 1996, page 67.
1789
(%i1) for n from 0 thru 255 do ( tmp: ascii(n),
1790
if constituent(tmp) then sprint(tmp) ), newline()$
1791
! " # % ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
1792
C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
1793
d e f g h i j k l m n o p q r s t u v w x y z { | } ~
1796
-- Función: cunlisp (<lisp_char>)
1797
Convierte un carácter Lisp en uno de Maxima. El uso de esta
1798
función por parte del usuario no será necesario.
1800
-- Función: digitcharp (<char>)
1801
Devuelve `true' si <char> es un dígito.
1803
-- Función: lcharp (<obj>)
1804
Devuelve `true' si <obj> es un carácter de Lisp. El uso de esta
1805
función por parte del usuario no será necesario.
1807
-- Función: lowercasep (<char>)
1808
Devuelve `true' si <char> es un carácter en minúscula.
1810
-- Variable: newline
1811
El carácter de nueva línea.
1814
El carácter de espacio.
1817
El carácter de tabulación.
1819
-- Función: uppercasep (<char>)
1820
Devuelve `true' si <char> es un carácter en mayúscula.
1823
File: maxima.info, Node: Definiciones para cadenas, Prev: Definiciones para caracteres, Up: stringproc
1825
67.4 Definiciones para cadenas
1826
==============================
1828
-- Función: sunlisp (<lisp_string>)
1829
Convierte una cadena Lisp en una de Maxima. El uso de esta
1830
función por parte del usuario no será necesario.
1832
-- Función: lstringp (<obj>)
1833
Devuelve `true' si <obj> es una cadena de Lisp. El uso de esta
1834
función por parte del usuario no será necesario.
1836
-- Función: stringp (<obj>)
1837
Devuelve `true' si <obj> es una cadena de Maxima. Véase un
1838
ejemplo en la introducción.
1840
-- Función: charat (<string>, <n>)
1841
Devuelve el <n>-ésimo carácter de <string>. Al primer carácter de
1842
<string> le corresponde <n> = 1.
1844
(%i1) load("stringproc")$
1845
(%i2) charat("Lisp",1);
1849
-- Función: charlist (<string>)
1850
Devuelve una lista con todos los caracteres de <string>.
1852
(%i1) load("stringproc")$
1853
(%i2) charlist("Lisp");
1859
-- Función: parsetoken (<string>)
1860
La función `parsetoken' convierte el primer lexema de <string> a
1861
su forma numérica, devolviendo `false' si no se puede determinar
1862
este número. El conjunto de delimitadores de lexemas es `{space,
1863
comma, semicolon, tab, newline}'.
1865
(%i1) load("stringproc")$
1866
(%i2) 2*parsetoken("1.234 5.678");
1869
También se puede utilizar la función `parse_string' para el
1870
análisis sintáctico.
1872
-- Función: sconc (<expr_1>, ..., <expr_n>)
1873
Evalúa sus argumentos y los yuxtapone para formar una cadena.
1874
Esta función es similar a `sconcat', pero devuelve una cadena de
1877
(%i1) load("stringproc")$
1878
(%i2) sconc("xx[",3,"]:",expand((x+y)^3));
1879
(%o2) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
1884
-- Función: scopy (<string>)
1885
Devuelve una copia nueva de la cadena <string>.
1887
-- Función: sdowncase (<string>)
1888
-- Función: sdowncase (<string>, <start>)
1889
-- Función: sdowncase (<string>, <start>, <end>)
1890
Convierte caracteres en minúscula a mayúscula. Véase también
1893
-- Función: sequal (<string_1>, <string_2>)
1894
Devuelve `true' si <string_1> y <string_2> son dos cadenas de
1898
-- Función: sequalignore (<string_1>, <string_2>)
1899
Igual que `sequal' pero no diferencia entre minúsculas y
1903
-- Función: sexplode (<string>)
1904
El nombre `sexplode' es un seudónimo de la función `charlist'.
1907
-- Función: simplode (<list>)
1908
-- Función: simplode (<list>, <delim>)
1909
La función `simplode' admite como entrada una lista de expresiones
1910
para luego convertirla en una cadena de caracteres. Si no se
1911
utiliza la opción <delim> para indicar el delimitador, entonces
1912
`simplode' actúa como `sconc' y no hace uso de ninguno. El valor
1913
de <delim> puede ser cualquier cadena.
1915
(%i1) load("stringproc")$
1916
(%i2) simplode(["xx[",3,"]:",expand((x+y)^3)]);
1917
(%o2) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
1918
(%i3) simplode( sexplode("stars")," * " );
1919
(%o3) s * t * a * r * s
1920
(%i4) simplode( ["One","more","coffee."]," " );
1921
(%o4) One more coffee.
1924
-- Función: sinsert (<seq>, <string>, <pos>)
1925
Devuelve la concatenación de las cadenas `substring (<string>, 1,
1926
<pos> - 1)', <seq> y `substring (<string>, <pos>)'. Nótese que al
1927
primer carácter de <string> le corresponde la posición 1.
1929
(%i1) load("stringproc")$
1930
(%i2) s: "A submarine."$
1931
(%i3) sconc( substring(s,1,3),"yellow ",substring(s,3) );
1932
(%o3) A yellow submarine.
1933
(%i4) sinsert("hollow ",s,3);
1934
(%o4) A hollow submarine.
1937
-- Función: sinvertcase (<string>)
1938
-- Función: sinvertcase (<string>, <start>)
1939
-- Función: sinvertcase (<string>, <start>, <end>)
1940
Devuelve la misma cadena <string> pero con todos sus caracteres
1941
desde la posición <start> hasta <end> quedan invertidos, esto es,
1942
las mayúsculas se convierten en minúsculas y éstas en mayúsculas.
1943
Si no se incluye el argumento <end>, se invierten todos los
1944
caracteres desde <start> hasta el final de la cadena.
1946
(%i1) load("stringproc")$
1947
(%i2) sinvertcase("sInvertCase");
1951
-- Función: slength (<string>)
1952
Devuelve el número de caracteres de <string>.
1955
-- Función: smake (<num>, <char>)
1956
Construye una cadena de longitud <num> con todos sus caracteres
1959
(%i1) load("stringproc")$
1964
-- Función: smismatch (<string_1>, <string_2>)
1965
-- Función: smismatch (<string_1>, <string_2>, <test>)
1966
Devuelve la posición del primer carácter de <string_1> distinto del
1967
correpondiente a <string_2>. La respuesta será `false' si no existe
1968
tal carácter. Por defecto, la función de comparación es `sequal'.
1969
Si se quiere ignorar la diferencia entre mayúsculas y minúsculas,
1970
hágase uso de `sequalignore' para el argumento <test>.
1972
(%i1) load("stringproc")$
1973
(%i2) smismatch("seven","seventh");
1977
-- Función: split (<string>)
1978
-- Función: split (<string>, <delim>)
1979
-- Función: split (<string>, <delim>, <multiple>)
1980
Devuelve la lista de todos los lexemas (tokens) de <string>. La
1981
función `split' utiliza <delim> como delimitador, y en caso de no
1982
ser utilizado este argumento, será utilizado el espacio en blanco
1983
como delimitador por defecto. El argumento <multiple> es una
1984
variable booleana con valor `true' por defecto. Los delimitadores
1985
múltiples se leen como uno solo, lo que resulta de utilidad si las
1986
tabulaciones son almacenadas como secuencias de espacios en
1987
blanco. Si a <multiple> se le asigna el valor `false', se
1988
consirararán todos los delimitadores.
1990
(%i1) load("stringproc")$
1991
(%i2) split("1.2 2.3 3.4 4.5");
1992
(%o2) [1.2, 2.3, 3.4, 4.5]
1993
(%i3) split("first;;third;fourth",";",false);
1994
(%o3) [first, , third, fourth]
1997
-- Función: sposition (<char>, <string>)
1998
Devuelve la posición del primer carácter de <string> que coincide
1999
con <char>. Al primer carácter de <string> le corresponde la
2000
posición 1. Para cuando se quiera ignorar la diferencia entre
2001
mayúsculas y minúsculas, véase <ssearch>.
2003
-- Función: sremove (<seq>, <string>)
2004
-- Función: sremove (<seq>, <string>, <test>)
2005
-- Función: sremove (<seq>, <string>, <test>, <start>)
2006
-- Función: sremove (<seq>, <string>, <test>, <start>, <end>)
2007
Devuelve la cadena <string> pero sin las subcadenas que coinciden
2008
con <seq>. La función de comparación por defecto es `sequal'. Si
2009
se quiere ignorar la diferencia entre mayúsculas y minúsculas,
2010
hágase uso de `sequalignore' para el argumento <test>. Utilícense
2011
<start> y <end> para acotar la búsqueda. Al primer carácter de
2012
<string> le corresponde la posición 1.
2014
(%i1) load("stringproc")$
2015
(%i2) sremove("n't","I don't like coffee.");
2016
(%o2) I do like coffee.
2017
(%i3) sremove ("DO ",%,'sequalignore);
2018
(%o3) I like coffee.
2021
-- Función: sremovefirst (<seq>, <string>)
2022
-- Función: sremovefirst (<seq>, <string>, <test>)
2023
-- Función: sremovefirst (<seq>, <string>, <test>, <start>)
2024
-- Función: sremovefirst (<seq>, <string>, <test>, <start>, <end>)
2025
Actúa de forma similar a la función `sremove', pero sólo elimina
2026
la primera aparición de la subcadena `seq'.
2029
-- Función: sreverse (<string>)
2030
Devuelve una cadena con todos los caracteres de <string> en orden
2034
-- Función: ssearch (<seq>, <string>)
2035
-- Función: ssearch (<seq>, <string>, <test>)
2036
-- Función: ssearch (<seq>, <string>, <test>, <start>)
2037
-- Función: ssearch (<seq>, <string>, <test>, <start>, <end>)
2038
Devuelve la posición de la primera subcadena de <string> que
2039
coincide con la cadena <seq>. La función de comparación por
2040
defecto es `sequal'. Si se quiere ignorar la diferencia entre
2041
mayúsculas y minúsculas, hágase uso de `sequalignore' para el
2042
argumento <test>. Utilícense <start> y <end> para acotar la
2043
búsqueda. Al primer carácter de <string> le corresponde la
2046
(%i1) ssearch("~s","~{~S ~}~%",'sequalignore);
2050
-- Función: ssort (<string>)
2051
-- Función: ssort (<string>, <test>)
2052
Devuelve una cadena con todos los caracteres de <string> en un
2053
orden tal que no haya dos caracteres sucesivos <c> y <d> que
2054
verifiquen que `test (<c>, <d>)' sea igual `false' y `test (<d>,
2055
<c>)' igual a `true'. La función de comparación <test> por
2056
defecto es <clessp>, siendo el conjunto de posibles valores para
2057
este argumento `{clessp, clesspignore, cgreaterp, cgreaterpignore,
2058
cequal, cequalignore}'.
2060
(%i1) load("stringproc")$
2061
(%i2) ssort("I don't like Mondays.");
2062
(%o2) '.IMaddeiklnnoosty
2063
(%i3) ssort("I don't like Mondays.",'cgreaterpignore);
2064
(%o3) ytsoonnMlkIiedda.'
2067
-- Función: ssubst (<new>, <old>, <string>)
2068
-- Función: ssubst (<new>, <old>, <string>, <test>)
2069
-- Función: ssubst (<new>, <old>, <string>, <test>, <start>)
2070
-- Función: ssubst (<new>, <old>, <string>, <test>, <start>, <end>)
2071
Devuelve una cadena similar a <string> pero en la que aquellas
2072
subcadenas coincidentes con <old> han sido sustituidas por <new>.
2073
Las subcadenas <old> y <new> no necesitan ser de la misma longitud.
2074
La función de comparación por defecto es `sequal'. Si se quiere
2075
ignorar la diferencia entre mayúsculas y minúsculas durante la
2076
búsqueda de <old>, hágase uso de `sequalignore' para el argumento
2077
<test>. Utilícense <start> y <end> para acotar la búsqueda. Al
2078
primer carácter de <string> le corresponde la posición 1.
2080
(%i1) load("stringproc")$
2081
(%i2) ssubst("like","hate","I hate Thai food. I hate green tea.");
2082
(%o2) I like Thai food. I like green tea.
2083
(%i3) ssubst("Indian","thai",%,'sequalignore,8,12);
2084
(%o3) I like Indian food. I like green tea.
2087
-- Función: ssubstfirst (<new>, <old>, <string>)
2088
-- Función: ssubstfirst (<new>, <old>, <string>, <test>)
2089
-- Función: ssubstfirst (<new>, <old>, <string>, <test>, <start>)
2090
-- Función: ssubstfirst (<new>, <old>, <string>, <test>, <start>,
2092
Actúa de forma similar a la función `subst', pero sólo hace la
2093
sustitución en la primera coincidencia con <old>.
2095
-- Función: strim (<seq>,<string>)
2096
Devuelve la cadena <string> pero recortando los caracteres de
2097
<seq> que tuviese en sus extremos.
2099
(%i1) load("stringproc")$
2100
(%i2) "/* comment */"$
2101
(%i3) strim(" /*",%);
2107
-- Función: striml (<seq>, <string>)
2108
Actúa de forma similar a `strim', pero sólo recorta en el extremo
2111
-- Función: strimr (<seq>, <string>)
2112
Actúa de forma similar a `strim', pero sólo recorta en el extremo
2113
inicial de <string>.
2115
-- Función: substring (<string>, <start>)
2116
-- Función: substring (<string>, <start>, <end>)
2117
Devuelve la subcadena de <string> que comienza en la posición
2118
<start> y termina en la posición <end>. El carácter en la
2119
posición <end> no se incluye. En caso de no suministrarse el
2120
argumento <end>, la subcadena se extenderá hasta el final. Al
2121
primer carácter de <string> le corresponde la posición 1.
2123
(%i1) load("stringproc")$
2124
(%i2) substring("substring",4);
2126
(%i3) substring(%,4,6);
2130
-- Función: supcase (<string>)
2131
-- Función: supcase (<string>, <start>)
2132
-- Función: supcase (<string>, <start>, <end>)
2133
Devuelve la cadena <string> con todos sus caracteres entre las
2134
posiciones <start> y <end> en minúscula transformados a mayúscula.
2135
En caso de no suministrarse el argumento <end>, los cambios se
2136
extenderán hasta el final.
2138
(%i1) load("stringproc")$
2139
(%i2) supcase("english",1,2);
2143
-- Función: tokens (<string>)
2144
-- Función: tokens (<string>, <test>)
2145
Devuelve la lista de todos los lexemas (tokens) de <string>. Los
2146
lexemas son subcadenas cuyos caracteres satisfacen la condición
2147
<test>. Si no se suministra el argumento <test>, se utilizará la
2148
condición <constituent>, siendo el conjunto de las otras
2149
alternativas `{constituent, alphacharp, digitcharp, lowercasep,
2150
uppercasep, charp, characterp, alphanumericp}'.
2152
(%i1) load("stringproc")$
2153
(%i2) tokens("24 October 2005");
2154
(%o2) [24, October, 2005]
2155
(%i3) tokens("05-10-24",'digitcharp);
2157
(%i4) map(parsetoken,%);
2162
File: maxima.info, Node: unit, Next: zeilberger, Prev: stringproc, Up: Top
2169
* Introducción a Units::
2170
* Definiciones para Units::
2173
File: maxima.info, Node: Introducción a Units, Next: Definiciones para Units, Prev: unit, Up: unit
2175
68.1 Introducción a Units
2176
=========================
2178
El paquete `unit' permite al usuario hacer cambios de unidades y llevar
2179
a cabo el análisis dimensional de las ecuaciones. La forma de operar de
2180
este paquete es radicalmente diferente de la del paquete original de
2181
Maxima; mientras que en el paquete original era tan solo una lista de
2182
definiciones, aquí se utiliza un conjunto de reglas que permiten
2183
seleccionar al usuario en qué unidades debe devolverse la expresión
2186
Junto con el análisis dimensional, el paquete aporta una serie de
2187
herramientas para controlar las opciones de conversión y simplificación.
2188
Además de la conversión automática adaptable a las necesidades del
2189
usuario, el paquete `unit' permite hacer conversiones a la manera
2192
Nota: Cuando los factores de conversión no son exactos, Maxima los
2193
transformará a fracciones como consecuencia de la metodología utilizada
2194
para simplificar las unidades. Los mensajes de aviso concernientes a
2195
estas transformaciones están desactivados por defecto en el caso de las
2196
unidades (lo habitual es que estén activados en otros contextos) debido
2197
a que al ser una operación muy frecuente, serían un estorbo. El estado
2198
previo de la variable `ratprint' queda restaurado tras la conversión de
2199
las unidades, de manera que se mantendrá la opción seleccionada por el
2200
usuario; en caso de que éste necesite ver dichos avisos, podrá hacer la
2201
asignación `unitverbose:on' para reactivarlos desde el proceso de
2202
conversión de unidades.
2204
El paquete `unit' se aloja en el directorio `share/contrib/unit' y
2205
se ajusta a las convenciones de Maxima para la carga de paquetes:
2208
*******************************************************************
2209
* Units version 0.50 *
2210
* Definitions based on the NIST Reference on *
2211
* Constants, Units, and Uncertainty *
2212
* Conversion factors from various sources including *
2213
* NIST and the GNU units package *
2214
*******************************************************************
2216
Redefining necessary functions...
2217
WARNING: DEFUN/DEFMACRO: redefining function TOPLEVEL-MACSYMA-EVAL ...
2218
WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
2219
WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
2220
WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
2221
Initializing unit arrays...
2224
Los avisos del tipo `WARNING' son normales y no deben interpretarse
2225
como errores; tan solo indican que el paquete `unit' está redefiniendo
2226
funciones que ya estaban definidas en Maxima. Esto es necesario para
2227
que las unidades se gestionen de forma correcta. El usuario debe tener
2228
en cuenta que si otros paquetes han cambiado las definiciones de estas
2229
funciones, tales cambios serán ignorados por el proceso de carga de
2232
El paquete `unit' también carga el fichero de Lisp
2233
`unit-functions.lisp', el cual contiene las funciones Lisp necesarias.
2235
El autor principal de este paquete es Clifford Yapp, quien ha
2236
recibido ayuda y asistencia, entre otros, de Barton Willis y Robert
2240
File: maxima.info, Node: Definiciones para Units, Prev: Introducción a Units, Up: unit
2242
68.2 Definiciones para Units
2243
============================
2245
-- Función: setunits (<list>)
2246
El paquete `unit' no utiliza por defecto dimensiones derivadas,
2247
pero convierte todas las unidades a las siete fundamentales en
2257
(%o3) (------) (----)
2264
(%i5) centigram*inch/minutes^2;
2266
(%o5) (-------------) (----)
2270
Este es el comportamiento que se desea en ciertos casos. Si el
2271
usuario necesita utilizar otras unidades, habrá de utilizar la
2272
instrucción `setunits':
2273
(%i6) setunits([centigram,inch,minute]);
2276
1800000000000 %in cg
2277
(%o7) (-------------) (------)
2282
(%o8) (--------) (------)
2287
(%i10) centigram*inch/minutes^2;
2293
La especificación de las variables es relativamente flexible. Por
2294
ejemplo, si se quiere volver a utilizar kilogramos, metros y
2295
segundos como unidades por defecto, podemos hacer:
2296
(%i11) setunits([kg,m,s]);
2298
(%i12) centigram*inch/minutes^2;
2300
(%o12) (-------------) (----)
2304
Las unidades derivadas también se controlan con esta misma
2316
(%i21) centigram*inch/minutes^2;
2318
(%o21) (-------------) (N)
2321
Téngase en cuenta que el paquete `unit' reconoce que la
2322
combinación de masa, longitud e inversa del cuadrado del tiempo da
2323
lugar a una fuerza, convirtiéndola a newtons. Esta es la forma
2324
general en la que trabaja Maxima. Si el usuario prefiere dinas a
2325
newtons, tan solo tendrá que hacer lo siguiente:
2326
(%i22) setunits(dyn);
2329
(%o23) (100000) (dyn)
2330
(%i24) centigram*inch/minutes^2;
2332
(%o24) (--------) (dyn)
2335
Para desactivar una unidad se utiliza la instrucción `uforget':
2336
(%i26) uforget(dyn);
2343
(%i28) centigram*inch/minutes^2;
2345
(%o28) (-------------) (----)
2348
Esto también hubiese funcionado con `uforget(N)' o
2351
Véase también `uforget'. Para hacer uso de esta función ejecútese
2354
-- Función: uforget (<list>)
2355
Por defecto, el paquete `unit' convierte todas las unidades a las
2356
siete fundamentales del sistema MKS. Este comportamiento puede
2357
alterarse mediante la instrucción `setunits'. Después, si el
2358
usuario quiere restaurar el comportamiento por defecto podrá
2359
hacerlo para una dimensión determinada haciendo uso de la
2360
instrucción `uforget':
2361
(%i13) setunits([centigram,inch,minute]);
2363
(%i14) centigram*inch/minutes^2;
2368
(%i15) uforget([cg,%in,%min]);
2369
(%o15) [false, false, false]
2370
(%i16) centigram*inch/minutes^2;
2372
(%o16) (-------------) (----)
2376
La instrucción `uforget' opera sobre dimensiones, no sobre
2377
unidades, de modo que valdrá para cualquier unidad de una
2378
dimensión concreta. La propia dimensión es una argumento válido
2381
Véase también `setunits'. Para hacer uso de esta función ejecútese
2384
-- Función: convert (<expr>, <list>)
2385
La función `convert' permite conversiones de una sola vez sin
2386
alterar el entorno global de ejecución. Acepta tanto un único
2387
argumento como una lista de unidades a utilizar en las
2388
conversiones. Cuando se realiza una llamada a `convert' se ignora
2389
el sistema global de evaluación, con el fin de evitar que el
2390
resultado deseado sea nuevamente transformado. Como consecuencia
2391
de esto, en los cálculos con decimales, los avisos de tipo `rat'
2392
se harán visibles si la variable global `ratprint' vale `true'.
2393
Otra propiedad de `convert' es que permite al usuario hacer
2394
conversiones al sistema fundamental de dimensiones incluso cuando
2395
el entorno ha sido ajustado para simplificar a una dimensión
2402
(%i3) convert(kg*m/s^2,[g,km,s]);
2407
(%i4) convert(kg*m/s^2,[g,inch,minute]);
2409
`rat' replaced 39.37007874015748 by 5000//127 = 39.37007874015748
2411
(%o4) (-----------) (-----)
2414
(%i5) convert(kg*m/s^2,[N]);
2416
(%i6) convert(kg*m^2/s^2,[N]);
2418
(%i7) setunits([N,J]);
2420
(%i8) convert(kg*m^2/s^2,[N]);
2422
(%i9) convert(kg*m^2/s^2,[N,inch]);
2424
`rat' replaced 39.37007874015748 by 5000//127 = 39.37007874015748
2426
(%o9) (----) (%in N)
2428
(%i10) convert(kg*m^2/s^2,[J]);
2432
(%i12) setunits([g,inch,s]);
2440
(%o15) (-------) (-----)
2443
(%i16) convert(kg*m/s^2,[g,inch,s]);
2445
`rat' replaced 39.37007874015748 by 5000//127 = 39.37007874015748
2447
(%o16) (-------) (-----)
2451
Véanse también `setunits' y `uforget'. Para hacer uso de esta
2452
función ejecútese `load("unit")'.
2454
-- Variable opcional: usersetunits
2455
Valor por defecto: ninguno
2457
En caso de que el usuario desee que el comportamiento por defecto
2458
del paquete `unit' sea distinto del descrito, puede hacer uso del
2459
fichero `maxima-init.mac' y de la variable global `usersetunits'.
2460
El paquete `unit' comprobará al ser cargado si se le ha dado a esta
2461
variable una lista de unidades; en caso afirmativo, aplicará
2462
`setunits' a las unidades de esta lista y las utilizará por
2463
defecto. Una llamada a la función `uforget' permitirá retornar al
2464
comportamiento establecido por defecto por el usuario. Por
2465
ejemplo, si en el archivo `maxima-init.mac' se tiene el siguiente
2467
usersetunits : [N,J];
2469
observaríamos el siguiente comportamiento:
2471
*******************************************************************
2472
* Units version 0.50 *
2473
* Definitions based on the NIST Reference on *
2474
* Constants, Units, and Uncertainty *
2475
* Conversion factors from various sources including *
2476
* NIST and the GNU units package *
2477
*******************************************************************
2479
Redefining necessary functions...
2480
WARNING: DEFUN/DEFMACRO: redefining function TOPLEVEL-MACSYMA-EVAL ...
2481
WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
2482
WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
2483
WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
2484
Initializing unit arrays...
2486
User defaults found...
2487
User defaults initialized.
2496
(%i6) setunits([dyn,eV]);
2499
(%o7) (100000) (dyn)
2501
(%o8) (6241509596477042688) (eV)
2503
(%o9) (6241509596477042688) (eV m)
2505
(%o10) (6241509596477042688000) (eV)
2506
(%i11) uforget([dyn,eV]);
2507
(%o11) [false, false]
2517
De no haber hecho uso de `usersetunits', las entradas iniciales
2518
hubiesen sido convertidas a unidades MKS y cualquier llamada a
2519
`uforget' hubiese retornado también a MKS. Sin embargo, las
2520
preferencias establecidas por el usuario se respetan en ambos
2521
casos. Para eliminar las preferencias del usuario y volver a
2522
utilizar las establecidas por defecto por el paquete `unit', debe
2523
utilizarse la instrucción `dontusedimension'. La función `uforget'
2524
puede restaurar nuevamente las preferencias del usuario, pero sólo
2525
si `usedimension' mantiene su valor. Alternativamente,
2526
`kill(usersetunits)' eliminará completamente cualquier vestigio
2527
de las preferencias del usuario durante la sesión actual. Véanse a
2528
continuación algunos ejemplos de aplicación de estas opciones:
2533
(%i4) setunits([dyn,eV]);
2536
(%o5) (100000) (dyn)
2538
(%o6) (6241509596477042688) (eV)
2539
(%i7) uforget([dyn,eV]);
2540
(%o7) [false, false]
2545
(%i10) dontusedimension(N);
2547
(%i11) dontusedimension(J);
2548
(%o11) [%energy, %force]
2560
(%i14) setunits([dyn,eV]);
2573
(%i17) uforget([dyn,eV]);
2574
(%o17) [false, false]
2586
(%i20) usedimension(N);
2587
Done. To have Maxima simplify to this dimension, use setunits([unit])
2590
(%i21) usedimension(J);
2591
Done. To have Maxima simplify to this dimension, use setunits([unit])
2605
(%i24) setunits([dyn,eV]);
2608
(%o25) (100000) (dyn)
2610
(%o26) (6241509596477042688) (eV)
2611
(%i27) uforget([dyn,eV]);
2612
(%o27) [false, false]
2617
(%i30) kill(usersetunits);
2619
(%i31) uforget([dyn,eV]);
2620
(%o31) [false, false]
2633
Desafortunadamente, esta amplia variedad de opciones puede resultar
2634
confusa en un primer momento, pero una vez se practica un poco con
2635
ellas, el usuario comprobará que tiene un control absoluto sobre
2636
su entorno de trabajo.
2639
-- Función: metricexpandall (<x>)
2640
Reconstruye automáticamente las listas globales de unidades
2641
creando todas los múltiplos y submúltiplos métricos necesarios. El
2642
argumento numérico <x> se utiliza para especificar cuántos
2643
prefijos numéricos quiere utilizar el usuario. Los argumentos son
2645
0 - none. Only base units
2646
1 - kilo, centi, milli
2647
(por defecto) 2 - giga, mega, kilo, hecto, deka, deci, centi,
2649
3 - peta, tera, giga, mega, kilo, hecto, deka,
2650
deci, centi, milli, micro, nano, pico,
2654
Normalmente, Maxima no definirá el juego completo de múltiplos y
2655
submúltiplos, lo que implica un número muy grande de unidades, pero
2656
`metricexpandall' puede utilizarse para reconstruir la lista. La
2657
variable fundamental del paquete `unit' es `%unitexpand'.
2659
-- Variable opcional: %unitexpand
2660
Valor por defecto: `2'
2662
Es el valor suministrado a `metricexpandall' durante la carga del
2666
File: maxima.info, Node: zeilberger, Next: Índice de Funciones y Variables, Prev: unit, Up: Top
2673
* Introducción a zeilberger::
2674
* Definiciones para zeilberger::
2677
File: maxima.info, Node: Introducción a zeilberger, Next: Definiciones para zeilberger, Prev: zeilberger, Up: zeilberger
2679
69.1 Introducción a zeilberger
2680
==============================
2682
El paquete `zeilberger' implementa el algoritmo de Zeilberger para la
2683
suma hipergeométrica definida y el algoritmo de Gosper para la suma
2684
hipergeométrica indefinida. Además, hace uso del método de optimización
2685
por filtrado desarrollado por Axel Riese.
2687
El autor de este paquete es Fabrizio Caruso.
2689
Antes de hacer uso de las funciones aquí definidas, ejecútese la
2690
sentencia `load (zeilberger)'.
2692
69.1.0.1 El problema de la suma indefinida
2693
..........................................
2695
El paquete `zeilberger' implementa el algoritmo de Gosper para la suma
2696
hipergeométrica indefinida. Dado el término general hipergeométrico
2697
F_k de índice k, se plantea el problema de encontrar su antidiferencia
2698
hipergeométrica, esto es, el término hipergeométrico tal que F_k =
2701
69.1.0.2 El problema de la suma definida
2702
........................................
2704
El paquete `zeilberger' implementa el algoritmo de Zeilberger para la
2705
suma hipergeométrica definida. Dados el término hipergeométrico propio
2706
F_(n,k), de índices n y k, y el entero positivo d, se plantea el
2707
problema de encontrar una expresión recurrente lineal de orden d con
2708
coeficientes polinomiales en n y una función racional R en n y k tales
2711
a_0 F_(n,k) + ... + a_d F_(n+d),k = Delta_K(R(n,k) F_(n,k))
2713
donde Delta_k es el k-ésimo operador diferencia hacia adelante, esto
2714
es, Delta_k(t_k) := t_(k+1) - t_k.
2716
69.1.1 Niveles de información
2717
-----------------------------
2719
Hay versiones extendidas de los nombres de las instrucciones, que se
2720
construyen añadiendo uno de los siguientes prefijos:
2723
Tan solo muestra un sumario al final
2726
Alguna información en los niveles intermedios
2732
Aún más información, incluida alguna sobre el sistema lineal en el
2733
algoritmo de Zeilberger.
2735
Por ejemplo: `GosperVerbose', `parGosperVeryVerbose',
2736
`ZeilbergerExtra', `AntiDifferenceSummary'.
2739
File: maxima.info, Node: Definiciones para zeilberger, Prev: Introducción a zeilberger, Up: zeilberger
2741
69.2 Definiciones para zeilberger
2742
=================================
2744
-- Función: AntiDifference (<F_k>, <k>)
2745
Returns the hypergeometric anti-difference of <F_k>, if it exists.
2746
Otherwise `AntiDifference' returns `no_hyp_antidifference'.
2748
-- Función: Gosper (<F_k>, <k>)
2749
Devuelve, si existe, el elemento racional asociado a <F_k>, esto
2750
es, la función racional que verifica
2752
F_k = R(k+1) F_(k+1) - R(k) F_k.
2754
En caso de no existir este elemento, `Gosper' devuelve
2757
-- Función: GosperSum (<F_k>, <k>, <a>, <b>)
2758
Devuelve la suma de los términos <F_k> desde <k> = <a> hasta <k> =
2759
<b> si <F_k> tiene una antidiferencia hipergeométrica. En caso
2760
contrario, `GosperSum' devuelve `nongosper_summable'.
2764
(%i1) load (zeilberger);
2765
(%o1) /usr/share/maxima/share/contrib/Zeilberger/zeilberger.mac
2766
(%i2) GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);
2768
Dependent equations eliminated: (1)
2772
(%o2) - ------------------ - -
2775
(%i3) GosperSum (1 / (4*k^2 - 1), k, 1, n);
2779
(%o3) -------------- + -
2782
(%i4) GosperSum (x^k, k, 1, n);
2785
(%o4) ------ - -----
2787
(%i5) GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
2790
(%o5) - ------------------------- - ----------
2791
a (- n + a - 1)! (n + 1)! a (a - 1)!
2792
(%i6) GosperSum (k*k!, k, 1, n);
2794
Dependent equations eliminated: (1)
2796
(%i7) GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
2797
(n + 1) (n + 2) (n + 1)!
2798
(%o7) ------------------------ - 1
2800
(%i8) GosperSum (1 / ((a - k)!*k!), k, 1, n);
2801
(%o8) nonGosper_summable
2803
-- Función: parGosper (<F_{n,k}>, <k>, <n>, <d>)
2804
Intenta calcular una recurrecia de orden <d> para <F_{n,k}>.
2806
El algoritmo devuelve una secuencia [s_1, s_2, ..., s_m] de
2807
soluciones, cada una de las cuales tiene la forma
2809
[R(n, k), [a_0, a_1, ..., a_d]].
2811
La función `parGosper' devuelve `[]' si no encuentra ninguna
2814
-- Función: Zeilberger (<F_{n,k}>, <k>, <n>)
2815
Intenta calcular la suma hipergeométrica indefinida de <F_{n,k}>.
2817
La función `Zeilberger' invoca en primer lugar a `Gosper', y en
2818
caso de no encontrar una solución, llama después a `parGosper' con
2819
los órdenes 1, 2, 3, ..., hasta `max_ord'. Si `Zeilberger'
2820
encuentra una solución antes de alcanzar `max_ord', se detiene su
2821
ejecución y devuelve el resultado.
2823
El algoritmo devuelve una secuencia [s_1, s_2, ..., s_m] de
2824
soluciones, cada una de las cuales tiene la forma
2826
[R(n, k), [a_0, a_1, ..., a_d]].
2828
La función `Zeilberger' devuelve `[]' si no encuentra ninguna
2831
La función `Zeilberger' llama a `Gosper' sólo si
2832
`gosper_in_zeilberger' tiene el valor `true'.
2834
-- Variable opcional: max_ord
2835
Valor por defecto: 5
2837
`max_ord' es el máximo orden de recurrencia que ensayará la
2838
función `Zeilberger'.
2840
-- Variable opcional: simplified_output
2841
Valor por defecto: `false'
2843
Si `simplified_output' vale `true', las funciones del paquete
2844
`zeilberger' tratan de presentar las soluciones simplificadas.
2846
-- Variable opcional: linear_solver
2847
Valor por defecto: `linsolve'
2849
La variable `linear_solver' guarda el nombre de la función que se
2850
utilizará para resolver el sistema de ecuaciones del algoritmo de
2853
-- Variable opcional: warnings
2854
Valor por defecto: `true'
2856
Si `warnings' vale `true', las funciones del paquete `zeilberger'
2857
emiten mensajes de aviso durante su ejecución.
2859
-- Variable opcional: gosper_in_zeilberger
2860
Valor por defecto: `true'
2862
Si `gosper_in_zeilberger' vale `true', la función `Zeilberger'
2863
llama a la función `Gosper' antes de llamar a `parGosper'. En
2864
caso contrario, `Zeilberger' invoca inmediatamente a `parGosper'.
2866
-- Variable opcional: trivial_solutions
2867
Valor por defecto: `true'
2869
Si `trivial_solutions' vale `true', la función `Zeilberger'
2870
devuelve soluciones triviales.
2872
-- Variable opcional: mod_test
2873
Valor por defecto: `false'
2875
Si `mod_test' vale `true', la función `parGosper' ejecuta una
2876
prueba modular para descartar sistemas sin soluciones.
2878
-- Variable opcional: modular_linear_solver
2879
Valor por defecto: `linsolve'
2881
La variable `modular_linear_solver' guarda el nombre de la función
2882
que deberá ser llamada por la prueba modular de `parGosper' para
2883
resolver sistemas lineales.
2885
-- Variable opcional: ev_point
2886
Valor por defecto: `big_primes[10]'
2888
La variable `ev_point' guarda el valor para el que debe evaluarse
2889
<n> durante la ejecución de la prueba modular de `parGosper'.
2891
-- Variable opcional: mod_big_prime
2892
Valor por defecto: `big_primes[1]'
2894
La variable `mod_big_prime' guarda el módulo utilizado por la
2895
prueba modular de `parGosper'.
2897
-- Variable opcional: mod_threshold
2898
Valor por defecto: 4
2900
La variable `mod_threshold' es el máximo orden que ensaya la
2901
prueba modular de `parGosper'.
added
removed
doc/info/es.utf8/maxima.info-6
