| blob | 250f9e3813e7072027e7a6ce872f34979f43b1d9 |
1 @c English version 2013-04-04
2 @menu
3 * Funciones para los números::
4 * Funciones para los números complejos::
5 * Funciones combinatorias::
6 * Funciones radicales exponenciales y logarítmicas::
7 * Funciones trigonométricas::
8 * Números aleatorios::
9 @end menu
14 @node Funciones para los números, Funciones para los números complejos, Funciones matemáticas, Funciones matemáticas
15 @section Funciones para los números
18 @deffn {Función} abs (@var{z})
19 La función @code{abs} representa el valor absoluto y se puede aplicar tanto
20 a argumentos numéricos como simbólicos. Si el argumento @var{z} es un
21 número real o complejo, @code{abs} devuelve el valor absoluto de @var{z}.
22 Si es posible, las expresiones simbólicas que utilizan la función del
23 valor absoluto también se simplifican.
25 Maxima puede derivar, integrar y calcular límites de expresiones
26 que contengan a @code{abs}. El paquete @code{abs_integrate} extiende las
27 capacidades de Maxima para calcular integrales que contengan llamadas a
28 @code{abs}. Véase @code{(%i12)} en el ejemplo de más abajo.
30 Cuando se aplica a una lista o matriz, @code{abs} se distribuye automáticamente
31 sobre sus elementos. De forma similar, también se distribuye sobre los dos
32 miembros de una igualdad. Para cambiar este comportamiento por defecto,
33 véase la variable @code{distribute_over}.
35 Ejemplos:
37 Cálculo del valor absoluto de números reales y complejos, incluyendo
38 constantes numéricas e infinitos. El primer ejemplo muestra cómo
39 @code{abs} se distribuye sobre los elementos de una lista.
41 @example
42 (%i1) abs([-4, 0, 1, 1+%i]);
43 (%o1) [4, 0, 1, sqrt(2)]
45 (%i2) abs((1+%i)*(1-%i));
46 (%o2) 2
47 (%i3) abs(%e+%i);
48 2
49 (%o3) sqrt(%e + 1)
50 (%i4) abs([inf, infinity, minf]);
51 (%o4) [inf, inf, inf]
52 @end example
54 Simplificación de expresiones que contienen @code{abs}:
56 @example
57 (%i5) abs(x^2);
58 2
59 (%o5) x
60 (%i6) abs(x^3);
61 2
62 (%o6) x abs(x)
64 (%i7) abs(abs(x));
65 (%o7) abs(x)
66 (%i8) abs(conjugate(x));
67 (%o8) abs(x)
68 @end example
70 Integrando y derivando con la función @code{abs}. Nótese que se pueden
71 calcular más integrales que involucren la función @code{abs} si se
72 carga el paquete @code{abs_integrate}. El último ejemplo muestra la
73 transformada de Laplace de @code{abs}. Véase @code{laplace}.
75 @example
76 (%i9) diff(x*abs(x),x),expand;
77 (%o9) 2 abs(x)
79 (%i10) integrate(abs(x),x);
80 x abs(x)
81 (%o10) --------
82 2
84 (%i11) integrate(x*abs(x),x);
85 /
86 [
87 (%o11) I x abs(x) dx
88 ]
89 /
91 (%i12) load("abs_integrate")$
92 (%i13) integrate(x*abs(x),x);
93 2 3
94 x abs(x) x signum(x)
95 (%o13) --------- - ------------
96 2 6
98 (%i14) integrate(abs(x),x,-2,%pi);
99 2
100 %pi
101 (%o14) ---- + 2
102 2
104 (%i15) laplace(abs(x),x,s);
105 1
106 (%o15) --
107 2
108 s
109 @end example
110 @end deffn
114 @deffn {Función} ceiling (@var{x})
115 Si @var{x} es un número real, devuelve el menor entero mayor o igual que @var{x}.
117 Si @var{x} es una expresión constante (por ejemplo, @code{10 * %pi}),
118 @code{ceiling} evalúa @var{x} haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación
119 @code{ceiling} al número decimal obtenido. Puesto que @code{ceiling} hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para @code{fpprec}.
121 Para argumentos no constantes, @code{ceiling} intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que @code{ceiling} es capaz de hacer:
123 @c ===beg===
124 @c ceiling (ceiling (x));
125 @c ceiling (floor (x));
126 @c declare (n, integer)$
127 @c [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
128 @c assume (x > 0, x < 1)$
129 @c ceiling (x);
130 @c tex (ceiling (a));
131 @c ===end===
132 @example
133 (%i1) ceiling (ceiling (x));
134 (%o1) ceiling(x)
135 (%i2) ceiling (floor (x));
136 (%o2) floor(x)
137 (%i3) declare (n, integer)$
138 (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
139 (%o4) [n, abs(n), max(n, 6)]
140 (%i5) assume (x > 0, x < 1)$
141 (%i6) ceiling (x);
142 (%o6) 1
143 (%i7) tex (ceiling (a));
144 $$\left \lceil a \right \rceil$$
145 (%o7) false
146 @end example
148 La función @code{ceiling} no se extiende automáticamente a los elementos de listas y matrices.
149 Por último, para todos los argumentos que tengan una forma compleja, @code{ceiling} devuelve una forma nominal.
151 Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como @code{integervalued}. Tanto @code{ceiling} como @code{floor} son funciones que hacen uso de esta información; por ejemplo:
153 @c ===beg===
154 @c declare (f, integervalued)$
155 @c floor (f(x));
156 @c ceiling (f(x) - 1);
157 @c ===end===
158 @example
159 (%i1) declare (f, integervalued)$
160 (%i2) floor (f(x));
161 (%o2) f(x)
162 (%i3) ceiling (f(x) - 1);
163 (%o3) f(x) - 1
164 @end example
166 Ejemplo de uso:
168 @c ===beg===
169 @c unitfrac(r) := block([uf : [], q],
170 @c if not(ratnump(r)) then
171 @c error("unitfrac: argument must be a rational number"),
172 @c while r # 0 do (
173 @c uf : cons(q : 1/ceiling(1/r), uf),
174 @c r : r - q),
175 @c reverse(uf));
176 @c unitfrac (9/10);
177 @c apply ("+", %);
178 @c unitfrac (-9/10);
179 @c apply ("+", %);
180 @c unitfrac (36/37);
181 @c apply ("+", %);
182 @c ===end===
183 @example
184 @group
185 (%i1) unitfrac(r) := block([uf : [], q],
186 if not(ratnump(r)) then
187 error("unitfrac: argument must be a rational number"),
188 while r # 0 do (
189 uf : cons(q : 1/ceiling(1/r), uf),
190 r : r - q),
191 reverse(uf))$
192 @end group
193 (%i2) unitfrac (9/10);
194 1 1 1
195 (%o2) [-, -, --]
196 2 3 15
197 (%i3) apply ("+", %);
198 9
199 (%o3) --
200 10
201 (%i4) unitfrac (-9/10);
202 1
203 (%o4) [- 1, --]
204 10
205 (%i5) apply ("+", %);
206 9
207 (%o5) - --
208 10
209 (%i6) unitfrac (36/37);
210 1 1 1 1 1
211 (%o6) [-, -, -, --, ----]
212 2 3 8 69 6808
213 (%i7) apply ("+", %);
214 36
215 (%o7) --
216 37
217 @end example
218 @end deffn
222 @deffn {Función} entier (@var{x})
223 Devuelve el mayor entero menor o igual a @var{x}, siendo @var{x} numérico. La función @code{fix} (como en
224 @code{fixnum}) es un sinónimo, de modo que @code{fix(@var{x})} hace justamente lo mismo.
226 @end deffn
230 @deffn {Función} floor (@var{x})
232 Si @var{x} es un número real, devuelve el mayor entero menor o igual que @var{x}.
234 Si @var{x} es una expresión constante (por ejemplo, @code{10 * %pi}),
235 @code{floor} evalúa @var{x} haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación
236 @code{floor} al número decimal obtenido. Puesto que @code{floor} hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para @code{fpprec}.
238 Para argumentos no constantes, @code{floor} intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que @code{floor} es capaz de hacer:
240 @c ===beg===
241 @c floor (ceiling (x));
242 @c floor (floor (x));
243 @c declare (n, integer)$
244 @c [floor (n), floor (abs (n)), floor (min (n, 6))];
245 @c assume (x > 0, x < 1)$
246 @c floor (x);
247 @c tex (floor (a));
248 @c ===end===
249 @example
250 (%i1) floor (ceiling (x));
251 (%o1) ceiling(x)
252 (%i2) floor (floor (x));
253 (%o2) floor(x)
254 (%i3) declare (n, integer)$
255 (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
256 (%o4) [n, abs(n), min(n, 6)]
257 (%i5) assume (x > 0, x < 1)$
258 (%i6) floor (x);
259 (%o6) 0
260 (%i7) tex (floor (a));
261 $$\left \lfloor a \right \rfloor$$
262 (%o7) false
263 @end example
265 La función @code{floor} no se extiende automáticamente a los elementos de listas y matrices.
266 Por último, para todos los argumentos que tengan una forma compleja, @code{floor} devuelve una forma nominal.
268 Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como @code{integervalued}. Tanto @code{ceiling} como @code{floor} son funciones que hacen uso de esta información; por ejemplo:
270 @c ===beg===
271 @c declare (f, integervalued)$
272 @c floor (f(x));
273 @c ceiling (f(x) - 1);
274 @c ===end===
275 @example
276 (%i1) declare (f, integervalued)$
277 (%i2) floor (f(x));
278 (%o2) f(x)
279 (%i3) ceiling (f(x) - 1);
280 (%o3) f(x) - 1
281 @end example
283 @end deffn
286 @deffn {Función} fix (@var{x})
287 Es un sinónimo de @code{entier (@var{x})}.
289 @end deffn
293 @deffn {Función} lmax (@var{L})
295 Si @var{L} es una lista o conjunto, devuelve @code{apply ('max, args (@var{L}))}. Si @var{L} no es una lista o conjunto, envía un mensaje de error.
296 @end deffn
300 @deffn {Función} lmin (@var{L})
302 Si @var{L} es una lista o conjunto, devuelve @code{apply ('min, args (@var{L}))}. Si @var{L} no es una lista o conjunto, envía un mensaje de error.
303 @end deffn
307 @deffn {Función} max (@var{x_1}, ..., @var{x_n})
308 Devuelve un valor simplificado de la mayor de las expresiones desde @var{x_1} hasta @var{x_n}.
309 Si @code{get (trylevel, maxmin)} es 2 o más, @code{max} aplica la simplificación
310 @code{max (e, -e) --> |e|}. Si @code{get (trylevel, maxmin)} es 3 o más, @var{max} intenta
311 eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo,
312 @code{max (x, 2*x, 3*x) --> max (x, 3*x)}. Para asignar el valor 2 a @code{trylevel} se puede hacer
313 @code{put (trylevel, 2, maxmin)}.
315 @end deffn
317 @deffn {Función} min (@var{x_1}, ..., @var{x_n})
318 Devuelve un valor simplificado de la menor de las expresiones desde @var{x_1} hasta @var{x_n}.
319 Si @code{get (trylevel, maxmin)} es 2 o más, @code{min} aplica la simplificación
320 @code{min (e, -e) --> |e|}. Si @code{get (trylevel, maxmin)} es 3 o más, @var{min} intenta
321 eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo,
322 @code{min (x, 2*x, 3*x) --> min (x, 3*x)}. Para asignar el valor 2 a @code{trylevel} se puede hacer
323 @code{put (trylevel, 2, maxmin)}.
325 @end deffn
329 @deffn {Función} round (@var{x})
330 Si @var{x} es un número real, la función devuelve el entero más
331 próximo a @var{x}. Los múltiplos de 1/2 se redondean al entero par más próximo.
332 La evaluación de @var{x} es similar a @code{floor} y @code{ceiling}.
334 @end deffn
338 @deffn {Función} signum (@var{x})
339 Tanto sea @var{x} real o complejo, la función @code{signum} devuelve 0 si @var{x}
340 es cero. Para un valor no nulo de @var{x}, la función devuelve @code{x/abs(x)}.
342 Para valores no numéricos de @var{x}, Maxima intenta determinar el
343 signo del argumento. Cuando es negativo, cero o positivo, @code{signum}
344 devuelve -1, 0 o 1, respectivamente. En caso de no poder determinarse,
345 @code{signum} devuelve una forma simplificada equivalente. Estas
346 simplificaciones incluyen la transformación de @code{signum(-x)}
347 en @code{-signum(x)} y la de @code{signum(x*y)} en
348 @code{signum(x) * signum(y)}.
350 La función @code{signum} es distributiva respecto de listas,
351 matrices o ecuaciones. Véase @code{distribute_over}.
353 @end deffn
362 @node Funciones para los números complejos, Funciones combinatorias, Funciones para los números, Funciones matemáticas
363 @section Funciones para los números complejos
366 @deffn {Función} cabs (@var{expr})
367 Calcula el valor absoluto de una expresión que representa a un número
368 complejo. Al contrario que @code{abs}, la función @code{cabs} siempre
369 descompone su argumento en sus partes real e imaginaria. Si @code{x} e
370 @code{y} representan variables o expresiones reales, la función @code{cabs}
371 calcula el valor absoluto de @code{x + %i*y} como
372 @example
373 2 2
374 sqrt(y + x )
375 @end example
377 La función @code{cabs} puede utilizar propiedades como la simetría
378 de funciones complejas para calcular el valor absoluto de una expresión.
380 @code{cabs} no es una función apropiada para cálculos simbólicos; en tales
381 casos, que incluyen la integración, diferenciación y límites que
382 contienen valores absolutos, es mejor utilizar @code{abs}.
384 El resultado devuelto por @code{cabs} puede incluir la función de valor absoluto,
385 @code{abs}, y el arco tangente, @code{atan2}.
387 Cuando se aplica a una lista o matriz, @code{cabs} automáticamente se distribuye
388 sobre sus elementos. También se distribuye sobre los dos miembros de una
389 igualdad.
391 Para otras formas de operar con números complejos, véanse las funciones
392 @code{rectform}, @code{realpart}, @code{imagpart}, @code{carg}, @code{conjugate}
393 y @code{polarform}.
395 Ejemplos:
397 Ejemplos con @code{sqrt} and @code{sin}:
399 @example
400 (%i1) cabs(sqrt(1+%i*x));
401 2 1/4
402 (%o1) (x + 1)
403 (%i2) cabs(sin(x+%i*y));
404 2 2 2 2
405 (%o2) sqrt(cos (x) sinh (y) + sin (x) cosh (y))
406 @end example
408 La simetría especular de la función de error @code{erf} se utiliza
409 para calcular el valor absoluto del argumento complejo:
411 @example
412 (%i3) cabs(erf(x+%i*y));
413 2
414 (erf(%i y + x) - erf(%i y - x))
415 (%o3) sqrt(--------------------------------
416 4
417 2
418 (erf(%i y + x) + erf(%i y - x))
419 - --------------------------------)
420 4
421 @end example
423 Dado que Maxima reconoce algunas identidades complejas de las funciones de
424 Bessel, le permite calcular su valor absoluto cuando tiene argumentos
425 complejos. Un ejemplo para @code{bessel_j}:
427 @example
428 (%i4) cabs(bessel_j(1,%i));
429 (%o4) abs(bessel_j(1, %i))
430 @end example
431 @end deffn
436 @deffn {Función} carg (@var{z})
437 Devuelve el argumento complejo de @var{z}.
438 El argumento complejo es un ángulo @code{theta} en @code{(-%pi, %pi]}
439 tal que @code{r exp (theta %i) = @var{z}} donde @code{r} es la magnitud de @var{z}.
441 La función @code{carg} es computacional, no simplificativa.
442 @c PROBABLY NEED TO EXPLAIN IMPLICATIONS OF ABOVE STATEMENT
444 Véanse también @code{abs} (módulo complejo), @code{polarform}, @code{rectform},
445 @code{realpart} y @code{imagpart}.
447 Ejemplos:
449 @c ===beg===
450 @c carg (1);
451 @c carg (1 + %i);
452 @c carg (exp (%i));
453 @c carg (exp (%pi * %i));
454 @c carg (exp (3/2 * %pi * %i));
455 @c carg (17 * exp (2 * %i));
456 @c ===end===
458 @example
459 (%i1) carg (1);
460 (%o1) 0
461 (%i2) carg (1 + %i);
462 %pi
463 (%o2) ---
464 4
465 (%i3) carg (exp (%i));
466 (%o3) 1
467 (%i4) carg (exp (%pi * %i));
468 (%o4) %pi
469 (%i5) carg (exp (3/2 * %pi * %i));
470 %pi
471 (%o5) - ---
472 2
473 (%i6) carg (17 * exp (2 * %i));
474 (%o6) 2
475 @end example
477 @end deffn
481 @deffn {Función} conjugate (@var{x})
482 Devuelve el conjugado complejo de @var{x}.
484 @c ===beg===
485 @c declare ([aa, bb], real, cc, complex, ii, imaginary);
486 @c conjugate (aa + bb*%i);
487 @c conjugate (cc);
488 @c conjugate (ii);
489 @c conjugate (xx + yy);
490 @c ===end===
491 @example
492 (%i1) declare ([aa, bb], real, cc, complex, ii, imaginary);
494 (%o1) done
495 (%i2) conjugate (aa + bb*%i);
497 (%o2) aa - %i bb
498 (%i3) conjugate (cc);
500 (%o3) conjugate(cc)
501 (%i4) conjugate (ii);
503 (%o4) - ii
504 (%i5) conjugate (xx + yy);
506 (%o5) conjugate(yy) + conjugate(xx)
507 @end example
509 @end deffn
513 @deffn {Función} imagpart (@var{expr})
514 Devuelve la parte imaginaria de la expresión @var{expr}.
516 La función @code{imagpart} es computacional,
517 no simplificativa.
518 @c PROBABLY NEED TO EXPLAIN IMPLICATIONS OF ABOVE STATEMENT
519 @c SEE ALSO SF BUG REPORT # 902290
521 Véanse también @code{abs}, @code{carg}, @code{polarform}, @code{rectform} y @code{realpart}.
523 @c NEED EXAMPLES HERE
524 @end deffn
528 @c NEEDS EXAMPLES
529 @deffn {Función} polarform (@var{expr})
530 Devuelve una expresión de la forma @code{r %e^(%i theta)} equivalente a @var{expr},
531 con @code{r} y @code{theta} son reales.
533 @end deffn
538 @c NEEDS EXAMPLES
539 @deffn {Función} realpart (@var{expr})
540 Devuelve la parte real de @var{expr}. La funciones @code{realpart} y @code{imagpart} operan también con expresiones que contengan funciones trigonométricas e hiperbólicas, raíces cuadradas, logaritmos y exponentes.
542 @end deffn
544 @c NEEDS EXAMPLES
545 @deffn {Función} rectform (@var{expr})
546 Devuelve una expresión de la forma @code{a + b %i} equivalente a @var{expr}, con @var{a} y @var{b} reales.
548 @end deffn
556 @node Funciones combinatorias, Funciones radicales exponenciales y logarítmicas, Funciones para los números complejos, Funciones matemáticas
557 @section Funciones combinatorias
561 @deffn {Operador} !!
562 @ifinfo
563 @fnindex Doble factorial
564 @end ifinfo
565 El operador doble factorial.
567 Para un número entero, de punto flotante o racional @code{n},
568 @code{n!!} se evaluará como el producto de @code{n (n-2) (n-4) (n-6) ... (n - 2 (k-1))}
569 donde @code{k} es igual a @code{entier(n/2)}, que es, el mayor entero
570 menor o igual a @code{n/2}.
571 Note que esta definición no coincide con otras definciones publicadas para argumentos, los cuales no son enteros.
573 @c REPORTED TO BUG TRACKER AS BUG # 1093138 !!!
575 Para un entero par (o impar) @code{n}, @code{n!} se evalua el producto de
576 todos los enteros pares (o impares) consecutivos desde 2 (o 1) por @code{n} inclusive.
578 Para un argumento @code{n} el cual no es un número entero, punto flotante o racional, @code{n!!} produce una forma de nombre @code{genfact (n, n/2, 2)}.
580 @c n!! IS NEITHER SIMPLIFIED NOR EVALUATED IN THIS CASE -- MENTION THAT? OR TOO MUCH DETAIL ???
582 @end deffn
587 @deffn {Función} binomial (@var{x}, @var{y})
588 Es el coeficiente binomial @code{@var{x}!/(@var{y}! (@var{x} - @var{y})!)}.
589 Si @var{x} y @var{y} son enteros, entonces se calcula el valor numérico
590 del coeficiente binomial. Si @var{y} o @var{x - y} son enteros,
591 el coeficiente binomial se expresa como un polinomio.
593 Ejemplos:
595 @c ===beg===
596 @c binomial (11, 7);
597 @c 11! / 7! / (11 - 7)!;
598 @c binomial (x, 7);
599 @c binomial (x + 7, x);
600 @c binomial (11, y);
601 @c ===end===
602 @example
603 (%i1) binomial (11, 7);
604 (%o1) 330
605 (%i2) 11! / 7! / (11 - 7)!;
606 (%o2) 330
607 (%i3) binomial (x, 7);
608 (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x
609 (%o3) -------------------------------------------------
610 5040
611 (%i4) binomial (x + 7, x);
612 (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7)
613 (%o4) -------------------------------------------------------
614 5040
615 (%i5) binomial (11, y);
616 (%o5) binomial(11, y)
617 @end example
618 @end deffn
622 @deffn {Función} factcomb (@var{expr})
623 Trata de combinar los coeficientes de los factoriales de @var{expr} con los mismos factoriales, convirtiendo, por ejemplo, @code{(n + 1)*n!} en @code{(n + 1)!}.
625 Si la variable @code{sumsplitfact} vale @code{false} hará que @code{minfactorial} se aplique después de @code{factcomb}.
627 @end deffn
631 @deffn {Función} factorial (@var{x})
632 @deffnx {Operador} !
634 Representa la función factorial. Maxima considera @code{factorial (@var{x})}
635 y @code{@var{x}!} como sinónimos.
637 Para cualquier número complejo @code{x}, excepto para
638 enteros negativos, @code{x!} se define como @code{gamma(x+1)}.
640 Para un entero @code{x}, @code{x!} se reduce al producto de los enteros
641 desde 1 hasta @code{x} inclusive. @code{0!} se reduce a 1.
642 Para un número real o complejo en formato de coma flotante @code{x},
643 @code{x!} se reduce al valor de @code{gamma(x+1)}. Cuando
644 @code{x} es igual a @code{n/2}, siendo @code{n} un entero impar, entonces
645 @code{x!} se reduce a un factor racional multiplicado por @code{sqrt(%pi)}
646 (pues @code{gamma(1/2)}) es igual a @code{sqrt(%pi)}).
648 Las variables opcionales @code{factlim} y @code{gammalim} controlan la
649 evaluación numérica de factoriales de argumentos enteros y racionales.
651 Las funciones @code{minfactorial} y @code{factcomb} simplifican expresiones
652 que contiene factoriales.
654 Véanse también @code{factlim}, @code{gammalim}, @code{minfactorial} y
655 @code{factcomb}.
657 Las funciones @code{gamma}, @code{bffac} y @code{cbffac} son variaciones de
658 la función matemática gamma. Las funciones @code{bffac} y @code{cbffac}
659 son llamadas internamente desde @code{gamma} para evaluar la función gamma
660 de números reales y complejos decimales con precisión de reales grandes
661 (bigfloats).
663 Las funciones @code{makegamma} substituye a @code{gamma} para factoriales
664 y funciones relacionadas.
666 Maxima reconoce la derivada de la función factorial y los límites
667 para ciertos valores específicos, tales como los enteros negativos.
669 La variable opcional @code{factorial_expand} controla la simplificación de
670 expresiones como @code{(n+x)!}, para @code{n} entero.
672 Véase también @code{binomial}.
674 Ejemplos:
676 El factorial de un entero se reduce a un número exacto, a menos que
677 el argumento sea mayor que @code{factlim}. Los factoriales de números
678 reales o complejos se evalúan como decimales de coma flotante.
680 @c ===beg===
681 @c factlim : 10;
682 @c [0!, (7/2)!, 8!, 20!];
683 @c [4,77!, (1.0+%i)!];
684 @c [2.86b0!, 1.0b0+%i)!];
685 @c ===end===
686 @example
687 (%i1) factlim:10;
688 (%o1) 10
689 (%i2) [0!, (7/2)!, 8!, 20!];
690 105 sqrt(%pi)
691 (%o2) [1, -------------, 40320, 20!]
692 16
693 (%i3) [4.77!, (1.0+%i)!];
694 (%o3) [81.44668037931197,
695 .3430658398165454 %i + .6529654964201665]
696 (%i4) [2.86b0!, (1.0b0+%i)!];
697 (%o4) [5.046635586910012b0,
698 3.430658398165454b-1 %i + 6.529654964201667b-1]
699 @end example
701 El factorial de una constante conocida o de una expresión general
702 no se calcula. Pero puede ser posible reducir el factorial después de
703 evaluado el argumento.
705 @c ===beg===
706 @c [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
707 @c ev (%, numer, %enumer);
708 @c ===end===
709 @example
710 (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
711 (%o1) [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
712 (%i2) ev (%, numer, %enumer);
713 (%o2) [.3430658398165454 %i + .6529654964201665,
714 7.188082728976031,
715 4.260820476357003, 1.227580202486819]
716 @end example
718 Los factoriales son simplificados o reducidos, no evaluados.
719 Así @code{x!} puede ser reemplazado en una expresión
720 nominal.
722 @c ===beg===
723 @c '([0!, (7/2)!, 4.77!, 8!, 20!]);
724 @c ===end===
725 @example
726 (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
727 105 sqrt(%pi)
728 (%o1) [1, -------------, 81.44668037931199, 40320,
729 16
730 2432902008176640000]
731 @end example
733 Maxima reconoce la derivada de la función factorial.
735 @c ===beg===
736 @c diff(x!,x);
737 @c ===end===
738 @example
739 (%i1) diff(x!,x);
740 (%o1) x! psi (x + 1)
741 0
742 @end example
744 La variable opcional @code{factorial_expand} controla la simplificación de
745 expresiones con la función factorial.
747 @c ===beg===
748 @c (n+1)!/n!,factorial_expand:true;
749 @c ===end===
750 @example
751 (%i1) (n+1)!/n!,factorial_expand:true;
752 (%o1) n + 1
753 @end example
754 @end deffn
758 @defvr {Variable opcional} factlim
759 Valor por defecto: -1
761 La variable @code{factlim} especifica el mayor factorial que será expandido automáticamente. Si su valor es -1, entonces se expandirán todos los enteros.
763 @end defvr
767 @defvr {Variable opcional} factorial_expand
768 Valor por defecto: false
770 La variable @code{factorial_expand} controla la simplificación
771 de expresiones tales como @code{(n+1)!}, siendo @code{n} un entero.
773 Véase @code{!} para un ejemplo.
775 @end defvr
779 @c IS THIS DEFINITION CORRECT ??
780 @deffn {Función} genfact (@var{x}, @var{y}, @var{z})
781 Devuelve el factorial generalizado, definido como
782 @code{x (x-z) (x - 2 z) ... (x - (y - 1) z)}. Así, para el entero @var{x},
783 @code{genfact (x, x, 1) = x!} y @code{genfact (x, x/2, 2) = x!!}.
785 @end deffn
789 @deffn {Función} minfactorial (@var{expr})
791 Busca en @var{expr} la presencia de dos factoriales que solo se
792 diferencien en una unidad; en tal caso, @code{minfactorial}
793 devuelve una expresión simplificada.
795 @example
796 (%i1) n!/(n+2)!;
797 n!
798 (%o1) --------
799 (n + 2)!
800 (%i2) minfactorial (%);
801 1
802 (%o2) ---------------
803 (n + 1) (n + 2)
804 @end example
806 @end deffn
809 @defvr {Variable opcional} sumsplitfact
810 Valor por defecto: @code{true}
812 Si @code{sumsplitfact} vale @code{false},
813 @c "IS APPLIED" -- UNDER WHAT CIRCUMSTANCES EXACTLY ??
814 @code{minfactorial} se aplica después de @code{factcomb}.
816 @end defvr
826 @node Funciones radicales exponenciales y logarítmicas, Funciones trigonométricas, Funciones combinatorias, Funciones matemáticas
827 @section Funciones radicales, exponenciales y logarítmicas
830 @defvr {Variable opcional} %e_to_numlog
831 Valor por defecto: @code{false}
833 Si @code{%e_to_numlog} vale @code{true}, @code{r} es un número racional y @code{x} una expresión, @code{%e^(r*log(x))} se reduce a @code{x^r} . Téngase en cuenta que la instrucción @code{radcan} también hace este tipo de transformaciones, así como otras más complicadas. La instrucción @code{logcontract} "contrae" expresiones que contienen algún @code{log}.
834 @end defvr
837 @defvr {Variable opcional} %emode
838 Valor por defecto: @code{true}
840 Si @code{%emode} vale @code{true},
841 @code{%e^(%pi %i x)} se simplifica como sigue.
843 @code{%e^(%pi %i x)} se simplifica a @code{cos (%pi x) + %i sin (%pi x)} si @code{x} es
844 un número decimal de coma flotante, un entero o un múltiplo de 1/2, 1/3, 1/4 o 1/6, y luego se sigue simplificando.
846 Para otros valores numéricos de @code{x},
847 @code{%e^(%pi %i x)} se simplifica a @code{%e^(%pi %i y)} donde @code{y} es @code{x - 2 k}
848 para algún entero @code{k} tal que @code{abs(y) < 1}.
850 Si @code{%emode} vale @code{false}, no se realizan simplificaciones especiales a @code{%e^(%pi %i x)}.
852 @c NEED EXAMPLES HERE
853 @end defvr
856 @defvr {Variable opcional} %enumer
857 Valor por defecto: @code{false}
859 Si la variable @code{%enumer} vale @code{true} hace que @code{%e} se reemplace por
860 2.718... siempre que @code{numer} valga @code{true}.
862 Si @code{%enumer} vale @code{false}, esta sustitución se realiza sólo si el exponente en @code{%e^x} tiene un valor numérico.
864 Véanse también @code{ev} y @code{numer}.
866 @c NEED EXAMPLES HERE
867 @end defvr
872 @deffn {Función} exp (@var{x})
873 Representa la función exponencial.
874 La expresión @code{exp (@var{x})} en la entrada se simplifica en @code{%e^@var{x}};
875 @code{exp} no aparece en expresiones simplificadas.
877 Si la variable @code{demoivre} vale @code{true} hace que @code{%e^(a + b %i)} se simplifique a
878 @code{%e^(a (cos(b) + %i sin(b)))} si @code{b} no contiene a @code{%i}. Véase @code{demoivre}.
880 Si la variable @code{%emode} vale @code{true},
881 hace que @code{%e^(%pi %i x)} se simplifique. Véase @code{%emode}.
883 Si la variable @code{%enumer} vale @code{true} hace que @code{%e} se reemplace por
884 2.718... siempre que @code{numer} valga @code{true}. Véase @code{%enumer}.
886 @end deffn
890 @deffn {Función} li [@var{s}] (@var{z})
892 Representa la función polilogarítmica de orden @var{s} y argumento @var{z},
893 definida por la serie infinita
895 @tex
896 $${\rm Li}_s \left(z\right) = \sum_{k=1}^\infty {z^k \over k^s}$$
897 @end tex
898 @ifnottex
899 @example
900 inf
901 ==== k
902 \ z
903 Li (z) = > --
904 s / s
905 ==== k
906 k = 1
907 @end example
908 @end ifnottex
910 @code{li [1]} es @code{- log (1 - z)}.
911 @code{li [2]} y @code{li [3]} son las funciones di- y trilogaritmo, respectivamente.
913 Cuando el orden es 1, el polilogaritmo se simplifica a @code{- log (1 - z)},
914 el cual a su vez se reduce a un valor numérico si @var{z} es un número
915 real o complejo en coma flotante o si está presente el término @code{numer}.
917 Cuando el orden es 2 ó 3,
918 el polilogaritmo se reduce a un valor numérico si @var{z} es
919 un número real en coma flotante o si está presente el término @code{numer}.
921 Ejemplos:
923 @c ===beg===
924 @c assume (x > 0);
925 @c integrate ((log (1 - t)) / t, t, 0, x);
926 @c li [2] (7);
927 @c li [2] (7), numer;
928 @c li [3] (7);
929 @c li [2] (7), numer;
930 @c L : makelist (i / 4.0, i, 0, 8);
931 @c map (lambda ([x], li [2] (x)), L);
932 @c map (lambda ([x], li [3] (x)), L);
933 @c ===end===
934 @example
935 (%i1) assume (x > 0);
936 (%o1) [x > 0]
937 (%i2) integrate ((log (1 - t)) / t, t, 0, x);
938 (%o2) - li (x)
939 2
940 (%i3) li [2] (7);
941 (%o3) li (7)
942 2
943 (%i4) li [2] (7), numer;
944 (%o4) 1.24827317833392 - 6.113257021832577 %i
945 (%i5) li [3] (7);
946 (%o5) li (7)
947 3
948 (%i6) li [2] (7), numer;
949 (%o6) 1.24827317833392 - 6.113257021832577 %i
950 (%i7) L : makelist (i / 4.0, i, 0, 8);
951 (%o7) [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
952 (%i8) map (lambda ([x], li [2] (x)), L);
953 (%o8) [0, .2676526384986274, .5822405249432515,
954 .9784693966661848, 1.64493407, 2.190177004178597
955 - .7010261407036192 %i, 2.374395264042415
956 - 1.273806203464065 %i, 2.448686757245154
957 - 1.758084846201883 %i, 2.467401098097648
958 - 2.177586087815347 %i]
959 (%i9) map (lambda ([x], li [3] (x)), L);
960 (%o9) [0, .2584613953442624, 0.537213192678042,
961 .8444258046482203, 1.2020569, 1.642866878950322
962 - .07821473130035025 %i, 2.060877505514697
963 - .2582419849982037 %i, 2.433418896388322
964 - .4919260182322965 %i, 2.762071904015935
965 - .7546938285978846 %i]
966 @end example
968 @end deffn
973 @deffn {Función} log (@var{x})
974 Representa el logaritmo natural (en base @math{e}) de @var{x}.
976 Maxima no tiene definida una función para el logaritmo de base 10 u
977 otras bases. El usuario puede hacer uso de la definición
978 @code{log10(x) := log(x) / log(10)}.
980 La simplificación y evaluación de logaritmos se controla con
981 ciertas variables globales:
983 @table @code
984 @item @code{logexpand}
985 hace que @code{log(a^b)} se convierta en @code{b*log(a)}.
986 Si toma el valor @code{all}, @code{log(a*b)} también se reducirá a @code{log(a)+log(b)}.
987 Si toma el valor @code{super}, entonces @code{log(a/b)} también se reducirá a
988 @code{log(a)-log(b)}, siendo @code{a/b} racional con @code{a#1},
989 (la expresión @code{log(1/b)}, para @code{b} entero, se simplifica siempre).
990 Si toma el valor @code{false}, se desactivarán todas estas simplificaciones.
992 @item @code{logsimp}
993 si vale @code{false}, entonces no se transforma @code{%e} a potencias que contengan logaritmos.
995 @item @code{lognegint}
996 si vale @code{true} se aplica la regla @code{log(-n)} -> @code{log(n)+%i*%pi},
997 siendo @code{n} un entero positivo.
999 @item @code{%e_to_numlog}
1000 si vale @code{true}, @code{r} es un número racional y @code{x} una expresión,
1001 @code{%e^(r*log(x))} se reduce a @code{x^r}. Téngase en cuenta que la
1002 instrucción @code{radcan} también hace este tipo de transformaciones,
1003 así como otras más complicadas. La instrucción @code{logcontract}
1004 "contrae" expresiones que contengan algún @code{log}.
1005 @end table
1007 @end deffn
1011 @defvr {Variable opcional} logabs
1012 Valor por defecto: @code{false}
1014 Cuando se calculan integrales indefinidas en las que se generan logaritmos, como en @code{integrate(1/x,x)}, el resultado se devuelve de la forma @code{log(abs(...))} si @code{logabs} vale @code{true}, o de la forma @code{log(...)} si
1015 @code{logabs} vale @code{false}. En la integración definida se hace la asignación @code{logabs:true}, ya que aquí es normalmente necesario evaluar la integral indefinida en los extremos del intervalo de integración.
1017 @end defvr
1019 @c NEEDS EXAMPLES
1020 @defvr {Variable opcional} logarc
1021 @defvrx {Función} logarc (@var{expr})
1023 Si la variable global @code{logarc} toma el valor @code{true},
1024 las funciones circulares e hiperbólicas inversas se
1025 reemplazan por funciones logarítmicas equivalentes.
1026 El valor por defecto de @code{logarc} es @code{false}.
1028 La función @code{logarc(@var{expr})} realiza la anterior transformación
1029 en la expresión @var{expr} sin necesidad de alterar el valor de la
1030 variable global @code{logarc}.
1032 @end defvr
1036 @defvr {Variable opcional} logconcoeffp
1037 Valor por defecto: @code{false}
1039 Controla qué coeficientes se contraen cuando se utiliza @code{logcontract}. Se le puede asignar el nombre de una función de predicado de un argumento; por ejemplo, si se quiere introducir raíces cuadradas, se puede hacer @code{logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$} . Entonces
1040 @code{logcontract(1/2*log(x));} devolverá @code{log(sqrt(x))}.
1042 @end defvr
1044 @deffn {Función} logcontract (@var{expr})
1045 Analiza la expresión @var{expr} recursivamente, transformando subexpresiones de la forma @code{a1*log(b1) + a2*log(b2) + c} en @code{log(ratsimp(b1^a1 * b2^a2)) + c}
1047 @c ===beg===
1048 @c 2*(a*log(x) + 2*a*log(y))$
1049 @c logcontract(%);
1050 @c ===end===
1051 @example
1052 (%i1) 2*(a*log(x) + 2*a*log(y))$
1053 (%i2) logcontract(%);
1054 2 4
1055 (%o2) a log(x y )
1057 @end example
1059 Si se hace @code{declare(n,integer);} entonces @code{logcontract(2*a*n*log(x));} da
1060 @code{a*log(x^(2*n))}. Los coeficientes que se contraen de esta manera son aquellos que como el 2 y el @code{n} satisfacen
1061 @code{featurep(coeff,integer)}. El usuario puede controlar qué coeficientes se contraen asignándole a la variable global @code{logconcoeffp} el nombre de una función de predicado de un argumento; por ejemplo, si se quiere introducir raíces cuadradas, se puede hacer @code{logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$} . Entonces @code{logcontract(1/2*log(x));} devolverá @code{log(sqrt(x))}.
1063 @end deffn
1066 @defvr {Variable opcional} logexpand
1067 Valor por defecto: @code{true}
1069 Si @code{logexpand} vale @code{true} hace que @code{log(a^b)} se convierta
1070 en @code{b*log(a)}. Si toma el valor @code{all}, @code{log(a*b)} también se
1071 reducirá a @code{log(a)+log(b)}. Si toma el valor @code{super}, entonces
1072 @code{log(a/b)} también se reducirá a @code{log(a)-log(b)}, siendo
1073 @code{a/b} racional con @code{a#1}, (la expresión @code{log(1/b)}, para
1074 @code{b} entero, se simplifica siempre). Si toma el valor @code{false},
1075 se desactivarán todas estas simplificaciones.
1076 @end defvr
1080 @defvr {Variable opcional} lognegint
1081 Valor por defecto: @code{false}
1083 Si @code{lognegint} vale @code{true} se aplica la regla @code{log(-n)} -> @code{log(n)+%i*%pi} siendo @code{n} un entero positivo.
1085 @end defvr
1089 @defvr {Variable opcional} logsimp
1090 Valor por defecto: @code{true}
1092 Si @code{logsimp} vale @code{false}, entonces no se transforma @code{%e} a potencias que contengan logaritmos.
1094 @end defvr
1098 @deffn {Función} plog (@var{x})
1099 Representa la rama principal del logaritmo natural complejo con @code{-%pi} < @code{carg(@var{x})} <= @code{+%pi} .
1101 @end deffn
1105 @deffn {Función} sqrt (@var{x})
1106 Raíz cuadrada de @var{x}. Se representa internamente por @code{@var{x}^(1/2)}. Véase también @code{rootscontract}.
1108 Si la variable @code{radexpand} vale @code{true} hará que las raíces @code{n}-ésimas de los factores de un producto que sean potencias de @code{n} sean extraídas del radical; por ejemplo, @code{sqrt(16*x^2)} se convertirá en @code{4*x} sólo si @code{radexpand} vale @code{true}.
1110 @end deffn
1120 @node Funciones trigonométricas, Números aleatorios, Funciones radicales exponenciales y logarítmicas, Funciones matemáticas
1121 @section Funciones trigonométricas
1124 @menu
1125 * Introducción a la trigonometría::
1126 * Funciones y variables para trigonometría::
1127 @end menu
1130 @node Introducción a la trigonometría, Funciones y variables para trigonometría, Funciones trigonométricas, Funciones trigonométricas
1131 @subsection Introducción a la trigonometría
1134 Maxima reconoce muchas funciones trigonométricas. No están programadas todas las identidades trigonométricas, pero el usuario puede añadir muchas de ellas haciendo uso de las técnicas basadas en patrones. Las funciones trigonométricas definidas en Maxima son: @code{acos},
1135 @code{acosh}, @code{acot}, @code{acoth}, @code{acsc},
1136 @code{acsch}, @code{asec}, @code{asech}, @code{asin},
1137 @code{asinh}, @code{atan}, @code{atanh}, @code{cos},
1138 @code{cosh}, @code{cot}, @code{coth}, @code{csc}, @code{csch},
1139 @code{sec}, @code{sech}, @code{sin}, @code{sinh}, @code{tan} y
1140 @code{tanh}. Hay también un determinado número de instrucciones especiales para manipular funciones trigonométricas; véanse a este respecto @code{trigexpand},
1141 @code{trigreduce} y la variable @code{trigsign}. Dos paquetes adicionales amplían las reglas de simplificación de Maxima, @code{ntrig} y @code{atrig1}. Ejecútese @code{describe(@var{command})} para más detalles.
1150 @node Funciones y variables para trigonometría, , Introducción a la trigonometría, Funciones trigonométricas
1151 @subsection Funciones y variables para trigonometría
1156 @defvr {Variable opcional} %piargs
1157 Valor por defecto: @code{true}
1159 Cuando @code{%piargs} vale @code{true}, las funciones trigonométricas
1160 se simplifican a constantes algebraicas cuando el argumento es múltiplo
1161 entero de
1162 @iftex
1163 @math{\pi}, @math{\pi/2}, @math{\pi/3}, @math{\pi/4} o @math{\pi/6}.
1164 @end iftex
1165 @ifnottex
1166 @math{%pi}, @math{%pi/2}, @math{%pi/3}, @math{%pi/4} o @math{%pi/6}.
1167 @end ifnottex
1169 @iftex
1170 Maxima conoce algunas identidades aplicables cuando @math{\pi}, etc.,
1171 @end iftex
1172 @ifnottex
1173 Maxima conoce algunas identidades aplicables cuando @math{%pi}, etc.,
1174 @end ifnottex
1175 se multiplican por una variable entera (esto es, un símbolo
1176 declarado como entero).
1178 Ejemplo:
1180 @c ===beg===
1181 @c %piargs : false$
1182 @c [sin (%pi), sin (%pi/2), sin (%pi/3)];
1183 @c [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
1184 @c %piargs : true$
1185 @c [sin (%pi), sin (%pi/2), sin (%pi/3)];
1186 @c [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
1187 @c [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3),
1188 @c cos (sqrt(2)*%pi/3)];
1189 @c ===end===
1190 @example
1191 (%i1) %piargs : false$
1192 @group
1193 (%i2) [sin (%pi), sin (%pi/2), sin (%pi/3)];
1194 %pi %pi
1195 (%o2) [sin(%pi), sin(---), sin(---)]
1196 2 3
1197 @end group
1198 @group
1199 (%i3) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
1200 %pi %pi %pi
1201 (%o3) [sin(---), sin(---), sin(---)]
1202 4 5 6
1203 @end group
1204 (%i4) %piargs : true$
1205 @group
1206 (%i5) [sin (%pi), sin (%pi/2), sin (%pi/3)];
1207 sqrt(3)
1208 (%o5) [0, 1, -------]
1209 2
1210 @end group
1211 @group
1212 (%i6) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
1213 1 %pi 1
1214 (%o6) [-------, sin(---), -]
1215 sqrt(2) 5 2
1216 @end group
1217 @group
1218 (%i7) [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3),
1219 cos (sqrt(2)*%pi/3)];
1220 1 1 sqrt(2) %pi
1221 (%o7) [-, - -, sqrt(3), cos(-----------)]
1222 2 2 3
1223 @end group
1224 @end example
1227 @iftex
1228 Se aplican ciertas identidades cuando @math{\pi} o @math{\pi/2} se multiplican por una variable entera.
1229 @end iftex
1230 @ifnottex
1231 Se aplican ciertas identidades cuando @math{%pi} o @math{%pi/2} se multiplican por una variable entera.
1232 @end ifnottex
1234 @c ===beg===
1235 @c declare (n, integer, m, even)$
1236 @c [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m),
1237 @c cos (%pi/2 * m)];
1238 @c ===end===
1239 @example
1240 (%i1) declare (n, integer, m, even)$
1241 @group
1242 (%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m),
1243 cos (%pi/2 * m)];
1244 m/2
1245 (%o2) [0, 1, 0, (- 1) ]
1246 @end group
1247 @end example
1249 @end defvr
1254 @defvr {Variable opcional} %iargs
1255 Valor por defecto: @code{true}
1257 Cuando @code{%iargs} vale @code{true}, las funciones trigonométricas
1258 se simplifican a funciones hiperbólicas
1259 @iftex
1260 si el argumento es aparentemente un múltiplo de la unidad imaginaria @math{i}.
1261 @end iftex
1262 @ifnottex
1263 si el argumento es aparentemente un múltiplo de la unidad imaginaria @math{%i}.
1264 @end ifnottex
1266 La simplificación se lleva a cabo incluso cuando el argumento es manifiestamente real;
1267 @iftex
1268 Maxima sólo se fija en si el argumento es un múltiplo literal de @math{i}.
1269 @end iftex
1270 @ifnottex
1271 Maxima sólo se fija en si el argumento es un múltiplo literal de @math{%i}.
1272 @end ifnottex
1274 Ejemplos:
1276 @c ===beg===
1277 @c %iargs : false$
1278 @c [sin (%i * x), cos (%i * x), tan (%i * x)];
1279 @c %iargs : true$
1280 @c [sin (%i * x), cos (%i * x), tan (%i * x)];
1281 @c ===end===
1282 @example
1283 (%i1) %iargs : false$
1284 @group
1285 (%i2) [sin (%i * x), cos (%i * x), tan (%i * x)];
1286 (%o2) [sin(%i x), cos(%i x), tan(%i x)]
1287 @end group
1288 (%i3) %iargs : true$
1289 @group
1290 (%i4) [sin (%i * x), cos (%i * x), tan (%i * x)];
1291 (%o4) [%i sinh(x), cosh(x), %i tanh(x)]
1292 @end group
1293 @end example
1295 La simplificación se aplica incluso en el caso de que
1296 el argumento se reduzca a un número real.
1298 @c ===beg===
1299 @c declare (x, imaginary)$
1300 @c [featurep (x, imaginary), featurep (x, real)];
1301 @c sin (%i * x);
1302 @c ===end===
1303 @example
1304 (%i1) declare (x, imaginary)$
1305 @group
1306 (%i2) [featurep (x, imaginary), featurep (x, real)];
1307 (%o2) [true, false]
1308 @end group
1309 @group
1310 (%i3) sin (%i * x);
1311 (%o3) %i sinh(x)
1312 @end group
1313 @end example
1315 @end defvr
1321 @deffn {Function} acos (@var{x})
1322 Arco coseno.
1324 @end deffn
1326 @deffn {Función} acosh (@var{x})
1327 Arco coseno hiperbólico.
1329 @end deffn
1331 @deffn {Función} acot (@var{x})
1332 Arco cotangente.
1334 @end deffn
1336 @deffn {Función} acoth (@var{x})
1337 Arco cotangente hiperbólica.
1339 @end deffn
1341 @deffn {Función} acsc (@var{x})
1342 Arco cosecante.
1344 @end deffn
1346 @deffn {Función} acsch (@var{x})
1347 Arco cosecante hiperbólica.
1349 @end deffn
1351 @deffn {Función} asec (@var{x})
1352 Arco secante.
1354 @end deffn
1356 @deffn {Función} asech (@var{x})
1357 Arco secante hiperbólica.
1359 @end deffn
1361 @deffn {Función} asin (@var{x})
1362 Arco seno.
1364 @end deffn
1366 @deffn {Función} asinh (@var{x})
1367 Arco seno hiperbólico.
1369 @end deffn
1371 @deffn {Función} atan (@var{x})
1372 Arco tangente.
1374 @end deffn
1376 @deffn {Función} atan2 (@var{y}, @var{x})
1377 Calcula el valor de @code{atan(@var{y}/@var{x})} en el intervalo de @code{-%pi} a @code{%pi}.
1379 @end deffn
1381 @deffn {Función} atanh (@var{x})
1382 Arco tangente hiperbólica.
1384 @end deffn
1386 @defvr {Paquete} atrig1
1387 El paquete @code{atrig1} contiene ciertas reglas de simplificación adicionales para las funciones trigonométricas inversas. Junto con las reglas que ya conoce Maxima, los siguientes ángulos están completamente implementados:
1388 @code{0}, @code{%pi/6}, @code{%pi/4}, @code{%pi/3} y @code{%pi/2}.
1389 Los ángulos correspondientes en los otros tres cuadrantes también están disponibles.
1390 Para hacer uso de estas reglas, ejecútese @code{load("atrig1");}.
1392 @end defvr
1394 @deffn {Función} cos (@var{x})
1395 Coseno.
1397 @end deffn
1399 @deffn {Función} cosh (@var{x})
1400 Coseno hiperbólico.
1402 @end deffn
1404 @deffn {Función} cot (@var{x})
1405 Cotangente.
1407 @end deffn
1409 @deffn {Función} coth (@var{x})
1410 Cotangente hiperbólica.
1412 @end deffn
1414 @deffn {Función} csc (@var{x})
1415 Cosecante.
1417 @end deffn
1419 @deffn {Función} csch (@var{x})
1420 Cosecante hiperbólica.
1422 @end deffn
1425 @defvr {Variable opcional} halfangles
1426 Valor por defecto: @code{false}
1428 Si @code{halfangles} vale @code{true}, las funciones
1429 trigonométricas con argumentos del tipo @code{@var{expr}/2}
1430 se simplifican a funciones con argumentos @var{expr}.
1432 Para un argumento real @var{x} en el intervalo @code{0 < x < 2*%pi}
1433 el seno del semiángulo se simplifica como
1435 @example
1436 sqrt(1 - cos(x))
1437 ----------------
1438 sqrt(2)
1439 @end example
1441 Se necesita un factor relativamente complicado para que esta fórmula
1442 sea también válida para cualquier argumento complejo @var{z}:
1444 @example
1445 realpart(z)
1446 floor(-----------)
1447 2 %pi
1448 (- 1) (1 - unit_step(- imagpart(z))
1450 realpart(z) realpart(z)
1451 floor(-----------) - ceiling(-----------)
1452 2 %pi 2 %pi
1453 ((- 1) + 1))
1454 @end example
1456 Maxima reconoce este factor y otros similares para las funciones @code{sin},
1457 @code{cos}, @code{sinh} y @code{cosh}. Para valores especiales del argumento
1458 @math{z}, estos factores se simplifican de forma apropiada.
1460 Ejemplos:
1462 @c ===beg===
1463 @c halfangles : false$
1464 @c sin (x / 2);
1465 @c halfangles : true$
1466 @c sin (x / 2);
1467 @c assume(x>0, x<2*%pi)$
1468 @c sin(x / 2);
1469 @c ===end===
1470 @example
1471 (%i1) halfangles:false;
1472 (%o1) false
1473 (%i2) sin(x/2);
1474 x
1475 (%o2) sin(-)
1476 2
1477 (%i3) halfangles:true;
1478 (%o3) true
1479 (%i4) sin(x/2);
1480 x
1481 floor(-----)
1482 2 %pi
1483 sqrt(1 - cos(x)) (- 1)
1484 (%o4) ----------------------------------
1485 sqrt(2)
1486 (%i5) assume(x>0, x<2*%pi)$
1487 (%i6) sin(x/2);
1488 sqrt(1 - cos(x))
1489 (%o6) ----------------
1490 sqrt(2)
1491 @end example
1493 @end defvr
1496 @defvr {Paquete} ntrig
1497 El paquete @code{ntrig} contiene un conjunto de reglas de simplificación que se pueden usar para simplificar funciones trigonométricas cuyos argumentos son de la forma
1498 @code{@var{f}(@var{n} %pi/10)} donde @var{f} es cualquiera de las funciones
1499 @code{sin}, @code{cos}, @code{tan}, @code{csc}, @code{sec} o @code{cot}.
1500 @c NEED TO LOAD THIS PACKAGE ??
1502 @end defvr
1504 @deffn {Función} sec (@var{x})
1505 Secante.
1507 @end deffn
1509 @deffn {Función} sech (@var{x})
1510 Secante hiperbólica.
1512 @end deffn
1514 @deffn {Función} sin (@var{x})
1515 Seno.
1517 @end deffn
1519 @deffn {Función} sinh (@var{x})
1520 Seno hiperbólico.
1522 @end deffn
1524 @deffn {Función} tan (@var{x})
1525 Tangente.
1527 @end deffn
1529 @deffn {Función} tanh (@var{x})
1530 Tangente hiperbólica.
1532 @end deffn
1534 @deffn {Función} trigexpand (@var{expr})
1535 Expande funciones trigonométricas e hiperbólicas de sumas de ángulos y de múltiplos de ángulos presentes en @var{expr}. Para mejorar los resultados, @var{expr} debería expandirse. Para facilitar el control por parte del usuario de las simplificaciones, esta función tan solo expande un nivel de cada vez, expandiendo sumas de ángulos o de múltiplos de ángulos. A fin de obtener una expansión completa en senos y coseno, se le dará a la variable @code{trigexpand} el valor @code{true}.
1537 La función @code{trigexpand} está controlada por las siguientes variables:
1539 @table @code
1540 @item trigexpand
1541 Si vale @code{true}, provoca la expansión de todas las expresiones que contengan senos y cosenos.
1542 @item trigexpandplus
1543 Controla la regla de la suma para @code{trigexpand}, la expansión de una suma como @code{sin(x + y)} se llevará a cabo sólo si @code{trigexpandplus} vale @code{true}.
1544 @item trigexpandtimes
1545 Controla la regla del producto para @code{trigexpand}, la expansión de un producto como @code{sin(2 x)} se llevará a cabo sólo si @code{trigexpandtimes} vale @code{true}.
1546 @end table
1548 Ejemplos:
1550 @c ===beg===
1551 @c x+sin(3*x)/sin(x),trigexpand=true,expand;
1552 @c trigexpand(sin(10*x+y));
1553 @c ===end===
1554 @example
1555 @group
1556 (%i1) x+sin(3*x)/sin(x),trigexpand=true,expand;
1557 2 2
1558 (%o1) - sin (x) + 3 cos (x) + x
1559 @end group
1560 @group
1561 (%i2) trigexpand(sin(10*x+y));
1562 (%o2) cos(10 x) sin(y) + sin(10 x) cos(y)
1563 @end group
1564 @end example
1566 @end deffn
1568 @defvr {Variable optativa} trigexpandplus
1569 Valor por defecto: @code{true}
1571 La variable @code{trigexpandplus} controla la regla de la suma para @code{trigexpand}. Así, si la instrucción @code{trigexpand} se utiliza o si la variable @code{trigexpand} vale @code{true}, se realizará la expansión de sumas como @code{sin(x+y)} sólo si @code{trigexpandplus} vale @code{true}.
1573 @end defvr
1575 @defvr {Variable optativa} trigexpandtimes
1576 Valor por defecto: @code{true}
1578 La variable @code{trigexpandtimes} controla la regla del producto para @code{trigexpand}. Así, si la instrucción @code{trigexpand} se utiliza o si la variable @code{trigexpand} vale @code{true}, se realizará la expansión de productos como @code{sin(2*x)} sólo si @code{trigexpandtimes} vale @code{true}.
1580 @end defvr
1582 @defvr {Variable optativa} triginverses
1583 Valor por defecto: @code{true}
1585 La variable @code{triginverses} controla la simplificación de la composición de funciones trigonométricas e hiperbólicas con sus funciones inversas.
1587 Si vale @code{all}, tanto @code{atan(tan(@var{x}))} como @code{tan(atan(@var{x}))} se reducen a @var{x}.
1589 Si vale @code{true}, se desactiva la simplificación de @code{@var{arcfun}(@var{fun}(@var{x}))}.
1591 Si vale @code{false}, se desactivan las simplificaciones de
1592 @code{@var{arcfun}(@var{fun}(@var{x}))} y
1593 @code{@var{fun}(@var{arcfun}(@var{x}))}.
1595 @end defvr
1597 @deffn {Función} trigreduce (@var{expr}, @var{x})
1598 @deffnx {Función} trigreduce (@var{expr})
1599 Combina productos y potencias de senos y cosenos trigonométricos e hiperbólicos de @var{x}, transformándolos en otros que son múltiplos de @var{x}. También intenta eliminar estas funciones cuando aparecen en los denominadores. Si no se introduce el argumento @var{x}, entonces se utilizan todas las variables de @var{expr}.
1601 Véase también @code{poissimp}.
1603 @c ===beg===
1604 @c trigreduce(-sin(x)^2+3*cos(x)^2+x);
1605 @c ===end===
1606 @example
1607 @group
1608 (%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x);
1609 cos(2 x) cos(2 x) 1 1
1610 (%o1) -------- + 3 (-------- + -) + x - -
1611 2 2 2 2
1612 @end group
1613 @end example
1616 Las rutinas de simplificación trigonométrica utilizan información declarada en algunos casos sencillos. Las declaraciones sobre variables se utilizan como se indica a continuación:
1618 @c ===beg===
1619 @c declare(j, integer, e, even, o, odd)$
1620 @c sin(x + (e + 1/2)*%pi);
1621 @c sin(x + (o + 1/2)*%pi);
1622 @c ===end===
1623 @example
1624 (%i1) declare(j, integer, e, even, o, odd)$
1625 (%i2) sin(x + (e + 1/2)*%pi);
1626 (%o2) cos(x)
1627 (%i3) sin(x + (o + 1/2)*%pi);
1628 (%o3) - cos(x)
1630 @end example
1632 @end deffn
1634 @defvr {Variable optativa} trigsign
1635 Valor por defecto: @code{true}
1637 Si @code{trigsign} vale @code{true}, se permite la simplificación de argumentos negativos en funciones trigonométricas, como en @code{sin(-x)}, que se transformará en @code{-sin(x)} sólo si @code{trigsign} vale @code{true}.
1639 @end defvr
1641 @deffn {Función} trigsimp (@var{expr})
1642 @iftex
1643 Utiliza las identidades
1644 @tex
1645 $\sin\left(x\right)^2 + \cos\left(x\right)^2 = 1$
1646 @end tex
1647 y
1648 @tex
1649 $\cosh\left(x\right)^2 - \sinh\left(x\right)^2 = 1$
1650 @end tex
1651 para simplificar expresiones que contienen @code{tan}, @code{sec},
1652 etc., en expresiones con @code{sin}, @code{cos}, @code{sinh}, @code{cosh}.
1653 @end iftex
1654 @ifnottex
1655 Utiliza las identidades @math{sin(x)^2 + cos(x)^2 = 1} y
1656 @math{cosh(x)^2 - sinh(x)^2 = 1} para simplificar expresiones que contienen @code{tan}, @code{sec},
1657 etc., en expresiones con @code{sin}, @code{cos}, @code{sinh}, @code{cosh}.
1658 @end ifnottex
1660 Las funciones @code{trigreduce}, @code{ratsimp} y @code{radcan} puden seguir siendo útiles para continuar el proceso de simplificación.
1662 La instrucción @code{demo ("trgsmp.dem")} muestra algunos ejemplos de @code{trigsimp}.
1663 @c MERGE EXAMPLES INTO THIS ITEM
1665 @end deffn
1667 @deffn {Función} trigrat (@var{expr})
1668 Devuelve una forma canónica simplificada cuasi-lineal de una expresión trigonométrica;
1669 @var{expr} es una fracción racional que contiene @code{sin}, @code{cos} o @code{tan},
1670 cuyos argumentos son formas lineales respecto de ciertas variables (o kernels) y @code{%pi/@var{n}}
1671 (@var{n} entero) con coeficientes enteros. El resultado es una fracción simplificada con
1672 el numerador y denominador lineales respecto de @code{sin} y @code{cos}. Así,
1673 @code{trigrat} devuelve una expresión lineal siempre que sea posible.
1675 @c ===beg===
1676 @c trigrat(sin(3*a)/sin(a+%pi/3));
1677 @c ===end===
1678 @example
1679 @group
1680 (%i1) trigrat(sin(3*a)/sin(a+%pi/3));
1681 (%o1) sqrt(3) sin(2 a) + cos(2 a) - 1
1682 @end group
1683 @end example
1685 El siguiente ejemplo se ha tomado de
1686 Davenport, Siret y Tournier, @i{Calcul Formel}, Masson (o en inglés,
1687 Addison-Wesley), sección 1.5.5, teorema de Morley.
1689 @c ===beg===
1690 @c c : %pi/3 - a - b$
1691 @c bc : sin(a)*sin(3*c)/sin(a+b);
1692 @c ba : bc, c=a, a=c;
1693 @c ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b);
1694 @c trigrat (ac2);
1695 @c ===end===
1696 @example
1697 (%i1) c : %pi/3 - a - b$
1698 @group
1699 (%i2) bc : sin(a)*sin(3*c)/sin(a+b);
1700 %pi
1701 sin(a) sin(3 (- b - a + ---))
1702 3
1703 (%o2) -----------------------------
1704 sin(b + a)
1705 @end group
1706 @group
1707 (%i3) ba : bc, c=a, a=c;
1708 %pi
1709 sin(3 a) sin(b + a - ---)
1710 3
1711 (%o3) -------------------------
1712 %pi
1713 sin(a - ---)
1714 3
1715 @end group
1716 @group
1717 (%i4) ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b);
1718 2 2 %pi
1719 sin (3 a) sin (b + a - ---)
1720 3
1721 (%o4) ---------------------------
1722 2 %pi
1723 sin (a - ---)
1724 3
1725 %pi
1726 - (2 sin(a) sin(3 a) sin(3 (- b - a + ---)) cos(b)
1727 3
1728 %pi %pi
1729 sin(b + a - ---))/(sin(a - ---) sin(b + a))
1730 3 3
1731 2 2 %pi
1732 sin (a) sin (3 (- b - a + ---))
1733 3
1734 + -------------------------------
1735 2
1736 sin (b + a)
1737 @end group
1738 @group
1739 (%i5) trigrat (ac2);
1740 (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a)
1741 - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a)
1742 - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a)
1743 + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a)
1744 + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b)
1745 + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a)
1746 - 9)/4
1747 @end group
1748 @end example
1750 @end deffn
1759 @node Números aleatorios, , Funciones trigonométricas, Funciones matemáticas
1760 @section Números aleatorios
1764 @deffn {Función} make_random_state (@var{n})
1765 @deffnx {Función} make_random_state (@var{s})
1766 @deffnx {Función} make_random_state (true)
1767 @deffnx {Función} make_random_state (false)
1769 Un objeto de estado aleatorio representa el estado del generador de números aleatorios. El estado consiste en 627 cadenas binarias de 32 bits.
1771 La llamada @code{make_random_state (@var{n})} devuelve un nuevo objeto de estado aleatorio creado a partir de una semilla entera igual a @var{n} módulo 2^32. El argumento @var{n} puede ser negativo.
1773 La llamada @code{make_random_state (@var{s})} devuelve una copia del estado aleatorio @var{s}.
1775 La llamada @code{make_random_state (true)} devuelve un nuevo objeto de estado aleatorio, cuya semilla se genera a partir de la hora actual del reloj del sistema como semilla.
1777 La llamada @code{make_random_state (false)} devuelve una copia del estado actual del generador de números aleatorios.
1779 @end deffn
1783 @deffn {Función} set_random_state (@var{s})
1784 Establece @var{s} como estado del generador de números aleatorios.
1786 La función @code{set_random_state} devuelve @code{done} en todo caso.
1788 @end deffn
1792 @deffn {Función} random (@var{x})
1793 Devuelve un número seudoaleatorio. Si @var{x} es un entero, @code{random (@var{x})} devuelve un
1794 entero entre 0 y @code{@var{x} - 1}, ambos inclusive. Si @var{x} es un decimal en punto flotante,
1795 @code{random (@var{x})} devuelve un decimal no negativo en punto flotante menor que @var{x}.
1796 La función @code{random} emite un mensaje de error si @var{x} no es ni entero ni de punto flotante,
1797 o si @var{x} no es positivo.
1799 Las funciones @code{make_random_state} y @code{set_random_state}
1800 permiten controlar el estado del generador de números aleatorios.
1802 El generador de números aleatorios de Maxima implementa el algoritmo de Mersenne twister MT 19937.
1804 Ejemplos:
1806 @c ===beg===
1807 @c s1: make_random_state (654321)$
1808 @c set_random_state (s1);
1809 @c random (1000);
1810 @c random (9573684);
1811 @c random (2^75);
1812 @c s2: make_random_state (false)$
1813 @c random (1.0);
1814 @c random (10.0);
1815 @c random (100.0);
1816 @c set_random_state (s2);
1817 @c random (1.0);
1818 @c random (10.0);
1819 @c random (100.0);
1820 @c ===end===
1821 @example
1822 (%i1) s1: make_random_state (654321)$
1823 (%i2) set_random_state (s1);
1824 (%o2) done
1825 (%i3) random (1000);
1826 (%o3) 768
1827 (%i4) random (9573684);
1828 (%o4) 7657880
1829 (%i5) random (2^75);
1830 (%o5) 11804491615036831636390
1831 (%i6) s2: make_random_state (false)$
1832 (%i7) random (1.0);
1833 (%o7) .2310127244107132
1834 (%i8) random (10.0);
1835 (%o8) 4.394553645870825
1836 (%i9) random (100.0);
1837 (%o9) 32.28666704056853
1838 (%i10) set_random_state (s2);
1839 (%o10) done
1840 (%i11) random (1.0);
1841 (%o11) .2310127244107132
1842 (%i12) random (10.0);
1843 (%o12) 4.394553645870825
1844 (%i13) random (100.0);
1845 (%o13) 32.28666704056853
1846 @end example
1848 @end deffn
1853 @c FALTA DEFINICION DE exptisolate