| blob | a17083a6976b4c5b2f4e48c6dfa781cec7556513 |
1 @c -----------------------------------------------------------------------------
2 @c File : Special.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Special.texi revision 15.06.2011
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 13.11.2010
8 @c Revision : 14.07.2011
9 @c
10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
11 @c -----------------------------------------------------------------------------
13 @menu
14 * Einf@"uhrung f@"ur spezielle Funktionen::
15 * Bessel-Funktionen und verwandte Funktionen::
16 * Gammafunktionen und verwandte Funktionen::
17 * Exponentielle Integrale::
18 * Fehlerfunktionen::
19 * Elliptische Funktionen und Integrale::
20 * Hypergeometrische Funktionen::
21 * Weitere spezielle Funktionen::
22 @end menu
24 @c -----------------------------------------------------------------------------
25 @node Einf@"uhrung f@"ur spezielle Funktionen, Bessel-Funktionen und verwandte Funktionen, Spezielle Funktionen, Spezielle Funktionen
26 @section Einf@"uhrung f@"ur spezielle Funktionen
27 @c -----------------------------------------------------------------------------
29 Spezielle Funktionen haben die folgenden Notationen:
31 @example
32 bessel_j (v, z) Bessel-Funktion der 1. Art
33 bessel_y (v, z) Bessel-Funktion der 2. Art
34 bessel_i (v, z) Modifizierte Bessel-Funktion der 1. Art
35 bessel_k (v, z) Modifizierte Bessel-Funktion der 2. Art
37 hankel_1 (v, z) Hankel-Funktion der 1. Art
38 hankel_2 (v, z) Hankel-Funktion der 2. Art
40 airy_ai (z) Airy-Funktion Ai(z)
41 airy_bi (z) Airy-Funktion Bi(z)
42 airy_dai (z) Ableitung der Airy-Funktion Ai(z)
43 airy_dbi (z) Ableitung der Airy-Funktion Bi(z)
45 struve_h (v, z) Struve-Funktion H[v](z)
46 struve_l (v, z) Struve-Funktion L[v](z)
48 %f[p,q] ([], [], z) Hypergeometrische Funktion
49 gamma() Gammafunktion
50 gamma_incomplete_lower(a, z) unvollst@"andige Gamma-Funktion der unteren Grenze
51 gammaincomplete(a,z) unvollst@"andige Gamma-Funktion
52 hypergeometric(l1, l2, z) Hypergeometrische Funktion
54 %m[u,k] (z) Whittaker-Funktion der 1. Art
55 %w[u,k] (z) Whittaker-Funktion der 2. Art
57 erf (z) Fehlerfunktion
58 erfc (z) Komplement@"are Fehlerfunktion
59 erfi (z) imagin@"are Fehlerfunktion
61 expintegral_e (v,z) Exponentielles Integral E
62 expintegral_e1 (z) Exponentielles Integral E1
63 expintegral_ei (z) Exponentielles integral Ei
64 expintegral_li (z) Logarithmisches Integral Li
65 expintegral_si (z) Exponentielles Integral Si
66 expintegral_ci (z) Exponentielles Integral Ci
67 expintegral_shi (z) Exponentielles Integral Shi
68 expintegral_chi (z) Exponentielles Integral Chi
70 parabolic_cylinder_d (v,z) Parabolische Zylinderfunktion D
71 @end example
73 @c -----------------------------------------------------------------------------
74 @node Bessel-Funktionen und verwandte Funktionen, Gammafunktionen und verwandte Funktionen, Einf@"uhrung f@"ur spezielle Funktionen, Spezielle Funktionen
75 @need 800
76 @section Bessel-Funktionen und verwandte Funktionen
77 @c -----------------------------------------------------------------------------
79 @menu
80 * Bessel-Funktionen::
81 * Hankel-Funktionen::
82 * Airy-Funktionen::
83 * Struve-Funktionen::
84 @end menu
86 @c -----------------------------------------------------------------------------
87 @node Bessel-Funktionen, Hankel-Funktionen, Bessel-Funktionen und verwandte Funktionen, Bessel-Funktionen und verwandte Funktionen
88 @subsection Bessel-Funktionen
89 @c -----------------------------------------------------------------------------
91 @c --- 12.07.2011 DK -----------------------------------------------------------
92 @anchor{bessel_j}
93 @deffn {Funktion} bessel_j (@var{v}, @var{z})
95 Die Bessel-Funktion der ersten Art der Ordnung @math{v} mit dem Argument
96 @math{z}. @code{bessel_j} ist definiert als
98 @ifnottex
99 @example
100 inf
101 ==== k
102 \ (- 1) z 2 k + v
103 J (z) = > ------------------- (-)
104 v / k! gamma(v + k + 1) 2
105 ====
106 k = 0
107 @end example
108 @end ifnottex
109 @tex
110 $$J_{v}(z)=\sum_{k=0}^{\infty }{{{\left(-1\right)^{k}}\over{k!
111 \,\Gamma\left(v+k+1\right)}}}\,\left({{z}\over{2}}\right)^{2
112 \,k+v}$$
113 @end tex
115 Die Reihenentwicklung wird nicht f@"ur die numerische Berechnung genutzt.
117 Die Bessel-Funktion @code{bessel_j} ist f@"ur das numerische und symbolische
118 Rechnen geeignet.
120 Maxima berechnet @code{bessel_j} numerisch f@"ur reelle und komplexe
121 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
122 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
123 Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
124 sind. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht
125 implementiert. In diesem Fall gibt Maxima eine Substantivform zur@"uck.
127 @code{bessel_j} hat die folgenden Eigenschaften, die mit mit der Funktion
128 @mref{properties} angezeigt werden und auf das symbolische Rechnen Einfluss
129 haben:
131 @table @code
132 @item conjugate function
133 @code{bessel_j} hat Spiegelsymmetrie, wenn das Argument @var{z} keine negative
134 reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
135 @mref{conjugate} f@"ur die Vereinfachung eines Ausdrucks genutzt.
136 @item complex characteristic
137 Maxima kennt den Realteil und den Imagin@"arteil von @code{bessel_j} f@"ur
138 spezielle Argumente @math{v} und @math{z}.
139 @item limit function
140 Maxima kennt spezielle Grenzwerte der Funktion @code{bessel_j}.
141 @item integral
142 Maxima kennt das Integral der Funktion @code{bessel_j} f@"ur die
143 Integrationsvariable @math{z}.
144 @item gradef
145 Maxima kennt die Ableitungen der Funktion @code{bessel_j} nach den
146 Argumenten @math{v} und @math{z}.
147 @end table
149 Die Vereinfachung der Bessel-Funktion @code{bessel_j} wird von den folgenden
150 Optionsvariablen kontrolliert:
152 @table @code
153 @item distribute_over
154 Hat die Optionsvariable @mref{distribute_over} den Wert @code{true} und sind
155 die Argumente von @code{bessel_j} eine Matrix, Liste oder Gleichung wird die
156 Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
157 Standardwert ist @code{true}.
158 @item besselexpand
159 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, wird
160 @code{bessel_j} mit einer halbzahligen Ordnung @math{v} als Sinus- und
161 Kosinusfunktionen entwickelt.
162 @item bessel_reduce
163 Hat die Optionsvariable @mref{bessel_reduce} den Wert @code{true}, wird
164 @code{bessel_j} mit einer ganzzahligen Ordnung @math{n} nach Bessel-Funktionen
165 @code{bessel_j} mit der niedrigsten Ordnung @code{0} und @code{1} entwickelt.
166 @item hypergeometric_representation
167 Hat die Optionsvariable @mref{hypergeometric_representation} den Wert
168 @code{true}, dann wird @code{bessel_j} als hypergeometrische Funktion
169 dargestellt.
170 @end table
172 Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
173 @code{bessel_j}. F@"ur eine ganze Zahl @math{n} vereinfacht daher
174 @code{bessel_j(-n, z)} zu @code{(-1)^n bessel_j(n, z)}.
176 Maxima kennt noch die Funktion @mrefcomma{spherical_bessel_j} die im Paket
177 @code{orthopoly} definiert ist. Siehe auch die anderen Bessel-Funktionen
178 @mrefcomma{bessel_y} @mref{bessel_i} und @mref{bessel_k} sowie die
179 weiteren mit den Bessel-Funktionen verwandten Funktionen wie die
180 Hankel-Funktionen in @ref{Hankel-Funktionen}, Airy-Funktionen in
181 @ref{Airy-Funktionen} und Struve-Funktionen in @ref{Struve-Funktionen}.
183 Beispiele:
185 Numerisches Rechnen mit der Bessel-Funktion. F@"ur gro@ss{}e Gleitkommazahlen
186 ist die numerische Berechnung nicht implementiert.
188 @example
189 (%i1) bessel_j(1,[0.5, 0.5+%i]);
190 (%o1) [.2422684576748739, .5124137767280905 %i
191 + .3392601907198862]
192 (%i2) bessel_j(1,[0.5b0, 0.5b0+%i]);
193 (%o2) [bessel_j(1, 5.0b-1), bessel_j(1, %i + 5.0b-1)]
194 @end example
196 Vereinfachungen der Bessel-Funktion mit den Optionsvariablen @code{besselexpand}
197 und @code{bessel_reduce}.
199 @example
200 (%i3) bessel_j(1/2,x), besselexpand:true;
201 sqrt(2) sin(x)
202 (%o3) -----------------
203 sqrt(%pi) sqrt(x)
204 (%i4) bessel_j(3,x), bessel_reduce:true;
205 2 bessel_j(1, x)
206 4 (---------------- - bessel_j(0, x))
207 x
208 (%o4) ------------------------------------- - bessel_j(1, x)
209 x
210 @end example
212 Ableitungen und Integrale der Bessel-Funktion. Das letzte Beispiel zeigt
213 die Laplace-Transformation der Bessel-Funktion mit der Funktion
214 @mrefdot{laplace}
216 @example
217 (%i5) diff(bessel_j(2,x), x);
218 @group
219 bessel_j(1, x) - bessel_j(3, x)
220 (%o5) -------------------------------
221 2
222 @end group
223 (%i6) diff(bessel_j(v,x), x);
224 bessel_j(v - 1, x) - bessel_j(v + 1, x)
225 (%o6) ---------------------------------------
226 2
227 (%i7) integrate(bessel_j(v,x), x);
228 (%o7)
229 2
230 v 1 v 3 x - v - 1 v + 1
231 hypergeometric([- + -], [- + -, v + 1], - --) 2 x
232 2 2 2 2 4
233 -------------------------------------------------------------
234 v 1
235 (- + -) gamma(v + 1)
236 2 2
237 (%i8) laplace(bessel_j(2,t), t, s);
238 1 2
239 (1 - sqrt(-- + 1)) s
240 2
241 s
242 (%o8) ---------------------
243 1
244 sqrt(-- + 1)
245 2
246 s
247 @end example
249 Bessel-Funktionen als L@"osung einer linearen Differentialgleichung zweiter
250 Ordnung.
252 @example
253 (%i1) depends(y, x);
254 (%o1) [y(x)]
255 (%i2) declare(n, integer);
256 (%o2) done
257 (%i3) 'diff(y, x, 2)*x^2 + 'diff(y, x)*x + y*(x^2-n^2) = 0;
258 2
259 2 2 d y 2 dy
260 (%o3) y (x - n ) + --- x + -- x = 0
261 2 dx
262 dx
263 (%i4) ode2(%, y, x);
264 (%o4) y = %k2 bessel_y(n, x) + %k1 bessel_j(n, x)
265 @end example
266 @end deffn
268 @c --- 13.07.2011 DK -----------------------------------------------------------
269 @anchor{bessel_y}
270 @deffn {Funktion} bessel_y (@var{v}, @var{z})
272 Die Bessel-Funktion der zweiten Art der Ordnung @math{v} mit dem Argument
273 @math{z}. @code{bessel_y} ist definiert als
275 @ifnottex
276 @example
277 cos(%pi v) J (z) - J (z)
278 v - v
279 Y (z) = --------------------------
280 v sin(%pi v)
281 @end example
282 @end ifnottex
283 @tex
284 $$Y_{v}(z)={{\cos \left(\pi\,v\right)\,J_{v}(z)-J_{-v}(z)}\over{\sin
285 \left(\pi\,v\right)}}$$
286 @end tex
288 f@"ur den Fall, dass @math{v} keine ganze Zahl ist. Ist @math{v} eine ganze
289 Zahl @math{n}, dann wird die Bessel-Funktion @code{bessel_y} wie folgt als
290 ein Grenzwert definiert
292 @ifnottex
293 @example
294 Y (z) = limit Y (z)
295 n v -> n v
296 @end example
297 @end ifnottex
298 @tex
299 $$Y_{n}(z)=\lim_{v\rightarrow n}{Y_{v}(z)}$$
300 @end tex
302 Die Bessel-Funktion @code{bessel_y} ist f@"ur das numerische und symbolische
303 Rechnen geeignet.
305 Maxima berechnet @code{bessel_y} numerisch f@"ur reelle und komplexe
306 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
307 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
308 Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
309 sind. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht
310 implementiert. In diesem Fall gibt Maxima eine Substantivform zur@"uck.
312 @code{bessel_y} hat die folgenden Eigenschaften, die mit mit der Funktion
313 @mref{properties} angezeigt werden und auf das symbolische Rechnen Einfluss
314 haben:
316 @table @code
317 @item conjugate function
318 @code{bessel_y} hat Spiegelsymmetrie, wenn das Argument @var{z} keine negative
319 reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
320 @mref{conjugate} f@"ur die Vereinfachung eines Ausdrucks genutzt.
321 @item complex characteristic
322 Maxima kennt den Realteil und den Imagin@"arteil von @code{bessel_y} f@"ur
323 spezielle Argumente @math{v} und @math{z}.
324 @item limit function
325 Maxima kennt spezielle Grenzwerte der Funktion @code{bessel_y}.
326 @item integral
327 Maxima kennt das Integral der Funktion @code{bessel_y} f@"ur die
328 Integrationsvariable @math{z}.
329 @item gradef
330 Maxima kennt die Ableitungen der Funktion @code{bessel_y} nach den
331 Argumenten @math{v} und @math{z}.
332 @end table
334 Die Vereinfachung der Bessel-Funktion @code{bessel_y} wird von den folgenden
335 Optionsvariablen kontrolliert:
337 @table @code
338 @item distribute_over
339 Hat die Optionsvariable @mref{distribute_over} den Wert @code{true} und sind
340 die Argumente von @code{bessel_y} eine Matrix, Liste oder Gleichung wird die
341 Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
342 Standardwert ist @code{true}.
343 @item besselexpand
344 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, wird
345 @code{bessel_y} mit einer halbzahligen Ordnung @math{v} als Sinus- und
346 Kosinusfunktionen entwickelt.
347 @item bessel_reduce
348 Hat die Optionsvariable @mref{bessel_reduce} den Wert @code{true}, wird
349 @code{bessel_y} mit einer ganzzahligen Ordnung @math{n} nach Bessel-Funktionen
350 @code{bessel_y} mit der niedrigsten Ordnung @code{0} und @code{1} entwickelt.
351 @item hypergeometric_representation
352 Hat die Optionsvariable @mref{hypergeometric_representation} den Wert
353 @code{true}, dann wird @code{bessel_y} als hypergeometrische Funktion
354 dargestellt. Es ist zu beachten, dass die hypergeometrische Funktion nur f@"ur
355 eine nicht ganzzahlige Ordnung @math{v} g@"ultig ist.
356 @end table
358 Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
359 @code{bessel_y}. F@"ur eine ganze Zahl @math{n} vereinfacht daher
360 @code{bessel_y(-n, z)} zu @code{(-1)^n bessel_y(n, z)}.
362 Maxima kennt noch die Funktion @mrefcomma{spherical_bessel_y} die im Paket
363 @code{orthopoly} definiert ist. Siehe auch die anderen Bessel-Funktionen
364 @mrefcomma{bessel_j} @mref{bessel_i} und @mref{bessel_k} sowie die
365 weiteren mit den Bessel-Funktionen verwandten Funktionen wie die
366 Hankel-Funktionen in @ref{Hankel-Funktionen}, Airy-Funktionen in
367 @ref{Airy-Funktionen} und Struve-Funktionen in @ref{Struve-Funktionen}.
369 Siehe die Funktion @mref{bessel_j} f@"ur Beispiele mit Bessel-Funktionen.
370 @end deffn
372 @c --- 13.07.2011 DK -----------------------------------------------------------
373 @anchor{bessel_i}
374 @deffn {Funktion} bessel_i (@var{v}, @var{z})
376 Die modifizierte Bessel-Funktion der ersten Art der Ordnung @math{v} mit dem
377 Argument @math{v}. @code{bessel_i} ist definiert als
379 @ifnottex
380 @example
381 inf
382 ====
383 \ 1 z 2 k + v
384 I (z) = > ------------------- (-)
385 v / k! gamma(v + k + 1) 2
386 ====
387 k = 0
388 @end example
389 @end ifnottex
390 @tex
391 $$I_{v}(z)=\sum_{k=0}^{\infty }{{{1}\over{k!\,\Gamma\left(v+k+1
392 \right)}}}\,\left({{z}\over{2}}\right)^{2\,k+v}$$
393 @end tex
395 Die Reihenentwicklung wird nicht f@"ur die numerische Berechnung genutzt.
397 Die Bessel-Funktion @code{bessel_i} ist f@"ur das numerische und symbolische
398 Rechnen geeignet.
400 Maxima berechnet @code{bessel_i} numerisch f@"ur reelle und komplexe
401 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
402 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
403 Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
404 sind. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht
405 implementiert. In diesem Fall gibt Maxima eine Substantivform zur@"uck.
407 @code{bessel_i} hat die folgenden Eigenschaften, die mit mit der Funktion
408 @mref{properties} angezeigt werden und auf das symbolische Rechnen Einfluss
409 haben:
411 @table @code
412 @item conjugate function
413 @code{bessel_i} hat Spiegelsymmetrie, wenn das Argument @var{z} keine negative
414 reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
415 @mref{conjugate} f@"ur die Vereinfachung eines Ausdrucks genutzt.
416 @item complex characteristic
417 Maxima kennt den Realteil und den Imagin@"arteil von @code{bessel_i} f@"ur
418 spezielle Argumente @math{v} und @math{z}.
419 @item limit function
420 Maxima kennt spezielle Grenzwerte der Funktion @code{bessel_i}.
421 @item integral
422 Maxima kennt das Integral der Funktion @code{bessel_i} f@"ur die
423 Integrationsvariable @math{z}.
424 @item gradef
425 Maxima kennt die Ableitungen der Funktion @code{bessel_i} nach den
426 Argumenten @math{v} und @math{z}.
427 @end table
429 Die Vereinfachung der Bessel-Funktion @code{bessel_i} wird von den folgenden
430 Optionsvariablen kontrolliert:
432 @table @code
433 @item distribute_over
434 Hat die Optionsvariable @mref{distribute_over} den Wert @code{true} und sind
435 die Argumente von @code{bessel_i} eine Matrix, Liste oder Gleichung wird die
436 Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
437 Standardwert ist @code{true}.
438 @item besselexpand
439 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, wird
440 @code{bessel_i} mit einer halbzahligen Ordnung @math{v} als Hyperbelfunktionen
441 entwickelt.
442 @item bessel_reduce
443 Hat die Optionsvariable @mref{bessel_reduce} den Wert @code{true}, wird
444 @code{bessel_i} mit einer ganzzahligen Ordnung @math{n} nach Bessel-Funktionen
445 @code{bessel_i} mit der niedrigsten Ordnung @code{0} und @code{1} entwickelt.
446 @item hypergeometric_representation
447 Hat die Optionsvariable @mref{hypergeometric_representation} den Wert
448 @code{true}, dann wird @code{bessel_i} als hypergeometrische Funktion
449 dargestellt.
450 @end table
452 Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
453 @code{bessel_i}. F@"ur eine ganze Zahl @math{n} vereinfacht daher
454 @code{bessel_i(-n, z)} zu @code{bessel_i(n, z)}.
456 Siehe auch die anderen Bessel-Funktionen @mrefcomma{bessel_j}@w{}
457 @mref{bessel_y} und @mref{bessel_k} sowie die weiteren mit den Bessel-Funktionen
458 verwandten Funktionen wie die Hankel-Funktionen in @ref{Hankel-Funktionen},
459 Airy-Funktionen in @ref{Airy-Funktionen} und Struve-Funktionen in
460 @ref{Struve-Funktionen}.
462 Siehe die Funktion @mref{bessel_j} f@"ur Beispiele mit Bessel-Funktionen.
463 @end deffn
465 @c --- 13.07.2011 DK -----------------------------------------------------------
466 @anchor{bessel_k}
467 @deffn {Funktion} bessel_k (@var{v}, @var{z})
469 Die modifizierte Bessel-Funktion der zweiten Art der Ordnung @math{v} mit dem
470 Argument @math{z}. @code{bessel_k} ist definiert als
472 @ifnottex
473 @example
474 %pi csc(%pi u) (I (z) - I (z))
475 - v u
476 K (z) = --------------------------------
477 v 2
478 @end example
479 @end ifnottex
480 @tex
481 $$K_{v}(z)={{\pi\,\csc \left(\pi\,u\right)\,\left(I_{-v}(z)-I_{u}(z)
482 \right)}\over{2}}$$
483 @end tex
485 f@"ur den Fall, dass @math{v} keine ganze Zahl ist. Ist @math{v} eine ganze
486 Zahl @math{n}, dann wird die Bessel-Funktion @code{bessel_k} wie folgt als
487 Grenzwert definiert
489 @ifnottex
490 @example
491 (%o5) K (z) = limit K (z)
492 n v -> n v
493 @end example
494 @end ifnottex
495 @tex
496 $$K_{n}(z)=\lim_{v\rightarrow n}{K_{v}(z)}$$
497 @end tex
499 Die Bessel-Funktion @code{bessel_k} ist f@"ur das numerische und symbolische
500 Rechnen geeignet.
502 Maxima berechnet @code{bessel_k} numerisch f@"ur reelle und komplexe
503 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
504 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
505 Auswertung erzwungen werden, wenn die Argumente ganze oder rationale Zahlen
506 sind. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht
507 implementiert. In diesem Fall gibt Maxima eine Substantivform zur@"uck.
509 @code{bessel_k} hat die folgenden Eigenschaften, die mit mit der Funktion
510 @mref{properties} angezeigt werden und auf das symbolische Rechnen Einfluss
511 haben:
513 @table @code
514 @item conjugate function
515 @code{bessel_k} hat Spiegelsymmetrie, wenn das Argument @var{z} keine negative
516 reelle Zahl ist. Die Spiegelsymmetrie wird zum Beispiel von der Funktion
517 @mref{conjugate} f@"ur die Vereinfachung eines Ausdrucks genutzt.
518 @item complex characteristic
519 Maxima kennt den Realteil und den Imagin@"arteil von @code{bessel_k} f@"ur
520 spezielle Argumente @math{v} und @math{z}.
521 @item limit function
522 Maxima kennt spezielle Grenzwerte der Funktion @code{bessel_k}.
523 @item integral
524 Maxima kennt das Integral der Funktion @code{bessel_k} f@"ur die
525 Integrationsvariable @math{z}.
526 @item gradef
527 Maxima kennt die Ableitungen der Funktion @code{bessel_k} nach den
528 Argumenten @math{v} und @math{z}.
529 @end table
531 Die Vereinfachung der Bessel-Funktion @code{bessel_k} wird von den folgenden
532 Optionsvariablen kontrolliert:
534 @table @code
535 @item distribute_over
536 Hat die Optionsvariable @mref{distribute_over} den Wert @code{true} und sind
537 die Argumente von @code{bessel_k} eine Matrix, Liste oder Gleichung wird die
538 Funktion auf die Elemente oder beiden Seiten der Gleichung angewendet. Der
539 Standardwert ist @code{true}.
540 @item besselexpand
541 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, wird
542 @code{bessel_k} mit einer halbzahligen Ordnung @math{v} als Exponentialfunktion
543 entwickelt.
544 @item bessel_reduce
545 Hat die Optionsvariable @mref{bessel_reduce} den Wert @code{true}, wird
546 @code{bessel_k} mit einer ganzzahligen Ordnung @math{n} nach Bessel-Funktionen
547 @code{bessel_k} mit der niedrigsten Ordnung @code{0} und @code{1} entwickelt.
548 @item hypergeometric_representation
549 Hat die Optionsvariable @mref{hypergeometric_representation} den Wert
550 @code{true}, dann wird @code{bessel_k} als hypergeometrische Funktion
551 dargestellt. Es ist zu beachten, dass die hypergeometrische Funktion nur f@"ur
552 eine nicht ganzzahlige Ordnung @math{v} g@"ultig ist.
553 @end table
555 Weiterhin kennt Maxima die geraden und ungeraden Symmetrieeigenschaften von
556 @code{bessel_k}. F@"ur eine ganze Zahl @math{n} vereinfacht daher
557 @code{bessel_k(-n, z)} zu @code{bessel_y(n, z)}.
559 Siehe auch die anderen Bessel-Funktionen @mrefcomma{bessel_j} @mref{bessel_y}
560 und @mref{bessel_i} sowie die weiteren mit den Bessel-Funktionen verwandten
561 Funktionen wie die Hankel-Funktionen in @ref{Hankel-Funktionen}, Airy-Funktionen
562 in @ref{Airy-Funktionen} und Struve-Funktionen in @ref{Struve-Funktionen}.
564 Siehe die Funktion @mref{bessel_j} f@"ur Beispiele mit Bessel-Funktionen.
565 @end deffn
567 @c --- 31.03.2011 DK -----------------------------------------------------------
568 @anchor{bessel_reduce}
569 @defvr {Optionsvariable} bessel_reduce
570 Standardwert: @code{false}
572 Hat die Optionsvariable @code{bessel_reduce} den Wert @code{true}, werden
573 Bessel-Funktionen mit einer ganzzahligen Ordnung @math{n} nach Bessel-Funktionen
574 mit der niedrigsten Ordnung @math{0} und @math{1} entwickelt.
575 @end defvr
577 @c --- 31.03.2011 DK -----------------------------------------------------------
578 @anchor{besselexpand}
579 @defvr {Optionsvariable} besselexpand
580 Standardwert: @code{false}
582 Hat die Optionsvariable @code{besselexpand} den Wert @code{true}, werden
583 Bessel-Funktion mit einer halbzahligen Ordnung @math{v} als Sinus-,
584 Kosinus-, Hyperbel- oder Exponentialfunktionen entwickelt. Die Optionsvariable
585 @code{besselexpand} kontrolliert auch die Entwicklung der Hankel-Funktionen
586 @mref{hankel_1} und @mref{hankel_2} sowie der Struve-Funktionen @mref{struve_h}
587 und @mrefdot{struve_l}
589 Beispiele:
591 @example
592 (%i1) besselexpand: false$
594 (%i2) bessel_j(3/2, z);
595 3
596 (%o2) bessel_j(-, z)
597 2
598 (%i3) besselexpand: true$
600 (%i4) bessel_j(3/2, z);
601 sin(z) cos(z)
602 sqrt(2) sqrt(z) (------ - ------)
603 2 z
604 z
605 (%o4) ---------------------------------
606 sqrt(%pi)
607 @end example
609 Weitere Beispiele f@"ur die Entwicklungen der Funktionen @mref{bessel_k} und
610 @mrefdot{struve_h}
612 @example
613 (%i5) bessel_k(3/2, z);
614 1 - z
615 sqrt(%pi) (- + 1) %e
616 z
617 (%o5) -----------------------
618 sqrt(2) sqrt(z)
620 (%i6) struve_h(3/2, z);
621 2
622 2 z sin(z) + 2 cos(z) - z - 2
623 (%o6) - ------------------------------
624 3/2
625 sqrt(2) sqrt(%pi) z
626 @end example
627 @end defvr
629 @c --- 31.03.2011 DK -----------------------------------------------------------
630 @anchor{scaled_bessel_i}
631 @deffn {Funktion} scaled_bessel_i (@var{v}, @var{z})
633 Die skalierte modifizierte Bessel-Funktion der ersten Art der Ordnung
634 @math{v} mit dem Argument @math{z}. Diese ist definiert als
636 @example
637 - abs(z)
638 scaled_bessel_i(v, z) = bessel_i(v, z) %e
639 @end example
641 @code{scaled_bessel_i} liefert ein numerisches Ergebnis, wenn die Argumente
642 @math{v} und @math{z} Zahlen sind. Die Funktion kann geeignet sein, wenn
643 @code{bessel_i} f@"ur gro@ss{}e Argumente @math{z} numerisch berechnet werden
644 soll. Ganze, rationale oder gro@ss{}e Gleitkommazahlen werden in
645 Gleitkommazahlen mit doppelter Genauigkeit umgewandelt. Sind die Argumente
646 keine Zahlen, wird ein vereinfachter Ausdruck mit der Funktion
647 @mref{bessel_i} zur@"uckgegeben.
649 @code{scaled_bessel_i} ist eine Verbfunktion, die nicht f@"ur das symbolische
650 Rechnen geeignet ist. F@"ur das symbolische Rechnen ist die Funktion
651 @mref{bessel_i} zu verwenden.
653 Beispiele:
655 @example
656 (%i1) scaled_bessel_i(1, 50);
657 (%o1) .05599312389289544
658 (%i2) scaled_bessel_i(1/2, 50);
659 (%o2) .05641895835477567
660 (%i3) scaled_bessel_i(v, x);
661 - abs(x)
662 (%o3) bessel_i(v, x) %e
663 @end example
664 @end deffn
666 @c -----------------------------------------------------------------------------
667 @anchor{scaled_bessel_i0}
668 @deffn {Funktion} scaled_bessel_i0 (@var{z})
670 Entspricht @code{scaled_bessel_i(0,z)}. Siehe @mrefdot{scaled_bessel_i}
671 @end deffn
673 @c -----------------------------------------------------------------------------
674 @anchor{scaled_bessel_i1}
675 @deffn {Funktion} scaled_bessel_i1 (@var{z})
677 Entspricht @code{scaled_bessel_i(1,z)}. Siehe @mrefdot{scaled_bessel_i}
678 @end deffn
680 @c -----------------------------------------------------------------------------
681 @node Hankel-Funktionen, Airy-Funktionen, Bessel-Funktionen, Bessel-Funktionen und verwandte Funktionen
682 @subsection Hankel-Funktionen
683 @c -----------------------------------------------------------------------------
685 @c --- 13.07.2011 DK -----------------------------------------------------------
686 @anchor{hankel_1}
687 @deffn {Funktion} hankel_1 (@var{v}, @var{z})
689 Die Hankel-Funktion der ersten Art der Ordnung @math{v} mit dem Argument
690 @math{z}. Siehe A@w{ }&@w{ }S 9.1.3. @code{hankel_1} ist definiert als
692 @ifnottex
693 @example
694 H1 (z) = J (z) + %i Y (z)
695 v v v
696 @end example
697 @end ifnottex
698 @tex
699 $${\it H1}_{v}(z)=J_{v}(z)+i\,Y_{v}(z)$$
700 @end tex
702 Die Hankel-Funktion @code{hankel_1} ist f@"ur das numerische und symbolische
703 Rechnen geeignet.
705 Maxima berechnet @code{hankel_1} numerisch f@"ur reelle und komplexe
706 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
707 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
708 Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
709 Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht implementiert. In diesem
710 Fall gibt Maxima eine Substantivform zur@"uck.
712 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, werden
713 Hankel-Funktionen @code{hankel_1} mit einer halbzahligen Ordnung @math{v} als
714 Sinus- und Kosinusfunktionen entwickelt.
716 Maxima kennt die Ableitung der Hankel-Funktion @code{hankel_1} nach dem zweiten
717 Argument @code{z}.
719 Siehe auch die Funktion @mref{hankel_2} sowie die Bessel-Funktionen in
720 @ref{Bessel-Funktionen}.
722 Beispiele:
724 Numerische Berechnung.
726 @example
727 (%i1) hankel_1(1, 0.5);
728 (%o1) .2422684576748738 - 1.471472392670243 %i
729 (%i2) hankel_1(1, 0.5+%i);
730 (%o2) - .2558287994862166 %i - 0.239575601883016
731 @end example
733 F@"ur eine komplex Ordnung kann Maxima keinen numerischen Wert berechnet. Das
734 Ergebnis ist eine Substantivform.
736 @example
737 (%i3) hankel_1(%i, 0.5+%i);
738 (%o3) hankel_1(%i, %i + 0.5)
739 @end example
741 Entwicklung der Hankel-Funktion @code{hankel_1}, wenn die Optionsvariable
742 @code{besselexpand} den Wert @code{true} hat.
744 @example
745 (%i4) hankel_1(1/2, z), besselexpand:true;
746 sqrt(2) sin(z) - sqrt(2) %i cos(z)
747 (%o4) ----------------------------------
748 sqrt(%pi) sqrt(z)
749 @end example
751 Ableitung der Hankel-Funktion @code{hankel_1} nach dem Argument @var{z}. Die
752 Ableitung nach der Ordnung @var{v} ist nicht implementiert. Maxima gibt eine
753 Substantivform zur@"uck.
755 @example
756 (%i5) diff(hankel_1(v,z), z);
757 hankel_1(v - 1, z) - hankel_1(v + 1, z)
758 (%o5) ---------------------------------------
759 2
760 (%i6) diff(hankel_1(v,z), v);
761 d
762 (%o6) -- (hankel_1(v, z))
763 dv
764 @end example
765 @end deffn
767 @c --- 27.03.2011 DK -----------------------------------------------------------
768 @anchor{hankel_2}
769 @deffn {Funktion} hankel_2 (@var{v}, @var{z})
771 Die Hankel-Funktion der zweiten Art der Ordnung @math{v} mit dem Argument
772 @math{z}. Siehe A@w{ }&@w{ }S 9.1.4. @code{hankel_2} ist definiert als
774 @ifnottex
775 @example
776 H2 (z) = J (z) - %i Y (z)
777 v v v
778 @end example
779 @end ifnottex
780 @tex
781 $${\it H2}_{v}(z)=J_{v}(z)-i\,Y_{v}(z)$$
782 @end tex
784 Die Hankel-Funktion @code{hankel_2} ist f@"ur das numerische und symbolische
785 Rechnen geeignet.
787 Maxima berechnet @code{hankel_2} numerisch f@"ur reelle und komplexe
788 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
789 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
790 Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
791 Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht implementiert. In diesem
792 Fall gibt Maxima eine Substantivform zur@"uck.
794 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, werden
795 Hankel-Funktionen @code{hankel_2} mit einer halbzahligen Ordnung @math{v} als
796 Sinus- und Kosinusfunktionen entwickelt.
798 Maxima kennt die Ableitung der Hankel-Funktion @code{hankel_2} nach dem zweiten
799 Argument @code{z}.
801 F@"ur Beispiele siehe @mrefdot{hankel_1} Siehe auch die Bessel-Funktionen in
802 @ref{Bessel-Funktionen}.
803 @end deffn
805 @c -----------------------------------------------------------------------------
806 @node Airy-Funktionen, Struve-Funktionen, Hankel-Funktionen, Bessel-Funktionen und verwandte Funktionen
807 @subsection Airy-Funktionen
808 @c -----------------------------------------------------------------------------
810 Die Airy-Funktionen @math{Ai(z)} und @math{Bi(z)} sind definiert in Abramowitz
811 und Stegun, @i{Handbook of Mathematical Functions}, Kapitel 10.4. Die
812 Funktionen @code{y = Ai(z)} und @code{y = Bi(z)} sind zwei linear unabh@"angige
813 L@"osungen der Airy-Differentialgleichung.
815 @example
816 2
817 d y
818 --- - y z = 0
819 2
820 dz
821 @end example
823 @c --- 14.07.2011.2011 DK -----------------------------------------------------------
824 @anchor{airy_ai}
825 @deffn {Funktion} airy_ai (@var{z})
827 Die Airy-Funktion @math{Ai(z)} (A & S 10.4.2).
829 Die Airy-Funktion @code{airy_ai} ist f@"ur das symbolische und numerische
830 Rechnen geeignet. Ist das Argument @code{z} eine reelle oder komplexe
831 Gleitkommazahl, wird @code{airy_ai} numerisch berechnet. Mit der
832 Optionsvariablen @mref{numer} oder der Funktion @mref{float} kann die
833 numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
834 rationale Zahl ist. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen
835 ist nicht implementiert.
837 Maxima kennt den speziellen Wert f@"ur das Argument @code{0}.
839 Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
840 @code{airy_ai} auf die Elemente der Liste oder beide Seiten der Gleichung
841 angewendet. Siehe auch @mrefdot{distribute_over}
843 Die Ableitung @code{diff(airy_ai(z), z)} ist als @code{airy_dai(z)}
844 implementiert. Siehe die Funktion @mrefdot{airy_dai}
846 Weiterhin kennt Maxima das Integral der Airy-Funktion @code{airy_ai}.
848 Siehe auch die Funktionen @mref{airy_bi} und @mrefdot{airy_dbi}
850 Beispiele:
852 Numerische Berechnung f@"ur Gleitkommazahlen. F@"ur ganze und rationale Zahlen
853 wird eine Substantivform zur@"uckgegeben. Maxima kennt den speziellen Wert
854 f@"ur das Argument @code{0}.
856 @example
857 (%i1) airy_ai([0.5, 1.0+%i]);
858 (%o1) [.2316936064808335, .06045830837183824
859 - .1518895658771814 %i]
860 (%i2) airy_ai([1, 1/2]);
861 @group
862 1
863 (%o2) [airy_ai(1), airy_ai(-)]
864 2
865 @end group
866 (%i3) airy_ai(0);
867 1
868 (%o3) -------------
869 2/3 2
870 3 gamma(-)
871 3
872 @end example
874 Ableitungen und Integral der Airy-Funktion @code{airy_ai}.
876 @example
877 (%i4) diff(airy_ai(z), z);
878 (%o4) airy_dai(z)
879 (%i5) diff(airy_ai(z), z, 2);
880 (%o5) z airy_ai(z)
881 (%i6) diff(airy_ai(z), z, 3);
882 (%o6) z airy_dai(z) + airy_ai(z)
883 (%i7) integrate(airy_ai(z), z);
884 3
885 1 2 4 z
886 hypergeometric([-], [-, -], --) z
887 3 3 3 9
888 (%o7) ---------------------------------
889 2/3 2
890 3 gamma(-)
891 3
892 3
893 1/6 2 2 4 5 z 2
894 3 gamma(-) hypergeometric([-], [-, -], --) z
895 3 3 3 3 9
896 - ------------------------------------------------
897 4 %pi
898 @end example
899 @end deffn
901 @c --- 14.07.2011 DK -----------------------------------------------------------
902 @anchor{airy_dai}
903 @deffn {Funktion} airy_dai (@var{z})
905 Die Ableitung der Airy-Funktion @mrefdot{airy_ai}
907 Die Ableitung der Airy-Funktion @code{airy_dai} ist f@"ur das symbolische und
908 numerische Rechnen geeignet. Ist das Argument @var{z} eine reelle oder
909 komplexe Gleitkommazahl, wird @code{airy_dai} numerisch berechnet. Mit der
910 Optionsvariablen @mref{numer} oder der Funktion @mref{float} kann die
911 numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
912 rationale Zahl ist. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen
913 ist nicht implementiert.
915 Maxima kennt den speziellen Wert f@"ur das Argument @code{0}.
917 Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
918 @code{airy_dai} auf die Elemente der Liste oder beide Seiten der Gleichung
919 angewendet. Siehe auch @mrefdot{distribute_over}
921 Maxima kennt die Ableitung und das Integral der Funktion @code{airy_dai}.
923 Siehe auch die Airy-Funktionen @mref{airy_bi} und @mrefdot{airy_dbi}
925 F@"ur Beispiele siehe die Funktion @mrefdot{airy_ai}
926 @end deffn
928 @c --- 14.07.2011 DK -----------------------------------------------------------
929 @need 1000
930 @anchor{airy_bi}
931 @deffn {Funktion} airy_bi (@var{z})
933 Die Airy-Funktion Bi(z) (A & S 10.4.3).
935 Die Airy-Funktion @code{airy_bi} ist f@"ur das symbolische und numerische
936 Rechnen geeignet. Ist das Argument @code{z} eine reelle oder komplexe
937 Gleitkommazahl, wird @code{airy_bi} numerisch berechnet. Mit der
938 Optionsvariablen @mref{numer} oder der Funktion @mref{float} kann die
939 numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
940 rationale Zahl ist. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen
941 ist nicht implementiert.
943 Maxima kennt den speziellen Wert f@"ur das Argument @code{0}.
945 Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
946 @code{airy_bi} auf die Elemente der Liste oder beide Seiten der Gleichung
947 angewendet. Siehe auch @mrefdot{distribute_over}
949 Die Ableitung @code{diff(airy_bi(z), z)} ist als @code{airy_dbi(z)}
950 implementiert. Siehe die Funktion @mrefdot{airy_dbi}
952 Weiterhin kennt Maxima das Integral der Airy-Funktion @code{airy_bi}.
954 Siehe auch die Funktionen @mref{airy_ai} und @mrefdot{airy_dai}
956 F@"ur Beispiele siehe die Funktion @mrefdot{airy_ai}
957 @end deffn
959 @c --- 14.07.2011 DK -----------------------------------------------------------
960 @anchor{airy_dbi}
961 @deffn {Funktion} airy_dbi (@var{z})
963 Die Ableitung der Airy-Funktion @mrefdot{airy_bi}
965 Die Ableitung der Airy-Funktion @code{airy_dbi} ist f@"ur das symbolische und
966 numerische Rechnen geeignet. Ist das Argument @var{z} eine reelle oder
967 komplexe Gleitkommazahl, wird @code{airy_dbi} numerisch berechnet. Mit der
968 Optionsvariablen @mref{numer} oder der Funktion @mref{float} kann die
969 numerische Berechnung erzwungen werden, wenn das Argument eine ganze oder
970 rationale Zahl ist. Die numerische Berechnung f@"ur gro@ss{}e Gleitkommazahlen
971 ist nicht implementiert.
973 Maxima kennt den speziellen Wert f@"ur das Argument @code{0}.
975 Ist das Argument eine Liste, Matrix oder Gleichung wird die Funktion
976 @code{airy_dbi} auf die Elemente der Liste oder beide Seiten der Gleichung
977 angewendet. Siehe auch @mrefdot{distribute_over}
979 Maxima kennt die Ableitung und das Integral der Funktion @code{airy_dbi}.
981 Siehe auch die Airy-Funktionen @mref{airy_ai} und @mrefdot{airy_dai}
983 F@"ur Beispiele siehe die Funktion @mrefdot{airy_ai}
984 @end deffn
986 @c -----------------------------------------------------------------------------
987 @node Struve-Funktionen, , Airy-Funktionen, Bessel-Funktionen und verwandte Funktionen
988 @subsection Struve-Funktionen
989 @c -----------------------------------------------------------------------------
991 @c --- 27.03.2011---------------------------------------------------------------
992 @anchor{struve_h}
993 @deffn {Funktion} struve_h (@var{v}, @var{z})
995 Die Struve-Funktion @math{H} der Ordnung @math{v} mit dem Argument
996 @math{z}. Siehe Abramowitz und Stegun, Handbook of Mathematical Functions,
997 Kapitel 12. Die Definition ist
999 @ifnottex
1000 @example
1001 inf
1002 ==== k 2 k
1003 z v + 1 \ (- 1) z
1004 H (z) = (-) > ----------------------------------
1005 v 2 / 2 k 3 3
1006 ==== 2 gamma(k + -) gamma(v + k + -)
1007 k = 0 2 2
1008 @end example
1009 @end ifnottex
1010 @tex
1011 $$H_{v}(z)=\left({{z}\over{2}}\right)^{v+1}\,\sum_{k=0}^{\infty }{{{\left(-1
1012 \right)^{k}\,z^{2\,k}}\over{2^{2\,k}\,\Gamma\left(k+{{3}\over{2}}
1013 \right)\,\Gamma\left(v+k+{{3}\over{2}}\right)}}}$$
1014 @end tex
1016 Die Struve-Funktion @code{struve_h} ist f@"ur das numerische und symbolische
1017 Rechnen geeignet. Im Unterschied zu den @nref{Bessel-Funktionen} ist jedoch
1018 die Implementation der Funktion @code{struve_h} weniger vollst@"andig.
1020 Maxima berechnet @code{struve_h} numerisch f@"ur reelle und komplexe
1021 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
1022 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
1023 Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
1024 Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht implementiert. In diesem
1025 Fall gibt Maxima eine Substantivform zur@"uck.
1027 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, wird die
1028 Struve-Funktion @code{struve_h} mit einer halbzahligen Ordnung @math{v} als
1029 Sinus- und Kosinusfunktionen entwickelt.
1031 Maxima kennt die Ableitung der Struve-Funktion @code{struve_h} nach dem
1032 Argument @math{z}.
1034 Siehe auch die Struve-Funktion @mrefdot{struve_l}
1036 Beispiele:
1038 @example
1039 (%i1) struve_h(1, 0.5);
1040 (%o1) .05217374424234107
1041 (%i2) struve_h(1, 0.5+%i);
1042 (%o2) 0.233696520211436 %i - .1522134290663428
1043 (%i3) struve_h(3/2,x), besselexpand: true;
1044 2
1045 2 x sin(x) + 2 cos(x) - x - 2
1046 (%o3) - ------------------------------
1047 3/2
1048 sqrt(2) sqrt(%pi) x
1049 (%i4) diff(struve_h(v, x), x);
1050 v
1051 x
1052 (%o4) (------------------------- - struve_h(v + 1, x)
1053 v 3
1054 sqrt(%pi) 2 gamma(v + -)
1055 2
1056 + struve_h(v - 1, x))/2
1057 @end example
1058 @end deffn
1060 @c --- 27.03.2011 DK -----------------------------------------------------------
1061 @anchor{struve_l}
1062 @deffn {Funktion} struve_l (@var{v}, @var{z})
1064 Die modifizierte Struve-Funktion @math{L} der Ordnung @math{v} mit dem Argument
1065 @math{z}. Siehe Abramowitz und Stegun, Handbook of Mathematical Functions,
1066 Kapitel 12. Die Definition ist
1068 @ifnottex
1069 @example
1070 inf
1071 ==== 2 k
1072 z v + 1 \ z
1073 L (z) = (-) > ----------------------------------
1074 v 2 / 2 k 3 3
1075 ==== 2 gamma(k + -) gamma(v + k + -)
1076 k = 0 2 2
1077 @end example
1078 @end ifnottex
1079 @tex
1080 $$L_{v}(z)=\left({{z}\over{2}}\right)^{v+1}\,\sum_{k=0}^{\infty }{{{z^{2\,k}
1081 }\over{2^{2\,k}\,\Gamma\left(k+{{3}\over{2}}\right)\,\Gamma\left(v+k
1082 +{{3}\over{2}}\right)}}}$$
1083 @end tex
1085 Die Struve-Funktion @code{struve_l} ist f@"ur das numerische und symbolische
1086 Rechnen geeignet. Im Unterschied zu den @nref{Bessel-Funktionen} ist jedoch
1087 die Implementation der Funktion @code{struve_l} weniger vollst@"andig.
1089 Maxima berechnet @code{struve_l} numerisch f@"ur reelle und komplexe
1090 Gleitkommazahlen als Argumente f@"ur @math{v} und @math{z}. Mit der Funktion
1091 @mref{float} oder der Optionsvariablen @mref{numer} kann die numerische
1092 Auswertung erzwungen werden, wenn die Argumente Zahlen sind. Die numerische
1093 Berechnung f@"ur gro@ss{}e Gleitkommazahlen ist nicht implementiert. In diesem
1094 Fall gibt Maxima eine Substantivform zur@"uck.
1096 Hat die Optionsvariable @mref{besselexpand} den Wert @code{true}, wird die
1097 Struve-Funktion @code{struve_l} mit einer halbzahligen Ordnung @math{v} als
1098 Sinus- und Kosinusfunktionen entwickelt.
1100 Maxima kennt die Ableitung der Struve-Funktion @code{struve_l} nach dem
1101 Argument @math{z}.
1103 Siehe auch die Struve-Funktion @mrefdot{struve_h}
1105 Beispiele:
1107 @example
1108 (%i1) struve_l(1, 0.5);
1109 (%o1) .05394218262352267
1110 (%i2) struve_l(1, 0.5+%i);
1111 (%o2) .1912720461247995 %i - .1646185598117401
1112 (%i3) struve_l(3/2,x), besselexpand: true;
1113 2
1114 2 x sinh(x) - 2 cosh(x) - x + 2
1115 (%o3) --------------------------------
1116 3/2
1117 sqrt(2) sqrt(%pi) x
1118 (%i4) diff(struve_l(v, x), x);
1119 v
1120 x
1121 (%o4) (------------------------- + struve_l(v + 1, x)
1122 v 3
1123 sqrt(%pi) 2 gamma(v + -)
1124 2
1125 + struve_l(v - 1, x))/2
1126 @end example
1127 @end deffn
1129 @c -----------------------------------------------------------------------------
1130 @node Gammafunktionen und verwandte Funktionen, Exponentielle Integrale, Bessel-Funktionen und verwandte Funktionen, Spezielle Funktionen
1131 @section Gammafunktionen und verwandte Funktionen
1132 @c -----------------------------------------------------------------------------
1134 Die Gammafunktion und die verwandten Funktionen wie die Beta-, Psi- und die
1135 unvollst@"andige Gammafunktion sind definiert in Abramowitz and Stegun,
1136 @i{Handbook of Mathematical Functions}, Kapitel 6.
1138 @c --- 29.05.2011 DK -----------------------------------------------------------
1139 @anchor{bffac}
1140 @deffn {Funktion} bffac (@var{x}, @var{fpprec})
1142 Berechnet die Fakult@"at f@"ur gro@ss{}e Gleitkommazahlen. Das Argument @var{x}
1143 muss eine gro@ss{}e Gleitkommazahl sein. Das zweite Argument @var{fpprec} ist
1144 die Anzahl der Stellen, f@"ur die die Fakult@"at berechnet wird. Das Ergebnis
1145 ist eine gro@ss{}e Gleitkommazahl.
1147 F@"ur das symbolische Rechnen mit der Fakult@"at und der Gammafunktion siehe die
1148 entsprechenden Funktionen @mref{factorial} und @mrefdot{gamma} Maxima ruft
1149 intern die Funktion @code{bffac} auf, um die Fakult@"at @code{factorial} und
1150 die Gammafunktion @code{gamma} f@"ur eine gro@ss{}e Gleitkommazahl numerisch zu
1151 berechnen.
1153 Siehe auch die Funktion @mref{cbffac} f@"ur die Berechnung der Fakult@"at f@"ur
1154 komplexe gro@ss{}e Gleitkommazahlen.
1156 Beispiel:
1158 @example
1159 (%i1) bffac(10.5b0, 25);
1160 (%o1) 1.189942308396224845701304b7
1161 (%i2) fpprec:25$
1162 (%i3) 10.5b0!;
1163 (%o3) 1.189942308396224845701303b7
1164 @end example
1165 @end deffn
1167 @c --- 29.05.2011 DK -----------------------------------------------------------
1168 @anchor{bfpsi}
1169 @deffn {Funktion} bfpsi (@var{n}, @var{x}, @var{fpprec})
1170 @deffnx {Funktion} bfpsi0 (@var{x}, @var{fpprec})
1172 @code{bfpsi} ist die Polygammafunktion f@"ur ein reelles Argument @var{x} und
1173 einer ganzzahligen Ordnung @var{n}. @code{bfpsi0} ist die Digammafunktion.
1174 @code{bfpsi0(@var{x}, @var{fpprec})} ist @"aquivalent zu @code{bfpsi(0, @var{x},
1175 @var{fpprec})}.
1177 Das Argument @var{x} der Funktionen @code{bfpsi} und @code{bfpsi0} muss eine
1178 gro@ss{}e Gleitkommazahl sein. Das Argument @var{fpprec} gibt die Anzahl der
1179 Stellen an, f@"ur die die Funktion berechnet wird. Das Ergebnis ist eine
1180 gro@ss{}e Gleitkommazahl.
1182 F@"ur das symbolische Rechnen mit der Polygammafunktion siehe die Funktion
1183 @mrefdot{psi} Maxima ruft intern die Funktion @code{bfpsi} auf, um die
1184 Polygammafunktion f@"ur gro@ss{}e Gleitkommazahlen numerisch zu berechnen.
1186 Beispiel:
1188 @example
1189 (%i1) bfpsi(0, 1, 25);
1190 (%o1) - 5.772156649015328606065121b-1
1191 (%i2) fpprec:25$
1193 (%i3) psi[0](1.0b0);
1194 (%o3) - 5.772156649015328606065121b-1
1195 @end example
1196 @end deffn
1198 @c --- 29.05.2011 DK -----------------------------------------------------------
1199 @anchor{cbffac}
1200 @deffn {Funktion} cbffac (@var{z}, @var{fpprec})
1202 Berechnet die Fakult@"at f@"ur komplexe gro@ss{}e Gleitkommazahlen. Das
1203 Argument @var{z} ist eine komplexe gro@ss{}e Gleitkommazahl. Das zweite
1204 Argument @var{fpprec} ist die Anzahl der Stellen, f@"ur die die Fakult@"at
1205 berechnet wird. Das Ergebnis ist eine komplexe gro@ss{}e Gleitkommazahl.
1207 F@"ur das symbolische Rechnen mit der Fakult@"at und der Gammafunktion siehe die
1208 entsprechenden Funktionen @mref{factorial} und @mrefdot{gamma} Maxima ruft
1209 intern die Funktion @code{cbffac} auf, um die Fakult@"at @code{factorial} und
1210 die Gammafunktion @code{gamma} f@"ur eine komplexe gro@ss{}e Gleitkommazahl
1211 numerisch zu berechnen.
1213 Siehe auch die Funktion @mrefdot{bffac}
1214 @end deffn
1216 @c --- 29.05.2011 DK -----------------------------------------------------------
1217 @anchor{gamma}
1218 @deffn {Funktion} gamma (@var{z})
1220 Die Definition der Gammafunktion ist (A & S 6.1.1)
1222 @example
1223 inf
1224 /
1225 [ z - 1 - t
1226 gamma(z) = I t %e dt
1227 ]
1228 /
1229 0
1230 @end example
1232 Die Gammafunktion @code{gamma} ist f@"ur das numerische und symbolische Rechnen
1233 geeignet. F@"ur positive ganze Zahlen und rationale Zahlen als Argument @var{z}
1234 wird die Gammafunktion vereinfacht. F@"ur halbzahlige rationale Zahlen ist das
1235 Ergebnis der Vereinfachung eine rationale Zahl multipliziert mit
1236 @code{sqrt(%pi)}. Die Vereinfachung f@"ur ganze Zahlen wird von der
1237 Optionsvariablen @mref{factlim} kontrolliert. F@"ur ganze Zahlen, die
1238 gr@"o@ss{}er als @code{factlim} sind, kann es zu einem @"Uberlauf bei der
1239 Berechnung der Gammafunktion kommen. Entsprechend wird die Vereinfachung f@"ur
1240 rationale Zahlen von der Optionsvariablen @mref{gammalim} kontrolliert.
1242 F@"ur negative ganze Zahlen ist die Gammafunktion @code{gamma} nicht definiert.
1244 Maxima berechnet @code{gamma} numerisch f@"ur reelle und komplexe Argumente
1245 @var{z}. Das Ergebnis ist eine reelle oder komplexe Gleitkommazahl.
1247 @code{gamma} hat Spiegelsymmetrie.
1249 Hat die Optionsvariable @mref{gamma_expand} den Wert @code{true}, entwickelt
1250 Maxima die Gammafunktion f@"ur Argumente der Form @code{z+n} und @code{z-n},
1251 wobei @var{n} eine ganze Zahl ist.
1253 Maxima kennt die Ableitung der Gammafunktion @code{gamma}.
1255 Siehe auch die Funktion @mrefcomma{makegamma} um Fakult@"aten und
1256 Betafunktionen in einem Ausdruck durch die Gammafunktion zu ersetzen.
1258 Die Euler-Mascheroni-Konstante ist @mrefdot{%gamma}
1260 Beispiele:
1262 Vereinfachung f@"ur ganze Zahlen und rationale Zahlen.
1264 @example
1265 (%i1) map('gamma,[1,2,3,4,5,6,7,8,9]);
1266 (%o1) [1, 1, 2, 6, 24, 120, 720, 5040, 40320]
1267 (%i2) map('gamma,[1/2,3/2,5/2,7/2]);
1268 sqrt(%pi) 3 sqrt(%pi) 15 sqrt(%pi)
1269 (%o2) [sqrt(%pi), ---------, -----------, ------------]
1270 2 4 8
1271 (%i3) map('gamma,[2/3,5/3,7/3]);
1272 2 1
1273 2 gamma(-) 4 gamma(-)
1274 2 3 3
1275 (%o3) [gamma(-), ----------, ----------]
1276 3 3 9
1277 @end example
1279 Numerische Berechnung f@"ur reelle und komplexe Argumente.
1281 @example
1282 (%i4) map('gamma,[2.5,2.5b0]);
1283 (%o4) [1.329340388179137, 1.3293403881791370205b0]
1284 (%i5) map('gamma,[1.0+%i,1.0b0+%i]);
1285 (%o5) [0.498015668118356 - .1549498283018107 %i,
1286 4.9801566811835604272b-1 - 1.5494982830181068513b-1 %i]
1287 @end example
1289 @code{gamma} hat Spiegelsymmetrie.
1291 @example
1292 (%i6) declare(z,complex)$
1293 (%i7) conjugate(gamma(z));
1294 (%o7) gamma(conjugate(z))
1295 @end example
1297 Maxima entwickelt @code{gamma(z+n)} und @code{gamma(z-n)}, wenn die
1298 Optionsvariable @code{gamma_expand} den Wert @code{true} hat.
1300 @example
1301 (%i8) gamma_expand:true$
1303 (%i9) [gamma(z+1),gamma(z-1),gamma(z+2)/gamma(z+1)];
1304 @group
1305 gamma(z)
1306 (%o9) [z gamma(z), --------, z + 1]
1307 z - 1
1308 @end group
1309 @end example
1311 Die Ableitung der Gammafunktion @code{gamma}.
1313 @example
1314 (%i10) diff(gamma(z),z);
1315 (%o10) psi (z) gamma(z)
1316 0
1317 @end example
1318 @end deffn
1320 @c --- 29.05.2011 DK -----------------------------------------------------------
1321 @anchor{gamma_expand}
1322 @defvr {Optionsvariable} gamma_expand
1323 Standardwert: @code{false}
1325 Kontrolliert die Vereinfachung der Gammafunktion @mref{gamma} und verwandte
1326 Funktionen wie @mref{gamma_incomplete} f@"ur den Fall, dass das Argument die
1327 Form @code{z+n} oder @code{z-n} hat. Dabei ist @code{z} ist ein beliebiges
1328 Argument und @code{n} ist eine ganze Zahl.
1330 Siehe die Funktion @code{gamma} f@"ur ein Beispiel.
1331 @end defvr
1333 @c --- 29.05.2011 DK -----------------------------------------------------------
1334 @anchor{log_gamma}
1335 @deffn {Funktion} log_gamma (@var{z})
1337 Der Logarithmus der Gammafunktion.
1338 @end deffn
1340 @c --- 29.05.2011 DK -----------------------------------------------------------
1341 @anchor{gamma_incomplete}
1342 @deffn {Funktion} gamma_incomplete (@var{a}, @var{z})
1344 Die unvollst@"andige Gammafunktion (A & S 6.5.2) die definiert ist als
1346 @tex
1347 $$\int_{z}^{\infty }{t^{a-1}\,e^ {- t }\;dt}$$
1348 @end tex
1349 @ifnottex
1350 @example
1351 inf
1352 /
1353 [ a - 1 - t
1354 I t %e dt
1355 ]
1356 /
1357 z
1358 @end example
1359 @end ifnottex
1360 @end deffn
1362 @c --- 29.05.2011 DK -----------------------------------------------------------
1363 @anchor{gamma_incomplete_regularized}
1364 @deffn {Funktion} gamma_incomplete_regularized (@var{a}, @var{z})
1366 Regularisierte unvollst@"andige Gammafunktion (A & S 6.5.1)
1368 @tex
1369 $${{{\it gamma\_incomplete}\left(a , z\right)}\over{\Gamma\left(a
1370 \right)}}$$
1371 @end tex
1372 @ifnottex
1373 @example
1374 gamma_incomplete(a, z)
1375 ----------------------
1376 gamma(a)
1377 @end example
1378 @end ifnottex
1379 @end deffn
1381 @c --- 29.05.2011 DK -----------------------------------------------------------
1382 @anchor{gamma_incomplete_generalized}
1383 @deffn {Funktion} gamma_incomplete_generalized (@var{a}, @var{z1}, @var{z2})
1385 Verallgemeinerte unvollst@"andige Gammafunktion
1387 @tex
1388 $$\int_{z1}^{z2}{t^{a-1}\,e^ {- t }\;dt}$$
1389 @end tex
1390 @ifnottex
1391 @example
1392 z2
1393 /
1394 [ a - 1 - t
1395 I t %e dt
1396 ]
1397 /
1398 z1
1399 @end example
1400 @end ifnottex
1401 @end deffn
1403 @c --- 29.05.2011 DK -----------------------------------------------------------
1404 @anchor{gammalim}
1405 @defvr {Optionsvariable} gammalim
1406 Standardwert: 1000000
1408 Kontrolliert die Vereinfachung der Gammafunktion f@"ur rationale Argumente.
1409 Ist der Betrag des Arguments der Gammafunktion gr@"o@ss{}er als @code{gammalim},
1410 wird die Gammafunktion nicht vereinfacht. Damit wird verhindert, dass
1411 die Berechnung der Gammafunktion zu einem @"Uberlauf f@"uhrt und mit einem
1412 Fehler abbricht.
1414 Siehe auch die Optionsvariable @mrefcomma{factlim} um die Vereinfachung f@"ur
1415 ganze Zahlen zu kontrollieren.
1416 @end defvr
1418 @c --- 29.05.2011 DK -----------------------------------------------------------
1419 @anchor{makegamma}
1420 @deffn {Funktion} makegamma (@var{expr})
1422 Ersetzt Fakult@"aten sowie Binomial- und Betafunktionen durch die Gammafunktion
1423 @mref{gamma} im Ausdruck @var{expr}.
1425 Siehe auch die Funktion @mrefcomma{makefact} um stattdessen Fakult@"aten in den
1426 Ausdruck einzusetzen.
1428 Beispiel:
1430 @example
1431 (%i1) expr: binomial(a,b)*gamma(b+1)/gamma(a+1);
1432 binomial(a, b) gamma(b + 1)
1433 (%o1) ---------------------------
1434 gamma(a + 1)
1435 (%i2) makegamma(expr);
1436 1
1437 (%o2) ------------------
1438 gamma(- b + a + 1)
1439 @end example
1440 @end deffn
1442 @c --- 29.05.2011 DK -----------------------------------------------------------
1443 @anchor{beta}
1444 @deffn {Funktion} beta (@var{a}, @var{b})
1446 Die Betafunktion ist definiert als @code{gamma(a) gamma(b)/gamma(a+b)}
1447 (A & S 6.2.1).
1449 Maxima vereinfacht die Betafunktion f@"ur positive ganze Zahlen @var{a} und
1450 @var{b} sowie rationale Zahlen, deren Summe @code{@var{a} + @var{b}} eine ganze
1451 Zahl ist. Hat die Optionsvariable @mref{beta_args_sum_to_integer} den Wert
1452 @code{true}, vereinfacht Maxima die Betafunktion f@"ur allgemeine Ausdr@"ucke
1453 @var{a} und @var{b}, deren Summe eine ganze Zahl ist.
1455 Ist eines der Argumente @var{a} oder @var{b} Null, ist die Betafunktion nicht
1456 definiert.
1458 Im allgemeinen ist die Betafunktion nicht definiert f@"ur negative ganze Zahlen
1459 als Argument. Ausnahme ist der Fall, dass @var{a = -n}, wobei @var{n} eine
1460 positive ganze Zahl und @var{b} eine positive ganze Zahl mit @var{b <= b} ist.
1461 In diesem Fall kann eine analytische Fortsetzung der Betafunktion definiert
1462 werden. Maxima gibt f@"ur diesen Fall ein Ergebnis zur@"uck.
1464 Hat die Optionsvariable @code{beta_expand} den Wert @code{true}, werden
1465 Ausdr@"ucke wie @code{beta(a+n, b} und @code{beta(a-n, b)} oder
1466 @code{beta(a, b+n} und @code{beta(a, b-n)} entwickelt.
1468 Maxima berechnet die Betafunktion f@"ur reelle und komplexe Gleitkommazahlen
1469 numerisch. F@"ur die numerische Berechnung nutzt Maxima die Funktion
1470 @mref{log_gamma}:
1472 @example
1473 - log_gamma(b + a) + log_gamma(b) + log_gamma(a)
1474 %e
1475 @end example
1477 Maxima kennt Symmetrieeigenschaften der Betafunktion. Die Betafunktion ist
1478 symmetrisch und hat Spiegelsymmetrie.
1480 Maxima kennt die Ableitung der Betafunktion nach den Argumenten @var{a} und
1481 @var{b}.
1483 Mit der Funktion @mref{makegamma} kann die Betafunktion durch Gammafunktionen
1484 ersetzt werden. Entsprechend ersetzt die Funktion @mref{makefact}@w{}
1485 Betafunktionen in einem Ausdruck durch Fakult@"aten.
1487 Beispiele:
1489 Vereinfachung der Betafunktion, wenn eines der Argumente eine ganze Zahl ist.
1491 @example
1492 (%i1) [beta(2,3),beta(2,1/3),beta(2,a)];
1493 @group
1494 1 9 1
1495 (%o1) [--, -, ---------]
1496 12 4 a (a + 1)
1497 @end group
1498 @end example
1500 Vereinfachung der Betafunktion f@"ur zwei rationale Argumente, die sich zu
1501 einer ganzen Zahl summieren.
1503 @example
1504 (%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)];
1505 3 %pi 2 %pi
1506 (%o2) [-----, -------, sqrt(2) %pi]
1507 8 sqrt(3)
1508 @end example
1510 Hat die Optionsvariable @code{beta_args_sum_to_integer} den Wert @code{true},
1511 vereinfacht die Betafunktion f@"ur allgemeine Ausdr@"ucke, die sich zu einer
1512 ganzen Zahl summieren.
1514 @example
1515 (%i3) beta_args_sum_to_integer:true$
1516 (%i4) beta(a+1,-a+2);
1517 %pi (a - 1) a
1518 (%o4) ------------------
1519 2 sin(%pi (2 - a))
1520 @end example
1522 Die m@"oglichen Ergebnisse, wenn eines der Argumente eine negative ganze
1523 Zahl ist.
1525 @example
1526 (%i5) [beta(-3,1),beta(-3,2),beta(-3,3)];
1527 1 1 1
1528 (%o5) [- -, -, - -]
1529 3 6 3
1530 @end example
1532 Vereinfachungen, wenn die Optionsvariable @code{beta_expand} den Wert
1533 @code{true} hat.
1535 @example
1536 (%i6) beta_expand:true$
1537 (%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)];
1538 a beta(a, b) beta(a, b) (b + a - 1) a
1539 (%o7) [------------, ----------------------, -]
1540 b + a a - 1 b
1542 @end example
1544 Die Betafunktion ist nicht definiert, wenn eines der Argumente Null ist.
1546 @example
1547 (%i7) beta(0,b);
1548 beta: expected nonzero arguments; found 0, b
1549 -- an error. To debug this try debugmode(true);
1550 @end example
1552 Numerische Berechnung der Betafunktion f@"ur reelle und komplexe Argumente.
1554 @example
1555 (%i8) beta(2.5,2.3);
1556 (%o8) .08694748611299981
1558 (%i9) beta(2.5,1.4+%i);
1559 (%o9) 0.0640144950796695 - .1502078053286415 %i
1561 (%i10) beta(2.5b0,2.3b0);
1562 (%o10) 8.694748611299969b-2
1564 (%i11) beta(2.5b0,1.4b0+%i);
1565 (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i
1566 @end example
1568 Die Betafunktion ist symmetrisch und hat Spiegelsymmetrie.
1570 @example
1571 (%i14) beta(a,b)-beta(b,a);
1572 (%o14) 0
1573 (%i15) declare(a,complex,b,complex)$
1574 (%i16) conjugate(beta(a,b));
1575 (%o16) beta(conjugate(a), conjugate(b))
1576 @end example
1578 Ableitung der Betafunktion.
1580 @example
1581 (%i17) diff(beta(a,b),a);
1582 (%o17) - beta(a, b) (psi (b + a) - psi (a))
1583 0 0
1584 @end example
1585 @end deffn
1587 @c --- 29.05.2011 DK -----------------------------------------------------------
1588 @anchor{beta_incomplete}
1589 @deffn {Funktion} beta_incomplete (@var{a}, @var{b}, @var{z})
1591 Die Definition der unvollst@"andigen Betafunktion ist (A & S 6.6.1)
1593 @example
1594 z
1595 /
1596 [ b - 1 a - 1
1597 I (1 - t) t dt
1598 ]
1599 /
1600 0
1601 @end example
1603 Diese Definition ist m@"oglich f@"ur @math{realpart(a)>0} und
1604 @math{realpart(b)>0} sowie @math{abs(z)<1}. F@"ur andere Werte kann die
1605 unvollst@"andige Betafunktion als eine verallgemeinerte Hypergeometrische
1606 Funktion definiert werden:
1608 @example
1609 gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z
1610 @end example
1612 (Siehe @url{https://functions.wolfram.com/} f@"ur eine Definition der unvollst@"andigen
1613 Betafunktion.)
1615 F@"ur negative ganze Zahlen @math{a = -n} und positive ganze Zahlen
1616 @math{b = m} mit @math{m <= n} kann die unvollst@"andige Betafunktion definiert
1617 werden als
1619 @example
1620 m - 1 k
1621 ==== (1 - m) z
1622 n - 1 \ k
1623 z > -----------
1624 / k! (n - k)
1625 ====
1626 k = 0
1627 @end example
1629 Maxima nutzt diese Definition, um die Funktion @code{beta_incomplete} f@"ur
1630 negative ganzzahlige Argumente @var{a} zu vereinfachen.
1632 F@"ur positive ganzzahlige Argumente @var{a} vereinfacht @code{beta_incomplete}
1633 f@"ur jedes Argument @var{b} und @var{z}. Entsprechend vereinfacht
1634 @code{beta_incomplete} f@"ur ein positives ganzzahliges Argument @var{b} mit
1635 der Ausnahme, dass @var{a} eine negative ganze Zahl ist.
1637 F@"ur @math{z=0} und @math{realpart(a) > 0} hat @code{beta_incomplete} den
1638 speziellen Wert Null. F@"ur @var{z=1} und @math{realpart(b) > 0} vereinfacht
1639 @code{beta_incomplete} zu einem Ausdruck mit der Betafunktion @code{beta(a, b)}.
1641 Maxima berechnet @code{beta_incomplete} numerisch f@"ur reelle und komplexe
1642 Gleitkommazahlen als Argumente. F@"ur die numerische Berechnung nutzt Maxima
1643 eine Entwicklung der unvollst@"andigen Betafunktion als Kettenbruch.
1645 Hat die Optionsvariable @mref{beta_expand} den Wert @code{true}, entwickelt
1646 Maxima Ausdr@"ucke der Form @code{beta_incomplete(a+n, b, z)} und
1647 @code{beta_incomplete(a-n, b, z)}, wobei @code{n} eine ganze Zahl ist.
1649 Maxima kennt die Ableitungen der unvollst@"andigen Betafunktion nach den
1650 Variablen @var{a}, @var{b} und @var{z} und das Integral f@"ur die
1651 Integrationsvariable @var{z}.
1653 Beispiele:
1655 Vereinfachung f@"ur eine positive ganze Zahl als Argument @var{a}.
1657 @example
1658 (%i1) beta_incomplete(2,b,z);
1659 b
1660 1 - (1 - z) (b z + 1)
1661 (%o1) ----------------------
1662 b (b + 1)
1663 @end example
1665 Vereinfachung f@"ur eine positive ganze Zahl als Argument @var{b}.
1667 @example
1668 (%i2) beta_incomplete(a,2,z);
1669 a
1670 (a (1 - z) + 1) z
1671 (%o2) ------------------
1672 a (a + 1)
1673 @end example
1675 Vereinfachung f@"ur positive ganzzahlige Argumente @var{a} und @var{b}.
1677 @example
1678 (%i3) beta_incomplete(3,2,z);
1679 3
1680 (3 (1 - z) + 1) z
1681 (%o3) ------------------
1682 12
1683 @end example
1685 @var{a} ist eine negative ganze Zahl mit @math{b <= (-a)}. Maxima vereinfacht
1686 f@"ur diesem Fall.
1688 @example
1689 (%i4) beta_incomplete(-3,1,z);
1690 1
1691 (%o4) - ----
1692 3
1693 3 z
1694 @end example
1696 F@"ur die speziellen Werte @math{z=0} und @math{z=1} vereinfacht Maxima.
1698 @example
1699 (%i5) assume(a>0,b>0)$
1700 (%i6) beta_incomplete(a,b,0);
1701 (%o6) 0
1702 (%i7) beta_incomplete(a,b,1);
1703 (%o7) beta(a, b)
1704 @end example
1706 Numerische Berechnung f@"ur reelle Argumente.
1708 @example
1709 (%i8) beta_incomplete(0.25,0.50,0.9);
1710 (%o8) 4.594959440269333
1711 (%i9) fpprec:25$
1712 (%i10) beta_incomplete(0.25,0.50,0.9b0);
1713 (%o10) 4.594959440269324086971203b0
1714 @end example
1716 F@"ur @math{abs(z) > 1} ist das Ergebnis komplex.
1718 @example
1719 (%i11) beta_incomplete(0.25,0.50,1.7);
1720 (%o11) 5.244115108584249 - 1.45518047787844 %i
1721 @end example
1723 Numerische Ergebnisse f@"ur komplexe Argumente.
1725 @example
1726 (%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i);
1727 (%o14) 2.726960675662536 - .3831175704269199 %i
1728 (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i);
1729 (%o15) 13.04649635168716 %i - 5.802067956270001
1730 (%i16)
1731 @end example
1733 Entwicklung, wenn @code{beta_expand} den Wert @code{true} hat.
1735 @example
1736 (%i23) beta_incomplete(a+1,b,z),beta_expand:true;
1737 b a
1738 a beta_incomplete(a, b, z) (1 - z) z
1739 (%o23) -------------------------- - -----------
1740 b + a b + a
1742 (%i24) beta_incomplete(a-1,b,z),beta_expand:true;
1743 b a - 1
1744 beta_incomplete(a, b, z) (- b - a + 1) (1 - z) z
1745 (%o24) -------------------------------------- - ---------------
1746 1 - a 1 - a
1747 @end example
1749 Ableitung und Integral der unvollst@"andigen Betafunktion.
1751 @example
1752 (%i34) diff(beta_incomplete(a, b, z), z);
1753 b - 1 a - 1
1754 (%o34) (1 - z) z
1755 (%i35) integrate(beta_incomplete(a, b, z), z);
1756 b a
1757 (1 - z) z
1758 (%o35) ----------- + beta_incomplete(a, b, z) z
1759 b + a
1760 a beta_incomplete(a, b, z)
1761 - --------------------------
1762 b + a
1763 (%i36) factor(diff(%, z));
1764 (%o36) beta_incomplete(a, b, z)
1765 @end example
1766 @end deffn
1768 @c --- 09.07.2011 DK -----------------------------------------------------------
1769 @anchor{beta_incomplete_regularized}
1770 @deffn {Funktion} beta_incomplete_regularized (@var{a}, @var{b}, @var{z})
1772 @c The regularized incomplete beta function A&S 6.6.2, defined as
1774 Die regularisierte unvollst@"andige Beta Funktion (A & S 6.6.2), die definiert
1775 ist als
1777 @example
1778 beta_incomplete(a, b, z)
1779 ------------------------
1780 beta(a, b)
1781 @end example
1783 @c As for @code{beta_incomplete} this definition is not complete. See
1784 @c functions.wolfram.com for a complete definition of
1785 @c @code{beta_incomplete_regularized}.
1787 Wie bei der Funktion @mref{beta_incomplete} ist diese Definition nicht
1788 vollst@"andig. Siehe @url{https://functions.wolfram.com} f@"ur eine vollst@"andige
1789 Definition der Funktion.
1791 @c @code{beta_incomplete_regularized} simplifies @var{a} or @var{b} a positive
1792 @c integer.
1793 @c For @math{z=0} and @math{realpart(a)>0}, @code{beta_incomplete_regularized}
1794 @c has the specific value 0. For @var{z=1} and @math{realpart(b)>0},
1795 @c @code{beta_incomplete_regularized} simplifies to 1.
1797 @code{beta_incomplete_regularized} vereinfacht, wenn das Argument @var{a} oder
1798 @var{b} eine positive ganze Zahl ist. F@"ur Argumente @code{@var{z} = 0} und
1799 @code{realpart(@var{a}) > 0} vereinfacht die Funktion
1800 @code{beta_incomplete_regularized} zu @code{0}. F@"ur @code{@var{z} = 1} und
1801 @code{realpart(@var{b}) > 0} vereinfacht die Funktion
1802 @code{beta_incomplete_regularized} zu @code{1}.
1804 @c Maxima can evaluate @code{beta_incomplete_regularized} for real and complex
1805 @c arguments in float and bigfloat precision.
1807 Maxima berechnet @code{beta_incomplete_regularized} f@"ur reelle und komplexe
1808 Gleitkommazahlen als Argumente numerisch.
1810 When @code{beta_expand} is @code{true}, Maxima expands
1811 @code{beta_incomplete_regularized} for arguments @math{a+n} or @math{a-n},
1812 where n is an integer.
1814 Hat die Optionsvariable @mref{beta_expand} den Wert @code{true}, expandiert
1815 Maxima @code{beta_incomplete_regularized} f@"ur Argumente @math{a+n} oder
1816 @math{a-n}, wobei @var{n} eine ganze Zahl ist.
1818 @c Maxima knows the derivatives of @code{beta_incomplete_regularized} with
1819 @c respect to the variables @var{a}, @var{b}, and @var{z} and the integral with
1820 @c respect to the variable @var{z}.
1822 Maxima kennt die Ableitung der Funktion @code{beta_incomplete_regularized}
1823 nach den Argumenten @var{a}, @var{b} und @var{z} sowie das Integral f@"ur das
1824 Argument @var{z}.
1826 Beispiele:
1828 @c Simplification for @var{a} or @var{b} a positive integer:
1830 Vereinfachung, wenn die Argumente @var{a} oder @var{b} ganze Zahlen sind.
1832 @example
1833 (%i1) beta_incomplete_regularized(2,b,z);
1834 b
1835 (%o1) 1 - (1 - z) (b z + 1)
1836 (%i2) beta_incomplete_regularized(a,2,z);
1837 a
1838 (%o2) (a (1 - z) + 1) z
1839 (%i3) beta_incomplete_regularized(3,2,z);
1840 3
1841 (%o3) (3 (1 - z) + 1) z
1842 @end example
1844 @c For the specific values @math{z=0} and @math{z=1}, Maxima simplifies:
1846 F@"ur die speziellen Werte @math{z=0} und @math{z=1} vereinfacht Maxima.
1848 @example
1849 (%i4) assume(a>0,b>0)$
1851 (%i5) beta_incomplete_regularized(a,b,0);
1852 (%o5) 0
1853 (%i6) beta_incomplete_regularized(a,b,1);
1854 (%o6) 1
1855 @end example
1857 @c Numerical evaluation for real and complex arguments in float and bigfloat
1858 @c precision:
1860 Numerische Berechnung f@"ur reelle und komplexe Argumente.
1862 @example
1863 (%i7) beta_incomplete_regularized(0.12,0.43,0.9);
1864 (%o7) .9114011367359802
1865 (%i8) fpprec:32$
1867 (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0);
1868 (%o9) 9.1140113673598075519946998779975b-1
1869 (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i);
1870 (%o10) .2865367499935405 %i - .1229959633346841
1871 (%i11) fpprec:20$
1873 (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i);
1874 (%o12) 2.8653674999354036142b-1 %i - 1.2299596333468400163b-1
1875 @end example
1877 @c Expansion, when @code{beta_expand} is @code{true}:
1879 Expansion, wenn @code{beta_expand} den Wert @code{true} hat.
1881 @example
1882 (%i13) beta_incomplete_regularized(a+1,b,z);
1883 b a
1884 (1 - z) z
1885 (%o13) beta_incomplete_regularized(a, b, z) - ------------
1886 a beta(a, b)
1887 (%i14) beta_incomplete_regularized(a-1,b,z);
1888 @group
1889 (%o14) beta_incomplete_regularized(a, b, z)
1890 b a - 1
1891 (1 - z) z
1892 - ----------------------
1893 beta(a, b) (b + a - 1)
1894 @end group
1895 @end example
1897 @c The derivative and the integral wrt @var{z}:
1899 Die Ableitung und das Integral der Funktion.
1901 @example
1902 (%i15) diff(beta_incomplete_regularized(a,b,z),z);
1903 b - 1 a - 1
1904 (1 - z) z
1905 (%o15) -------------------
1906 beta(a, b)
1907 (%i16) integrate(beta_incomplete_regularized(a,b,z),z);
1908 (%o16) beta_incomplete_regularized(a, b, z) z
1909 b a
1910 (1 - z) z
1911 a (beta_incomplete_regularized(a, b, z) - ------------)
1912 a beta(a, b)
1913 - -------------------------------------------------------
1914 b + a
1915 @end example
1916 @end deffn
1918 @c --- 11.07.2011 DK -----------------------------------------------------------
1919 @anchor{beta_incomplete_generalized}
1920 @deffn {Funktion} beta_incomplete_generalized (@var{a}, @var{b}, @var{z1}, @var{z2})
1922 @c The basic definition of the generalized incomplete beta function is
1924 Die Definition der verallgemeinerten unvollst@"andigen Betafunktion ist
1926 @example
1927 z2
1928 /
1929 [ b - 1 a - 1
1930 I (1 - t) t dt
1931 ]
1932 /
1933 z1
1934 @end example
1936 @c Maxima simplifies @code{beta_incomplete_regularized} for @var{a} and @var{b}
1937 @c a positive integer.
1939 Maxima vereinfacht @code{beta_incomplete_refularized} f@"ur positive ganzzahlige
1940 Argumente @var{a} und @var{b}.
1942 @c For @math{realpart(a)>0} and @math{z1=0} or @math{z2=0}, Maxima simplifies
1943 @c @code{beta_incomplete_generalized} to @code{beta_incomplete}. For
1944 @c @math{realpart(b)>0} and @math{z1=1} or @var{z2=1}, Maxima simplifies to an
1945 @c expression with @code{beta} and @code{beta_incomplete}.
1947 Ist @math{realpart(a)>0} und @math{z1=0} oder @math{z2=0}, vereinfacht Maxima
1948 @code{beta_incomplete_generalized} zu der Funktion
1949 @mrefdot{beta_incomplete} Ist @math{realpart(b)>0} und @math{z1=1} oder
1950 @var{z2=1}, vereinfacht Maxima zu einem Ausdruck mit der Funktion
1951 @mref{beta} und @mrefdot{beta_incomplete}
1953 @c Maxima evaluates @code{beta_incomplete_regularized} for real and complex
1954 @c values in float and bigfloat precision.
1956 Maxima berechnet @code{beta_incomplete_regularized} numerisch f@"ur reelle und
1957 komplexe Gleitkommazahlen in doppelter und beliebiger Genauigkeit.
1959 @c When @code{beta_expand} is @code{true}, Maxima expands
1960 @c @code{beta_incomplete_generalized} for @math{a+n} and @math{a-n}, @var{n} a
1961 @c positive integer.
1963 Hat die Optionsvariable @mref{beta_expand} den Wert @code{true}, dann expandiert
1964 Maxima @code{beta_incomplete_generalized} f@"ur Argumente @math{a+n} und
1965 @math{a-n}, wobei @var{n} eine positive ganze Zahl ist.
1967 @c Maxima knows the derivative of @code{beta_incomplete_generalized} with
1968 @c respect to the variables @var{a}, @var{b}, @var{z1}, and @var{z2} and the
1969 @c integrals with respect to the variables @var{z1} and @var{z2}.
1971 Maxima kennt die Ableitung der Funktion @code{beta_incomplete_generalized} nach
1972 den Variablen @var{a}, @var{b}, @var{z1} und @var{z2} sowie die Integrale
1973 f@"ur die Integrationsvariablen @var{z1} und @var{z2}.
1975 Beispiele:
1977 @c Maxima simplifies @code{beta_incomplete_generalized} for @var{a} and @var{b}
1978 @c a positive integer:
1980 Maxima vereinfacht @code{beta_incomplete_generalized}, wenn @var{a} und @var{b}
1981 positive ganze Zahlen sind.
1983 @example
1984 (%i1) beta_incomplete_generalized(2,b,z1,z2);
1985 @group
1986 b b
1987 (1 - z1) (b z1 + 1) - (1 - z2) (b z2 + 1)
1988 (%o1) -------------------------------------------
1989 b (b + 1)
1990 @end group
1991 (%i2) beta_incomplete_generalized(a,2,z1,z2);
1992 @group
1993 a a
1994 (a (1 - z2) + 1) z2 - (a (1 - z1) + 1) z1
1995 (%o2) -------------------------------------------
1996 a (a + 1)
1997 @end group
1998 (%i3) beta_incomplete_generalized(3,2,z1,z2);
1999 2 2 2 2
2000 (1 - z1) (3 z1 + 2 z1 + 1) - (1 - z2) (3 z2 + 2 z2 + 1)
2001 (%o3) -----------------------------------------------------------
2002 12
2003 @end example
2005 @c Simplification for specific values @math{z1=0}, @math{z2=0}, @math{z1=1}, or
2006 @c @math{z2=1}:
2008 Vereinfachung f@"ur die speziellen Werte @math{z1=0}, @math{z2=0}, @math{z1=1}
2009 und @math{z2=1}.
2011 @example
2012 (%i4) assume(a > 0, b > 0)$
2013 (%i5) beta_incomplete_generalized(a,b,z1,0);
2014 (%o5) - beta_incomplete(a, b, z1)
2016 (%i6) beta_incomplete_generalized(a,b,0,z2);
2017 (%o6) - beta_incomplete(a, b, z2)
2019 (%i7) beta_incomplete_generalized(a,b,z1,1);
2020 (%o7) beta(a, b) - beta_incomplete(a, b, z1)
2022 (%i8) beta_incomplete_generalized(a,b,1,z2);
2023 (%o8) beta_incomplete(a, b, z2) - beta(a, b)
2024 @end example
2026 @c Numerical evaluation for real arguments in float or bigfloat precision:
2028 Numerische Berechnung f@"ur reelle Argumente in doppelter und beliebiger
2029 Gleitkommagenauigkeit.
2031 @example
2032 (%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31);
2033 (%o9) .09638178086368676
2035 (%i10) fpprec:32$
2036 (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0);
2037 (%o10) 9.6381780863686935309170054689964b-2
2038 @end example
2040 @c Numerical evaluation for complex arguments in float or bigfloat precision:
2042 Numerische Berechnung f@"ur komplexe Argumente in doppelter und beliebiger
2043 Gleitkommagenauigkeit.
2045 @example
2046 (%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31);
2047 (%o11) - .09625463003205376 %i - .003323847735353769
2048 (%i12) fpprec:20$
2049 (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0);
2050 (%o13) - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3
2051 @end example
2053 @c Expansion for @math{a+n} or @math{a-n}, @var{n} a positive integer, when
2054 @c @code{beta_expand} is @code{true}:
2056 Expansion f@"ur @math{a+n} oder @math{a-n} und @var{n} eine positive ganze Zahl,
2057 wenn @code{beta_expand} den Wert @code{true} hat.
2059 @example
2060 (%i14) beta_expand:true$
2062 (%i15) beta_incomplete_generalized(a+1,b,z1,z2);
2063 @group
2064 b a b a
2065 (1 - z1) z1 - (1 - z2) z2
2066 (%o15) -----------------------------
2067 b + a
2068 a beta_incomplete_generalized(a, b, z1, z2)
2069 + -------------------------------------------
2070 b + a
2071 @end group
2072 (%i16) beta_incomplete_generalized(a-1,b,z1,z2);
2074 beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1)
2075 (%o16) -------------------------------------------------------
2076 1 - a
2077 b a - 1 b a - 1
2078 (1 - z2) z2 - (1 - z1) z1
2079 - -------------------------------------
2080 1 - a
2081 @end example
2083 @c Derivative wrt the variable @var{z1} and integrals wrt @var{z1} and @var{z2}:
2085 Ableitung nach der Variablen @var{z1} und die Integrale f@"ur die
2086 Integrationsvariablen @var{z1} und @var{z2}.
2088 @example
2089 (%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1);
2090 b - 1 a - 1
2091 (%o17) - (1 - z1) z1
2092 (%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1);
2093 (%o18) beta_incomplete_generalized(a, b, z1, z2) z1
2094 + beta_incomplete(a + 1, b, z1)
2095 (%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2);
2096 (%o19) beta_incomplete_generalized(a, b, z1, z2) z2
2097 - beta_incomplete(a + 1, b, z2)
2098 @end example
2099 @end deffn
2101 @c -----------------------------------------------------------------------------
2102 @anchor{beta_expand}
2103 @defvr {Optionsvariable} beta_expand
2104 Standardwert: @code{false}
2106 @c When @code{beta_expand} is @code{true}, @code{beta(a,b)} and related
2107 @c functions are expanded for arguments like @math{a+n} or @math{a-n},
2108 @c where @math{n} is an integer.
2110 Hat die Optionsvariable @code{beta_expand} den Wert @code{true}, werden
2111 @code{beta(a,b)} und verwandte Funktionen f@"ur Argumente @math{a+n} oder
2112 @math{a-n} entwickelt, wobei @var{n} eine positive ganze Zahl ist.
2113 @end defvr
2115 @c -----------------------------------------------------------------------------
2116 @anchor{beta_args_sum_to_integer}
2117 @defvr {Optionsvariable} beta_args_sum_to_integer
2118 Standardwert: @code{false}
2120 @c When @code{beta_args_sum_to_integer} is @code{true}, Maxima simplifies
2121 @c @code{beta(a,b)}, when the arguments @var{a} and @var{b} sum to an integer.
2123 Hat die Optionsvariable @code{beta_args_sum_to_integer} den Wert @code{true},
2124 vereinfacht Maxima die Funktion @code{beta(a,b)}, wenn sich die Argumente
2125 @var{a} und @var{b} zu einer ganzen Zahlen summieren. Siehe auch @mrefdot{beta}
2126 @end defvr
2128 @c NEED INFO HERE ABOUT THE SUBSCRIPTED FORM psi[n](x)
2129 @c I (rtoy) don't think there is a plain psi(x) function anymore.
2130 @c @deffn {Function} psi (@var{x})
2131 @c @deffnx {Function} psi [@var{n}](@var{x})
2133 @c --- 11.07.2011 DK -----------------------------------------------------------
2134 @anchor{psi}
2135 @deffn {Funktion} psi [@var{n}](@var{x})
2137 @c The derivative of @code{log (gamma (@var{x}))} of order @code{@var{n}+1}.
2138 @c Thus, @code{psi[0](@var{x})} is the first derivative,
2139 @c @code{psi[1](@var{x})} is the second derivative, etc.
2141 Ist definiert als die Ableitung der Funktion @code{log(gamma(@var{x}))} der
2142 Ordnung @code{@var{n}+1}. @code{psi[0](@var{x})} ist die erste Ableitung,
2143 @code{psi[1](@var{x})} ist die zweite Ableitung, usw.
2145 @c Maxima does not know how, in general, to compute a numerical value of
2146 @c @code{psi}, but it can compute some exact values for rational args.
2147 @c Several variables control what range of rational args @code{psi} will
2148 @c return an exact value, if possible. See @code{maxpsiposint},
2149 @c @code{maxpsinegint}, @code{maxpsifracnum}, and @code{maxpsifracdenom}.
2150 @c That is, @var{x} must lie between @code{maxpsinegint} and
2151 @c @code{maxpsiposint}. If the absolute value of the fractional part of
2152 @c @var{x} is rational and has a numerator less than @code{maxpsifracnum}
2153 @c and has a denominator less than @code{maxpsifracdenom}, @code{psi}
2154 @c will return an exact value.
2156 Maxima kann numerische Werte f@"ur reelle Gleitkommazahlen berechnen. Weiterhin
2157 kann Maxima die Funktion @code{psi} f@"ur rationale Argumente zu exakten Werten
2158 vereinfachen. Die Optionsvariablen @mrefcomma{maxpsiposint}@w{}
2159 @mrefcomma{maxpsinegint} @mref{maxpsifracnum} und @code{maxpsifracdenom}@w{}
2160 kontrollieren, den Wertebereich der Argumente f@"ur den die Funktion @code{psi}
2161 vereinfacht.
2163 @c The function @code{bfpsi} in the @code{bffac} package can compute
2164 @c numerical values.
2166 Die Funktion @mref{bfpsi} des @code{bffac}-Package kann numerische Werte der
2167 Funktion @code{psi} berechnen.
2168 @end deffn
2170 @c --- 11.07.2011 DK -----------------------------------------------------------
2171 @anchor{maxpsiposint}
2172 @defvr {Optionsvariable} maxpsiposint
2173 Standardwert: @code{20}
2175 Die Optionsvariable @code{maxpsiposint} kontrolliert die Vereinfachung der
2176 Funktion @mref{psi} und enth@"alt eine obere positive Schranke. Ist das
2177 Argument @var{x} der Funktion @code{psi} gr@"o@ss{}er als @code{maxpsiposint},
2178 dann versucht Maxima nicht @code{psi[@var{n}](@var{x})} zu vereinfachen.
2180 Siehe auch @mrefcomma{maxpsifracdenom} @mref{maxpsifracnum} und
2181 @mrefdot{maxpsinegint}
2183 Beispiele:
2185 @example
2186 (%o1) 20
2187 (%i2) psi[0](20);
2188 275295799
2189 (%o2) --------- - %gamma
2190 77597520
2191 (%i3) maxpsiposint:10;
2192 (%o3) 10
2193 (%i4) psi[0](20);
2194 (%o4) psi (20)
2195 0
2196 (%i5) psi[0](10);
2197 7129
2198 (%o5) ---- - %gamma
2199 2520
2200 @end example
2201 @end defvr
2203 @c --- 11.07.2011 DK -----------------------------------------------------------
2204 @anchor{maxpsinegint}
2205 @defvr {Optionsvariable} maxpsinegint
2206 Standardwert: @code{-10}
2208 Die Optionsvariable @code{maxpsinegint} kontrolliert die Vereinfachung der
2209 Funktion @mref{psi} und enth@"alt eine untere negative Schranke. Ist das
2210 Argument @var{x} der Funktion @code{psi} kleiner als @code{maxpsinegint},
2211 dann versucht Maxima nicht @code{psi[@var{n}](@var{x})} zu vereinfachen.
2213 Siehe auch @mrefcomma{maxpsifracdenom} @mref{maxpsifracnum} und
2214 @mrefdot{maxpsiposint}
2216 Beispiele:
2218 @example
2219 (%i1) maxpsinegint:-10;
2220 (%o1) - 10
2221 (%i2) psi[0](-3/2);
2222 8
2223 (%o2) - 2 log(2) - %gamma + -
2224 3
2225 (%i3) maxpsinegint:-1;
2226 (%o3) - 1
2227 (%i4) psi[0](-3/2);
2228 3
2229 (%o4) psi (- -)
2230 0 2
2231 (%i5) psi[0](-1/2);
2232 (%o5) - 2 log(2) - %gamma + 2
2233 @end example
2234 @end defvr
2236 @c --- 11.07.2011 DK -----------------------------------------------------------
2237 @anchor{maxpsifracnum}
2238 @defvr {Optionsvariable} maxpsifracnum
2239 Standardwert: @code{6}
2241 Die Optionsvariable @code{maxpsifracnum} kontrolliert die Vereinfachung der
2242 Funktion @mrefdot{psi} Ist das Argument @var{x} der Funktion @code{psi} eine
2243 rationale Zahl kleiner als eins mit @code{p/q} und ist der Z@"ahler @code{p}
2244 gr@"o@ss{}er als @code{maxpsifracnum}, dann versucht Maxima nicht
2245 @code{psi[@var{n}](@var{x})} zu vereinfachen.
2247 Siehe auch @mrefcomma{maxpsifracdenom} @mref{maxpsiposint} und
2248 @mrefdot{maxpsinegint}
2250 Beispiele:
2252 @example
2253 (%i1) maxpsifracnum: 6;
2254 (%o1) 6
2255 (%i2) psi[0](5/6);
2256 3 log(3) sqrt(3) %pi
2257 (%o2) - -------- - 2 log(2) + ----------- - %gamma
2258 2 2
2259 (%i3) maxpsifracnum: 3;
2260 (%o3) 3
2261 (%i4) psi[0](5/6);
2262 5
2263 (%o4) psi (-)
2264 0 6
2265 @end example
2266 @end defvr
2268 @c --- 11.07.2011 DK -----------------------------------------------------------
2269 @anchor{maxpsifracdenom}
2270 @defvr {Optionsvariable} maxpsifracdenom
2271 Standardwert: @code{6}
2273 Die Optionsvariable @code{maxpsifracdenom} kontrolliert die Vereinfachung der
2274 Funktion @mrefdot{psi} Ist das Argument @var{x} der Funktion @code{psi} eine
2275 rationale Zahl kleiner als eins mit @code{p/q} und ist der Nenner @code{q}
2276 gr@"o@ss{}er als @code{maxpsifracdenom}, dann versucht Maxima nicht
2277 @code{psi[@var{n}](@var{x})} zu vereinfachen.
2279 Siehe auch @mrefcomma{maxpsifracnum} @mref{maxpsiposint} und
2280 @mrefdot{maxpsinegint}
2282 Beispiele:
2284 @example
2285 (%i1) maxpsifracdenom: 6;
2286 (%o1) 6
2287 (%i2) psi[0](1/6);
2288 3 log(3) sqrt(3) %pi
2289 (%o2) - -------- - 2 log(2) - ----------- - %gamma
2290 2 2
2291 (%i3) maxpsifracdenom: 4;
2292 (%o3) 4
2293 (%i4) psi[0](1/6);
2294 @group
2295 1
2296 (%o4) psi (-)
2297 0 6
2298 @end group
2299 (%i5) psi[0](1/5);
2300 1
2301 (%o5) psi (-)
2302 0 5
2303 (%i6) psi[0](1/4);
2304 %pi
2305 (%o6) - 3 log(2) - --- - %gamma
2306 2
2307 @end example
2308 @end defvr
2310 @c NEED CROSS REFS HERE
2311 @c NEED EXAMPLES HERE
2313 @c --- 10.07.2011 DK -----------------------------------------------------------
2314 @anchor{makefact}
2315 @deffn {Funktion} makefact (@var{expr})
2317 Ersetzt Binomial-, Gamma- und Beta-Funktionen, die im Ausdruck @var{expr}
2318 auftreten, durch Fakult@"aten.
2320 Siehe auch die Funktion @mrefdot{makegamma}
2321 @end deffn
2323 @c TODO: GEHOERT DIESE FUNKTION HIERHER?
2324 @c AREN'T THERE OTHER FUNCTIONS THAT DO ESSENTIALLY THE SAME THING ??
2326 @c --- 10.07.2011 DK -----------------------------------------------------------
2327 @anchor{numfactor}
2328 @deffn {Funktion} numfactor (@var{expr})
2330 Gibt einen numerischen Faktor des Produktes @var{expr} zur@"uck. Ist @var{expr}
2331 kein Produkt oder enth@"alt das Produkt keinen numerischen Faktor ist die
2332 R@"uckgabe @code{1}.
2334 Beispiel:
2336 @example
2337 (%i1) gamma (7/2);
2338 15 sqrt(%pi)
2339 (%o1) ------------
2340 8
2341 (%i2) numfactor (%);
2342 15
2343 (%o2) --
2344 8
2345 @end example
2346 @end deffn
2348 @c -----------------------------------------------------------------------------
2349 @node Exponentielle Integrale, Fehlerfunktionen, Gammafunktionen und verwandte Funktionen, Spezielle Funktionen
2350 @section Exponentielle Integrale
2351 @c -----------------------------------------------------------------------------
2353 Die Exponentiellen Integrale und verwandte Funktionen sind definiert in
2354 Abramowitz und Stegun, @i{Handbook of Mathematical Functions}, Kapitel 5.
2356 @c --- 10.07.2011 DK -----------------------------------------------------------
2357 @anchor{expintegral_e1}
2358 @deffn {Funktion} expintegral_e1 (@var{z})
2360 Das Exponentielle Integral @code{E1(z)} (A&S 5.1.1).
2361 @end deffn
2363 @c --- 10.07.2011 DK -----------------------------------------------------------
2364 @anchor{expintegral_ei}
2365 @deffn {Funktion} expintegral_ei (@var{z})
2367 Das Exponentielle Integral @code{Ei(z)} (A&S 5.1.2).
2368 @end deffn
2370 @c --- 10.07.2011 DK -----------------------------------------------------------
2371 @anchor{expintegral_li}
2372 @deffn {Funktion} expintegral_li (@var{n},@var{z})
2374 Das Exponentielle Integral @code{Li(z)} (A&S 5.1.3).
2375 @end deffn
2377 @c --- 10.07.2011 DK -----------------------------------------------------------
2378 @anchor{expintegral_e}
2379 @deffn {Funktion} expintegral_e (@var{n}, @var{z})
2381 Das Exponentielle Integral @code{E[n](z)} (A&S 5.1.4).
2382 @end deffn
2384 @c --- 10.07.2011 DK -----------------------------------------------------------
2385 @anchor{expintegral_si}
2386 @deffn {Funktion} expintegral_si (@var{z})
2388 Das Exponentielle Integral @code{Si(z)} (A&S 5.2.1).
2389 @end deffn
2391 @c --- 10.07.2011 DK -----------------------------------------------------------
2392 @anchor{expintegral_ci}
2393 @deffn {Funktion} expintegral_ci (@var{z})
2395 Das Exponentielle Integral @code{Ci(z)} (A&S 5.2.2).
2396 @end deffn
2398 @c --- 10.07.2011 DK -----------------------------------------------------------
2399 @anchor{expintegral_shi}
2400 @deffn {Funktion} expintegral_shi (@var{z})
2402 Das Exponentielle Integral @code{Shi(z)} (A&S 5.2.3).
2403 @end deffn
2405 @c --- 10.07.2011 DK -----------------------------------------------------------
2406 @anchor{expintegral_chi}
2407 @deffn {Funktion} expintegral_chi (@var{z})
2409 Das Exponentielle Integral @code{Chi(z)} (A&S 5.2.4).
2410 @end deffn
2412 @c --- 10.07.2011 DK -----------------------------------------------------------
2413 @anchor{expintrep}
2414 @defvr {Optionsvariable} expintrep
2415 Standardwert: @code{false}
2417 Wechselt die Darstellung eines Exponentiellen Integrals in eine der anderen
2418 Funktionen @mrefcomma{gamma_incomplete} @mrefcomma{expintegral_e1}@w{}
2419 @mrefcomma{expintegral_ei} @mrefcomma{expintegral_li}@w{}
2420 @mrefcomma{expintegral_si} @mrefcomma{expintegral_ci}@w{}
2421 @mrefcomma{expintegral_shi} oder @mrefdot{expintegral_chi}
2422 @end defvr
2424 @c --- 10.07.2011 DK -----------------------------------------------------------
2425 @anchor{expintexpand}
2426 @defvr {Optionsvariable} expintexpand
2427 Standardwert: @code{false}
2429 Expandiert das Exponentielle Integral @code{E[n](z)} f@"ur halbzahlige, gerade
2430 Ordnung @var{n} nach den Funktionen @mref{erfc} und @mrefdot{erf} sowie f@"ur
2431 positive ganze Zahlen nach der Funktion @mrefdot{expintegral_ei}
2432 @end defvr
2434 @c -----------------------------------------------------------------------------
2435 @node Fehlerfunktionen, Elliptische Funktionen und Integrale, Exponentielle Integrale, Spezielle Funktionen
2436 @section Fehlerfunktionen
2437 @c -----------------------------------------------------------------------------
2439 Die Fehlerfunktion und verwandte Funktionen sind definiert in Abramowitz
2440 und Stegun, @i{Handbook of Mathematical Functions}, Kapitel 7.
2442 @c --- 10.07.2011 DK -----------------------------------------------------------
2443 @anchor{erf}
2444 @deffn {Funktion} erf (@var{z})
2446 Die Fehlerfunktion @code{erf(z)} (A&S 7.1.1).
2448 Siehe auch die Optionsvariable @mrefdot{erfflag}
2449 @end deffn
2451 @c --- 10.07.2011 DK -----------------------------------------------------------
2452 @anchor{erfc}
2453 @deffn {Function} erfc (@var{z})
2455 Die komplement@"are Fehlerfunktion @code{erfc(z) = 1 - erf(z)} (A & S 7.1.2).
2456 @end deffn
2458 @c --- 10.07.2011 DK -----------------------------------------------------------
2459 @anchor{erfi}
2460 @deffn {Funktion} erfi (@var{z})
2462 Die imagin@"are Fehlerfunktion @code{erfi(z) = -%i*erf(%i*z)}.
2463 @end deffn
2465 @c --- 10.07.2011 DK -----------------------------------------------------------
2466 @anchor{erf_generalized}
2467 @deffn {Funktion} erf_generalized (@var{z1}, @var{z2})
2469 Die verallgemeinerte Fehlerfunktion @math{Erf(z1, z2)}.
2470 @end deffn
2472 @c --- 10.07.2011 DK -----------------------------------------------------------
2473 @anchor{fresnel_c}
2474 @deffn {Funktion} fresnel_c (@var{z})
2476 Das Fresnel-Integral, das definiert ist als (A & S 7.3.1):
2478 @example
2479 z
2480 / 2
2481 [ %pi t
2482 C(z) = I cos(------) dt
2483 ] 2
2484 /
2485 0
2486 @end example
2488 Hat die Optionsvariable @mref{trigsign} den Wert @code{true}, vereinfacht
2489 Maxima @code{fresnel_c(-x)} zu @code{-fresnel_c(x)}.
2491 Hat die Optionsvariable @mref{%iargs} den Wert @code{true}, vereinfacht
2492 Maxima @code{fresnel_c(%i*x)} zu @code{%i*fresnel_c(x)}.
2494 Siehe auch die Optionsvariable @mrefcomma {hypergeometric_representation} um
2495 die Fresnelfunktion in eine hypergeometrische Darstellung zu transformieren,
2496 und die Optionsvariable @mref{erf_representation} f@"ur eine Darstellung als
2497 Fehlerfunktion.
2498 @end deffn
2500 @c -----------------------------------------------------------------------------
2501 @anchor{fresnel_s}
2502 @deffn {Funktion} fresnel_s (@var{z})
2504 Das Fresnel-Integral, das definiert ist als (A & S 7.3.2):
2506 @example
2507 z
2508 / 2
2509 [ %pi t
2510 S(z) = I sin(------) dt
2511 ] 2
2512 /
2513 0
2514 @end example
2516 Hat die Optionsvariable @mref{trigsign} den Wert @code{true}, vereinfacht
2517 Maxima @code{fresnel_s(-x)} zu @code{-fresnel_s(x)}.
2519 Hat die Optionsvariable @mref{%iargs} den Wert @code{true}, vereinfacht
2520 Maxima @code{fresnel_s(%i*x)} zu @code{%i*fresnel_s(x)}.
2522 Siehe auch die Optionsvariable @mrefcomma {hypergeometric_representation} um
2523 die Fresnelfunktion in eine hypergeometrische Darstellung zu transformieren,
2524 und die Optionsvariable @mref{erf_representation} f@"ur eine Darstellung als
2525 Fehlerfunktion.
2526 @end deffn
2528 @c --- 10.07.2011 DK -----------------------------------------------------------
2529 @anchor{erf_representation}
2530 @defvr {Optionsvariable} erf_representation
2531 Standarwert: @code{false}
2533 Hat die Optionsvariable @code{erf_representation} den Wert @code{true}, werden
2534 die Funktionen @mrefcomma{erfc} @mrefcomma{erfi}@w{}
2535 @mrefcomma{erf_generalized} @mref{fresnel_s} und @mref{fresnel_c} in eine
2536 Darstellung mit der Funktion @mref{erf} transformiert.
2537 @end defvr
2539 @c --- 10.07.2011 DK -----------------------------------------------------------
2540 @anchor{hypergeometric_representation}
2541 @defvr {Optionsvariable} hypergeometric_representation
2542 Standardwert: @code{false}
2544 Hat die Optionsvariable @code{hypergeometric_representation} den Wert
2545 @code{true}, werden die Funktionen @mref{fresnel_s} und @mref{fresnel_c} in
2546 eine hypergeometrische Funktion transformiert.
2547 @end defvr
2549 @c -----------------------------------------------------------------------------
2550 @node Elliptische Funktionen und Integrale, Hypergeometrische Funktionen, Fehlerfunktionen, Spezielle Funktionen
2551 @section Elliptische Funktionen und Integrale
2552 @c -----------------------------------------------------------------------------
2554 @menu
2555 * Einf@"uhrung in Elliptische Funktionen und Integrale::
2556 * Funktionen und Variablen f@"ur Elliptische Funktionen::
2557 * Funktionen und Variablen f@"ur Elliptische Integrale::
2558 @end menu
2560 @c -----------------------------------------------------------------------------
2561 @node Einf@"uhrung in Elliptische Funktionen und Integrale, Funktionen und Variablen f@"ur Elliptische Funktionen, Elliptische Funktionen und Integrale, Elliptische Funktionen und Integrale
2562 @subsection Einf@"uhrung in Elliptische Funktionen und Integrale
2563 @c -----------------------------------------------------------------------------
2565 @c Maxima includes support for Jacobian elliptic functions and for
2566 @c complete and incomplete elliptic integrals. This includes symbolic
2567 @c manipulation of these functions and numerical evaluation as well.
2568 @c Definitions of these functions and many of their properties can by
2569 @c found in Abramowitz and Stegun, Chapter 16--17. As much as possible,
2570 @c we use the definitions and relationships given there.
2572 Maxima unterst@"utzt die Jacobischen elliptische Funktionen sowie die
2573 vollst@"andigen und unvollst@"andigen elliptischen Integrale. Die Funktionen
2574 sind f@"ur das symbolische und numerische Rechnen geeignet. Die Definition der
2575 Funktionen und viele ihrer Eigenschaften sind in Abramowitz and Stegun,
2576 Kapitel 16 und 17 enthalten. Die dort beschriebenen Definitionen und
2577 Beziehungen werden so weit als m@"oglich verwendet.
2579 @c In particular, all elliptic functions and integrals use the parameter
2580 @c @math{m} instead of the modulus @math{k} or the modular angle
2581 @c @math{\alpha}. This is one area where we differ from Abramowitz and
2582 @c Stegun who use the modular angle for the elliptic functions. The
2583 @c following relationships are true:
2585 Im besonderen nutzen alle elliptischen Funktionen und Integrale den Parameter
2586 @math{m} anstatt den Modulus @math{k} oder den modularen Winkel @math{\alpha}.
2587 Dies ist ein Unterschied zu der Definition von Abramowitz und Stegun. Es
2588 gelten die folgenden Beziehungen:
2589 @ifinfo
2590 @math{m = k^2} und @math{k = \sin(\alpha)}
2591 @end ifinfo
2592 @tex
2593 $$m = k^2$$ und $$k = \sin\alpha $$
2594 @end tex
2596 @c The elliptic functions and integrals are primarily intended to support
2597 @c symbolic computation. Therefore, most of derivatives of the functions
2598 @c and integrals are known. However, if floating-point values are given,
2599 @c a floating-point result is returned.
2601 Die elliptischen Funktionen und Integrale sind zuallererst f@"ur das symbolische
2602 Rechnen gedacht. Daher sind die Ableitungen und Integrale der Funktionen im
2603 wesentlichen in Maxima bekannt. Maxima unterst@"utzt jedoch auch die
2604 numerische Berechnung, wenn die Argumente Gleitkommazahlen sind.
2606 @c Support for most of the other properties of elliptic functions and
2607 @c integrals other than derivatives has not yet been written.
2609 Viele bekannte Eigenschaften der Elliptischen Funktionen und Integrale sind
2610 noch nicht in Maxima implementiert.
2612 @c Some examples of elliptic functions:
2614 Einige Beispiele f@"ur elliptische Funktionen.
2616 @example
2617 (%i1) jacobi_sn (u, m);
2618 (%o1) jacobi_sn(u, m)
2619 (%i2) jacobi_sn (u, 1);
2620 (%o2) tanh(u)
2621 (%i3) jacobi_sn (u, 0);
2622 (%o3) sin(u)
2623 (%i4) diff (jacobi_sn (u, m), u);
2624 (%o4) jacobi_cn(u, m) jacobi_dn(u, m)
2625 (%i5) diff (jacobi_sn (u, m), m);
2626 (%o5) jacobi_cn(u, m) jacobi_dn(u, m)
2628 elliptic_e(asin(jacobi_sn(u, m)), m)
2629 (u - ------------------------------------)/(2 m)
2630 1 - m
2632 2
2633 jacobi_cn (u, m) jacobi_sn(u, m)
2634 + --------------------------------
2635 2 (1 - m)
2636 @end example
2638 @c Some examples of elliptic integrals:
2640 Einige Beispiele f@"ur elliptische Integrale.
2642 @example
2643 (%i1) elliptic_f (phi, m);
2644 (%o1) elliptic_f(phi, m)
2645 (%i2) elliptic_f (phi, 0);
2646 (%o2) phi
2647 (%i3) elliptic_f (phi, 1);
2648 phi %pi
2649 (%o3) log(tan(--- + ---))
2650 2 4
2651 (%i4) elliptic_e (phi, 1);
2652 (%o4) sin(phi)
2653 (%i5) elliptic_e (phi, 0);
2654 (%o5) phi
2655 (%i6) elliptic_kc (1/2);
2656 1
2657 (%o6) elliptic_kc(-)
2658 2
2659 (%i7) makegamma (%);
2660 @group
2661 2 1
2662 gamma (-)
2663 4
2664 (%o7) -----------
2665 4 sqrt(%pi)
2666 @end group
2667 (%i8) diff (elliptic_f (phi, m), phi);
2668 1
2669 (%o8) ---------------------
2670 2
2671 sqrt(1 - m sin (phi))
2672 (%i9) diff (elliptic_f (phi, m), m);
2673 elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m)
2674 (%o9) (-----------------------------------------------
2675 m
2677 cos(phi) sin(phi)
2678 - ---------------------)/(2 (1 - m))
2679 2
2680 sqrt(1 - m sin (phi))
2681 @end example
2683 @c Support for elliptic functions and integrals was written by Raymond
2684 @c Toy. It is placed under the terms of the General Public License (GPL)
2685 @c that governs the distribution of Maxima.
2687 Die Implementierung der elliptischen Funktionen und Integrale wurde von
2688 Raymond Toy geschrieben. Der Code steht wie Maxima unter der General Public
2689 License (GPL).
2691 @c -----------------------------------------------------------------------------
2692 @node Funktionen und Variablen f@"ur Elliptische Funktionen, Funktionen und Variablen f@"ur Elliptische Integrale, Einf@"uhrung in Elliptische Funktionen und Integrale, Elliptische Funktionen und Integrale
2693 @subsection Funktionen und Variablen f@"ur Elliptische Funktionen
2694 @c -----------------------------------------------------------------------------
2696 @c --- 10.07.2011 DK -----------------------------------------------------------
2697 @deffn {Funktion} jacobi_sn (@var{u}, @var{m})
2699 Die Jacobische elliptische Funktion @math{sn(u,m)}.
2700 @end deffn
2702 @c --- 10.07.2011 DK -----------------------------------------------------------
2703 @deffn {Funktion} jacobi_cn (@var{u}, @var{m})
2705 Die Jacobische elliptische Funktion @math{cn(u,m)}.
2706 @end deffn
2708 @c --- 10.07.2011 DK -----------------------------------------------------------
2709 @deffn {Funktion} jacobi_dn (@var{u}, @var{m})
2711 Die Jacobische elliptische Funktion @math{dn(u,m)}.
2712 @end deffn
2714 @c --- 10.07.2011 DK -----------------------------------------------------------
2715 @deffn {Funktion} jacobi_ns (@var{u}, @var{m})
2717 Die Jacobische elliptische Funktion @math{ns(u,m) = 1/sn(u,m)}.
2718 @end deffn
2720 @c --- 10.07.2011 DK -----------------------------------------------------------
2721 @deffn {Funktion} jacobi_sc (@var{u}, @var{m})
2723 Die Jacobische elliptische Funktion @math{sc(u,m) = sn(u,m)/cn(u,m)}.
2724 @end deffn
2726 @c --- 10.07.2011 DK -----------------------------------------------------------
2727 @deffn {Funktion} jacobi_sd (@var{u}, @var{m})
2729 Die Jacobische elliptische Funktion @math{sd(u,m) = sn(u,m)/dn(u,m)}.
2730 @end deffn
2732 @c --- 10.07.2011 DK -----------------------------------------------------------
2733 @deffn {Funktion} jacobi_nc (@var{u}, @var{m})
2735 Die Jacobische elliptische Funktion @math{nc(u,m) = 1/cn(u,m)}.
2736 @end deffn
2738 @c --- 10.07.2011 DK -----------------------------------------------------------
2739 @deffn {Funktion} jacobi_cs (@var{u}, @var{m})
2741 Die Jacobische elliptische Funktion @math{cs(u,m) = cn(u,m)/sn(u,m)}.
2742 @end deffn
2744 @c --- 10.07.2011 DK -----------------------------------------------------------
2745 @deffn {Funktion} jacobi_cd (@var{u}, @var{m})
2747 Die Jacobische elliptische Funktion @math{cd(u,m) = cn(u,m)/dn(u,m)}.
2748 @end deffn
2750 @c --- 10.07.2011 DK -----------------------------------------------------------
2751 @deffn {Funktion} jacobi_nd (@var{u}, @var{m})
2753 Die Jacobische elliptische Funktion @math{nc(u,m) = 1/cn(u,m)}.
2754 @end deffn
2756 @c --- 10.07.2011 DK -----------------------------------------------------------
2757 @deffn {Funktion} jacobi_ds (@var{u}, @var{m})
2759 Die Jacobische elliptische Funktion @math{ds(u,m) = dn(u,m)/sn(u,m)}.
2760 @end deffn
2762 @c --- 10.07.2011 DK -----------------------------------------------------------
2763 @deffn {Funktion} jacobi_dc (@var{u}, @var{m})
2765 Die Jacobische elliptische Funktion @math{dc(u,m) = dn(u,m)/cn(u,m)}.
2766 @end deffn
2768 @c --- 10.07.2011 DK -----------------------------------------------------------
2769 @deffn {Funktion} inverse_jacobi_sn (@var{u}, @var{m})
2771 Die inverse Jacobische elliptische Funktion @math{sn(u,m)}.
2772 @end deffn
2774 @c --- 10.07.2011 DK -----------------------------------------------------------
2775 @deffn {Funktion} inverse_jacobi_cn (@var{u}, @var{m})
2777 Die inverse Jacobische elliptische Funktion @math{cn(u,m)}.
2778 @end deffn
2780 @c --- 10.07.2011 DK -----------------------------------------------------------
2781 @deffn {Funktion} inverse_jacobi_dn (@var{u}, @var{m})
2783 Die inverse Jacobische elliptische Funktion @math{dn(u,m)}.
2784 @end deffn
2786 @c --- 10.07.2011 DK -----------------------------------------------------------
2787 @deffn {Funktion} inverse_jacobi_ns (@var{u}, @var{m})
2789 Die inverse Jacobische elliptische Funktion @math{ns(u,m)}.
2790 @end deffn
2792 @c --- 10.07.2011 DK -----------------------------------------------------------
2793 @deffn {Funktion} inverse_jacobi_sc (@var{u}, @var{m})
2795 Die inverse Jacobische elliptische Funktion @math{sc(u,m)}.
2796 @end deffn
2798 @c --- 10.07.2011 DK -----------------------------------------------------------
2799 @deffn {Funktion} inverse_jacobi_sd (@var{u}, @var{m})
2801 Die inverse Jacobische elliptische Funktion @math{sd(u,m)}.
2802 @end deffn
2804 @c --- 10.07.2011 DK -----------------------------------------------------------
2805 @deffn {Funktion} inverse_jacobi_nc (@var{u}, @var{m})
2807 Die inverse Jacobische elliptische Funktion @math{nc(u,m)}.
2808 @end deffn
2810 @c --- 10.07.2011 DK -----------------------------------------------------------
2811 @deffn {Funktion} inverse_jacobi_cs (@var{u}, @var{m})
2813 Die inverse Jacobische elliptische Funktion @math{cs(u,m)}.
2814 @end deffn
2816 @c --- 10.07.2011 DK -----------------------------------------------------------
2817 @deffn {Funktion} inverse_jacobi_cd (@var{u}, @var{m})
2819 Die inverse Jacobische elliptische Funktion @math{cd(u,m)}.
2820 @end deffn
2822 @c --- 10.07.2011 DK -----------------------------------------------------------
2823 @deffn {Funktion} inverse_jacobi_nd (@var{u}, @var{m})
2825 Die inverse Jacobische elliptische Funktion @math{nc(u,m)}.
2826 @end deffn
2828 @c --- 10.07.2011 DK -----------------------------------------------------------
2829 @deffn {Funktion} inverse_jacobi_ds (@var{u}, @var{m})
2831 Die inverse Jacobische elliptische Funktion @math{ds(u,m)}.
2832 @end deffn
2834 @c --- 10.07.2011 DK -----------------------------------------------------------
2835 @deffn {Funktion} inverse_jacobi_dc (@var{u}, @var{m})
2837 Die inverse Jacobische elliptische Funktion @math{dc(u,m)}.
2838 @end deffn
2840 @c -----------------------------------------------------------------------------
2841 @node Funktionen und Variablen f@"ur Elliptische Integrale, , Funktionen und Variablen f@"ur Elliptische Funktionen, Elliptische Funktionen und Integrale
2842 @subsection Funktionen und Variablen f@"ur Elliptische Integrale
2843 @c -----------------------------------------------------------------------------
2845 @c --- 10.07.2011 DK -----------------------------------------------------------
2846 @anchor{elliptic_f}
2847 @deffn {Funktion} elliptic_f (@var{phi}, @var{m})
2849 Das unvollst@"andige elliptische Integral der ersten Art, das definiert ist als
2851 @ifhtml
2852 @math{integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)}
2853 @end ifhtml
2854 @ifinfo
2855 @math{integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)}
2856 @end ifinfo
2858 @tex
2859 $$\int_0^\phi {{d\theta}\over{\sqrt{1 - m\sin^2\theta}}}$$
2860 @end tex
2862 Siehe auch @mref{elliptic_e} und @mrefdot{elliptic_kc}
2863 @end deffn
2865 @c --- 10.07.2011 DK -----------------------------------------------------------
2866 @anchor{elliptic_e}
2867 @deffn {Funktion} elliptic_e (@var{phi}, @var{m})
2869 Das unvollst@"andige elliptische Integral der zweiten Art, das definiert ist als
2871 @ifhtml
2872 @math{elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi)}
2873 @end ifhtml
2874 @ifinfo
2875 @math{elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi)}
2876 @end ifinfo
2877 @tex
2878 $$\int_0^\phi \sqrt{1 - m\sin^2\theta} d\theta$$
2879 @end tex
2881 Siehe auch @mref{elliptic_e} und @mrefdot{elliptic_ec}
2882 @end deffn
2884 @c --- 10.07.2011 DK -----------------------------------------------------------
2885 @anchor{elliptic_eu}
2886 @deffn {Funktion} elliptic_eu (@var{u}, @var{m})
2888 Das unvollst@"andige elliptische Integral der zweiten Art, das definiert ist als
2890 @ifhtml
2891 @math{integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t, 0, tau)}
2893 mit @math{tau = sn(u,m)}.
2894 @end ifhtml
2895 @ifinfo
2896 @math{integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t, 0, tau)}
2898 mit @math{tau = sn(u,m)}.
2899 @end ifinfo
2900 @tex
2901 $$\int_0^u {\rm dn}(v, m) dv = \int_0^\tau \sqrt{{1-m t^2}\over{1-t^2}} dt$$
2903 mit $\tau = {\rm sn}(u, m)$.
2904 @end tex
2906 Dieses Integral steht in Beziehung zum elliptischen Integral @code{elliptiec_e}
2908 @ifhtml
2909 @math{elliptic_eu(u, m) = elliptic_e(asin(sn(u,m)),m)}
2910 @end ifhtml
2911 @ifinfo
2912 @math{elliptic_eu(u, m) = elliptic_e(asin(sn(u,m)),m)}
2913 @end ifinfo
2914 @tex
2915 $$E(u,m) = E(\phi, m)$$
2917 mit $\phi = \sin^{-1} {\rm sn}(u, m)$.
2918 @end tex
2920 Siehe auch @mrefdot{elliptic_e}
2921 @end deffn
2923 @c --- 10.07.2011 DK -----------------------------------------------------------
2924 @anchor{elliptic_pi}
2925 @deffn {Funktion} elliptic_pi (@var{n}, @var{phi}, @var{m})
2927 Das unvollst@"andige elliptische Integral der dritten Art, das definiert ist als
2929 @ifhtml
2930 @math{integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)}
2931 @end ifhtml
2932 @ifinfo
2933 @math{integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)}
2934 @end ifinfo
2935 @tex
2936 $$\int_0^\phi {{d\theta}\over{(1-n\sin^2 \theta)\sqrt{1 - m\sin^2\theta}}}$$
2937 @end tex
2939 Maxima kennt nur die Ableitung nach der Variablen @var{phi}.
2940 @end deffn
2942 @c --- 10.07.2011 DK -----------------------------------------------------------
2943 @anchor{elliptic_kc}
2944 @deffn {Funktion} elliptic_kc (@var{m})
2946 Das vollst@"andige elliptische Integral der ersten Art, das definiert ist als
2948 @ifhtml
2949 @math{integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)}
2950 @end ifhtml
2951 @ifinfo
2952 @math{integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)}
2953 @end ifinfo
2955 @tex
2956 $$\int_0^{{\pi}\over{2}} {{d\theta}\over{\sqrt{1 - m\sin^2\theta}}}$$
2957 @end tex
2959 F@"ur einige spezielle Argumente @var{m} kennt Maxima Werte mit der
2960 Gammafunktion @mrefdot{gamma} Die Werte k@"onnen mit der Funktion
2961 @mref{makegamma} berechnet werden.
2962 @end deffn
2964 @c --- 10.07.2011 DK -----------------------------------------------------------
2965 @anchor{elliptic_ec}
2966 @deffn {Funktion} elliptic_ec (@var{m})
2968 Das vollst@"andige elliptische Integral der zweiten Art, das definiert ist als
2970 @ifhtml
2971 @math{integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)}
2972 @end ifhtml
2973 @ifinfo
2974 @math{integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)}
2975 @end ifinfo
2977 @tex
2978 $$\int_0^{{\pi}\over{2}} \sqrt{1 - m\sin^2\theta} d\theta$$
2979 @end tex
2981 F@"ur einige spezielle Argumente @var{m} kennt Maxima Werte mit der
2982 Gammafunktion @mrefdot{gamma} Die Werte k@"onnen mit der Funktion
2983 @mref{makegamma} berechnet werden.
2984 @end deffn
2986 @c -----------------------------------------------------------------------------
2987 @node Hypergeometrische Funktionen, Weitere spezielle Funktionen, Elliptische Funktionen und Integrale, Spezielle Funktionen
2988 @section Hypergeometrische Funktionen
2989 @c -----------------------------------------------------------------------------
2991 @c The Hypergeometric Functions are defined in Abramowitz and Stegun,
2992 @c @i{Handbook of Mathematical Functions}, Chapters 13 and 15.
2994 @c Maxima has very limited knowledge of these functions. They
2995 @c can be returned from function @code{hgfred}.
2997 @c --- 10.07.2011 DK -----------------------------------------------------------
2998 @anchor{%m}
2999 @deffn {Funktion} %m [@var{k}, @var{u}] (@var{z})
3001 Ist die Whittaker M Funktion
3002 @code{M[k,u](z) = exp(-z/2) * z^(1/2+u) * M(1/2+u-k, 1+2*u, z)}.
3003 Siehe A & S 13.1.32 f@"ur die Definition.
3004 @end deffn
3006 @c --- 10.07.2011 DK -----------------------------------------------------------
3007 @anchor{%w}
3008 @deffn {Funktion} %w [@var{k}, @var{u}] (@var{z})
3010 Ist die Whittaker W Funktion. Siehe A & S 13.1.33 f@"ur die Definition.
3011 @end deffn
3013 @c --- 10.07.2011 DK -----------------------------------------------------------
3014 @anchor{%f}
3015 @deffn {Funktion} %f [@var{p},@var{q}] (@var{[a], [b], z})
3017 @c The pFq(a1,a2,..ap;b1,b2,..bq;z) hypergeometric function,
3018 @c where @code{a} a list of length @code{p} and
3019 @c @code{b} a list of length @code{q}.
3021 Ist die hypergeometrische Funktion
3022 @code{F[p,q](a_1, ..., a_p; b_1,..., b_q; z)}. Das Argument @var{a} ist eine
3023 Liste mit den @var{p}-Elementen @var{a_i} und das Argument @var{b} die Liste
3024 mit den @var{q}-Elementen @var{b_i}.
3025 @end deffn
3027 @c --- 10.07.2011 DK -----------------------------------------------------------
3028 @anchor{hypergeometric}
3029 @deffn {Funktion} hypergeometric ([@var{a_1}, @dots{}, @var{a_p}], [@var{b_1}, @dots{} ,@var{b_q}], z)
3031 @c The hypergeometric function. Unlike Maxima's @code{%f} hypergeometric
3032 @c function, the function @code{hypergeometric} is a simplifying
3033 @c function; also, @code{hypergeometric} supports complex double and
3034 @c big floating point evaluation. For the Gauss hypergeometric function,
3035 @c that is @math{p = 2} and @math{q = 1}, floating point evaluation
3036 @c outside the unit circle is supported, but in general, it is not
3037 @c supported.
3039 Ist die hypergeometrische Funktion. Im Unterschied zu den Funktionen
3040 @mref{%f} und @mrefcomma{hgfred} ist die Funktion @code{hypergeometric} eine
3041 vereinfachende Funktion. @code{hypergeometric} unterst@"utzt die Berechnung
3042 von numerischen Werten f@"ur reelle und komplexe Gleitkommazahlen in doppelter
3043 und mit beliebiger Genauigkeit. F@"ur die Gau@ss{}sche hypergeometrische
3044 Funktion ist @math{p = 2} und @math{q = 1}. In diesem Fall wird auch die
3045 numerische Berechnung au@ss{}erhalb des Einheitskreises unterst@"utzt.
3047 @c When the option variable @code{expand_hypergeometric} is true (default
3048 @c is false) and one of the arguments @code{a1} through @code{ap} is a
3049 @c negative integer (a polynomial case), @code{hypergeometric} returns an
3050 @c expanded polynomial.
3052 Hat die Optionsvariable @code{expand_hypergeometric} den Wert @code{true}, das
3053 ist der Standardwert, und eines der Argumente @code{a_1}, @dots{}, @code{a_p}
3054 ist eine negative ganze Zahl, gibt @code{hypergeometric} ein Polynom zur@"uck.
3056 Beispiel:
3058 @example
3059 (%i1) hypergeometric([],[],x);
3060 (%o1) %e^x
3061 @end example
3063 @c Polynomial cases automatically expand when @code{expand_hypergeometric} is
3064 @c true:
3066 Expansion in ein Polynom f@"ur eine negative ganze Zahl, wenn die
3067 Optionsvariable @code{expand_hypergeometric} den Wert @code{true} hat.
3069 @example
3070 (%i2) hypergeometric([-3],[7],x);
3071 (%o2) hypergeometric([-3],[7],x)
3073 (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true;
3074 (%o3) -x^3/504+3*x^2/56-3*x/7+1
3075 @end example
3077 @c Both double float and big float evaluation is supported:
3079 Numerische Berechnung in doppelter und beliebiger Gleitkommagenauigkeit.
3081 @example
3082 (%i4) hypergeometric([5.1],[7.1 + %i],0.42);
3083 (%o4) 1.346250786375334 - 0.0559061414208204 %i
3084 (%i5) hypergeometric([5,6],[8], 5.7 - %i);
3085 (%o5) .007375824009774946 - .001049813688578674 %i
3086 (%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30;
3087 (%o6) 7.37582400977494674506442010824b-3
3088 - 1.04981368857867315858055393376b-3 %i
3089 @end example
3090 @end deffn
3092 @c --- 10.07.2011 DK -----------------------------------------------------------
3093 @anchor{parabolic_cylinder_d}
3094 @deffn {Funktion} parabolic_cylinder_d (@var{v}, @var{z})
3096 @c The parabolic cylinder function @code{parabolic_cylinder_d(v,z)}.
3097 @c (A&s 19.3.1)
3099 Die parabolische Zylinderfunktion @code{parabolic_cylinder_d(v,z)}.
3101 @c The Parabolic Cylinder Functions are defined in Abramowitz and Stegun,
3102 @c @i{Handbook of Mathematical Functions}, Chapter 19.
3104 Die parabolischen Zylinderfunktionen sind in Abramowitz and Stegun,
3105 @i{Handbook of Mathematical Functions}, Kapitel 19 definiert.
3107 @c Maxima has very limited knowledge of these functions. They
3108 @c can be returned from function @code{hgfred}.
3110 Die parabolischen Zylinderfunktionen k@"onnen als Ergebnis der Funktion
3111 @mref{hgfred} auftreten. Maxima kennt keine weiteren Eigenschaften.
3112 @end deffn
3114 @c -----------------------------------------------------------------------------
3115 @node Weitere spezielle Funktionen, , Hypergeometrische Funktionen, Spezielle Funktionen
3116 @section Weitere spezielle Funktionen
3117 @c -----------------------------------------------------------------------------
3119 @c --- 10.07.2011 DK -----------------------------------------------------------
3120 @anchor{li}
3121 @deffn {Funktion} li [@var{s}] (@var{z})
3123 @c Represents the polylogarithm function of order @var{s} and argument @var{z},
3124 @c defined by the infinite series
3126 Ist der Polylogarithmus der Ordnung @var{s} mit dem Argument @var{z}. Der
3127 Polylogarithmus wird durch die folgende Reihe definiert werden:
3129 @tex
3130 $${\rm Li}_s \left(z\right) = \sum_{k=1}^\infty {z^k \over k^s}$$
3131 @end tex
3132 @ifnottex
3133 @example
3134 inf
3135 ==== k
3136 \ z
3137 Li (z) = > --
3138 s / s
3139 ==== k
3140 k = 1
3141 @end example
3142 @end ifnottex
3144 @c @code{li [1]} is @code{- log (1 - z)}. @code{li [2]} and @code{li [3]} are
3145 @c the dilogarithm and trilogarithm functions, respectively.
3147 F@"ur @var{s=1} geht der Polylogarithmus in die gew@"ohnliche
3148 Logarithmusfunktion @"uber und man erh@"alt @code{-log(1-z)}. F@"ur @var{s=2}
3149 oder @var{s=3} spricht man vom Dilogarithmus oder Trilogarithmus.
3151 @c When the order is 1, the polylogarithm simplifies to @code{- log (1 - z)},
3152 @c which in turn simplifies to a numerical value if @var{z} is a real or complex
3153 @c floating point number or the @code{numer} evaluation flag is present.
3155 Maxima vereinfacht f@"ur @var{s=1} sofort zum gew@"ohnlichen Logarithmus.
3156 F@"ur negative ganze Zahlen @var{s} einschlie@ss{}lich der Null vereinfacht
3157 Maxima den Polylogarithmus zu einer rationalen Funktion.
3159 @c When the order is 2 or 3, the polylogarithm simplifies to a numerical value
3160 @c if @var{z} is a real floating point number or the @code{numer} evaluation
3161 @c flag is present.
3163 Ist @var{s=2} oder @var{s=3} und das Argument @var{z} eine Gleitkommazahl,
3164 vereinfacht Maxima den Di- oder Trilogarithmus zu einer Gleitkommazahl.
3166 Beispiele:
3168 @example
3169 (%i1) assume (x > 0);
3170 (%o1) [x > 0]
3171 (%i2) integrate ((log (1 - t)) / t, t, 0, x);
3172 (%o2) - li (x)
3173 2
3174 (%i3) li [2] (7);
3175 (%o3) li (7)
3176 2
3177 (%i4) li [2] (7), numer;
3178 (%o4) 1.24827317833392 - 6.113257021832577 %i
3179 (%i5) li [3] (7);
3180 (%o5) li (7)
3181 3
3182 (%i6) li [2] (7), numer;
3183 (%o6) 1.24827317833392 - 6.113257021832577 %i
3184 (%i7) L : makelist (i / 4.0, i, 0, 8);
3185 (%o7) [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
3186 (%i8) map (lambda ([x], li [2] (x)), L);
3187 (%o8) [0, .2676526384986274, .5822405249432515,
3188 .9784693966661848, 1.64493407, 2.190177004178597
3189 - .7010261407036192 %i, 2.374395264042415
3190 - 1.273806203464065 %i, 2.448686757245154
3191 - 1.758084846201883 %i, 2.467401098097648
3192 - 2.177586087815347 %i]
3193 (%i9) map (lambda ([x], li [3] (x)), L);
3194 (%o9) [0, .2584613953442624, 0.537213192678042,
3195 .8444258046482203, 1.2020569, 1.642866878950322
3196 - .07821473130035025 %i, 2.060877505514697
3197 - .2582419849982037 %i, 2.433418896388322
3198 - .4919260182322965 %i, 2.762071904015935
3199 - .7546938285978846 %i]
3200 @end example
3201 @end deffn
3203 @c --- 10.07.2011 DK -----------------------------------------------------------
3204 @anchor{specint}
3205 @deffn {Funktion} specint (exp(- s*@var{t}) * @var{expr}, @var{t})
3207 @c Compute the Laplace transform of @var{expr} with respect to the variable
3208 @c @var{t}. The integrand @var{expr} may contain special functions.
3210 Berechnet die Laplace-Transformation des Ausdrucks @var{expr} f@"ur die
3211 Integrationsvariable @var{t}. @var{s} ist der Parameter der
3212 Laplace-Transformation. Der Integrand @var{expr} kann spezielle
3213 Funktionen der Mathematik enthalten.
3215 @c The following special functions are handled by @code{specint}: incomplete
3216 @c gamma function, error functions (but not the error function @code{erfi}, it
3217 @c is easy to transform @code{erfi} e.g. to the error function @code{erf}),
3218 @c exponential integrals, bessel functions (including products of bessel
3219 @c functions), hankel functions, hermite and the laguerre polynomials.
3220 @c Furthermore, @code{specint} can handle the hypergeometric function
3221 @c @code{%f[p,q]([],[],z)}, the whittaker function of the first kind
3222 @c @code{%m[u,k](z)} and of the second kind @code{%w[u,k](z)}.
3224 Die folgenden speziellen Funktionen k@"onnen als Integrand auftreten: die
3225 un@-voll@-st@"an@-di@-ge Gammafunkion @mrefcomma{gamma_incomplete} die
3226 Fehlerfunktionen @mref{erf} und @mrefcomma{erfc} nicht jedoch die Funktion
3227 @mrefcomma{erfi} die jedoch in eine andere Fehlerfunktion transformiert werden
3228 kann, die Exponentiellen Integrale wie zum Beispiel @mrefcomma{expintegral_e1}
3229 die Bessel-Funktionen wie zum Beispiel @mrefcomma{bessel_j} einschlie@ss{}lich
3230 der Produkte von Bessel-Funktionen, Hankel-Funktionen wie zum Beispiel
3231 @mrefcomma{hankel_1} Hermite @mref{hermite} und Laguerre Polynome
3232 @mrefdot{laguerre} Weiterhin kann @code{specint} Integranden mit der
3233 Hypergeometrische Funktion @code{%f[p,q]([],[],z)}, die Whittaker Funktion der
3234 ersten Art @code{%m[u,k](z)} und die der zweiten Art @code{%w[u,k](z)}
3235 integrieren.
3237 @c The result may be in terms of special functions and can include unsimplified
3238 @c hypergeomtric functions.
3240 Das Ergebnis kann spezielle Funktionen und die Hypergeometrische Funktion
3241 enthalten.
3243 @c When @code{laplace} fails to find a Laplace transform, @code{specint} is
3244 @c called. Because @code{laplace} knows more general rules for Laplace
3245 @c transforms, it is preferable to use @code{laplace} and not @code{specint}.
3247 Kann die Funktion @mref{laplace} keine Laplace-Transformation finden, wird
3248 @code{specint} aufgerufen. Da die Funktion @code{laplace} einige allgemeine
3249 Regeln kennt, um die Laplace-Transformation zu finden, ist es von Vorteil
3250 die Laplace-Transformation mit der Funktion @code{laplace} zu berechnen.
3252 @c @code{demo(hypgeo)} displays several examples of Laplace transforms computed
3253 @c by @code{specint}.
3255 @code{demo(hypgeo)} zeigt einige Beispiele f@"ur Laplace-Transformationen mit
3256 der Funktion @code{specint}.
3258 Beispiele:
3260 @example
3261 (%i1) assume (p > 0, a > 0)$
3262 (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
3263 sqrt(%pi)
3264 (%o2) ------------
3265 a 3/2
3266 2 (p + -)
3267 4
3268 @group
3269 (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
3270 * exp(-p*t), t);
3271 @end group
3272 @group
3273 - a/p
3274 sqrt(a) %e
3275 (%o3) ---------------
3276 2
3277 p
3278 @end group
3279 @end example
3281 @c Examples for exponential integrals:
3283 Beispiel mit Exponentiellen Integralen.
3285 @example
3286 (%i4) assume(s>0,a>0,s-a>0)$
3287 (%i5) ratsimp(specint(%e^(a*t)
3288 *(log(a)+expintegral_e1(a*t))*%e^(-s*t),t));
3289 @group
3290 log(s)
3291 (%o5) ------
3292 s - a
3293 @end group
3294 (%i6) logarc:true$
3295 (%i7) gamma_expand:true$
3297 radcan(specint((cos(t)*expintegral_si(t)
3298 -sin(t)*expintegral_ci(t))*%e^(-s*t),t));
3299 log(s)
3300 (%o8) ------
3301 2
3302 s + 1
3303 ratsimp(specint((2*t*log(a)+2/a*sin(a*t)
3304 -2*t*expintegral_ci(a*t))*%e^(-s*t),t));
3305 2 2
3306 log(s + a )
3307 (%o9) ------------
3308 2
3309 s
3310 @end example
3312 @c Results when using the expansion of @code{gamma_incomplete} and when changing
3313 @c the representation to @code{expintegral_e1}:
3315 Entwicklung der unvollst@"andigen Gammafunktion und Wechsel in eine Darstellung
3316 mit dem Exponentiellen Integral @code{expintegral_e1}.
3318 @example
3319 (%i10) assume(s>0)$
3320 (%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
3321 1
3322 gamma_incomplete(-, k s)
3323 2
3324 (%o11) ------------------------
3325 sqrt(%pi) sqrt(s)
3327 (%i12) gamma_expand:true$
3328 (%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
3329 erfc(sqrt(k) sqrt(s))
3330 (%o13) ---------------------
3331 sqrt(s)
3333 (%i14) expintrep:expintegral_e1$
3334 (%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t));
3335 a s
3336 a s %e expintegral_e1(a s) - 1
3337 (%o15) - ---------------------------------
3338 a
3339 @end example
3340 @end deffn
3342 @c --- 10.07.2011 DK -----------------------------------------------------------
3343 @anchor{hgfred}
3344 @deffn {Funktion} hgfred (@var{a}, @var{b}, @var{z})
3346 @c Simplify the generalized hypergeometric function in terms of other,
3347 @c simpler, forms. @var{a} is a list of numerator parameters and @var{b}
3348 @c is a list of the denominator parameters.
3350 Vereinfacht die Hypergeometrische Funktion zu einfacheren Funktionen, wie
3351 Polynome und spezielle Funktionen. Die Hypergeometrische Funktion ist die
3352 verallgemeinerte geometrische Reihe und ist wie folgt definiert:
3354 @example
3355 @group
3356 F (a_1, ... a_p; b_1, ..., b_q; z) =
3357 p, q
3359 inf p q k
3360 ==== /===\ gamma(k + a ) /===\ gamma(b ) z
3361 \ ! ! i ! ! j
3362 = > ! ! ------------- ! ! ----------------
3363 / ! ! gamma(a ) ! ! k! gamma(k + b )
3364 ==== i = 1 i j = 1 j
3365 k = 0
3366 @end group
3367 @end example
3369 Die Argumente @var{a} und @var{b} sind Listen mit den Parametern der
3370 Hypergeometrischen Funktion @code{a_1}, @dots{}, @code{a_p} sowie
3371 @code{b_1}, @dots{}, @code{b_p}. Die Liste @var{a} enth@"alt die
3372 @code{p}-Elemente @var{a_i} und die Liste @var{b} enth@"alt die
3373 @var{q}-Elemente @var{b_i}.
3375 @c If @code{hgfred} cannot simplify the hypergeometric function, it returns
3376 @c an expression of the form @code{%f[p,q]([a], [b], x)} where @var{p} is
3377 @c the number of elements in @var{a}, and @var{q} is the number of elements
3378 @c in @var{b}. This is the usual @code{pFq} generalized hypergeometric
3379 @c function
3381 Kann @code{hgfred} die Hypergeomentrische Funktion nicht vereinfachen, wird
3382 eine Substantivform @code{%f[p,q]([a], [b], z)} zur@"uckgegeben.
3384 Beispiele:
3386 @example
3387 (%i1) assume(not(equal(z,0)));
3388 (%o1) [notequal(z, 0)]
3389 (%i2) hgfred([v+1/2],[2*v+1],2*%i*z);
3391 v/2 %i z
3392 4 bessel_j(v, z) gamma(v + 1) %e
3393 (%o2) ---------------------------------------
3394 v
3395 z
3396 (%i3) hgfred([1,1],[2],z);
3398 log(1 - z)
3399 (%o3) - ----------
3400 z
3401 (%i4) hgfred([a,a+1/2],[3/2],z^2);
3402 @group
3404 1 - 2 a 1 - 2 a
3405 (z + 1) - (1 - z)
3406 (%o4) -------------------------------
3407 2 (1 - 2 a) z
3408 @end group
3409 @end example
3410 @end deffn
3412 @c --- 10.07.2011 DK -----------------------------------------------------------
3413 @anchor{lambert_w}
3414 @deffn {Funktion} lambert_w (@var{z})
3416 Der Hauptzweig der Lambert W Funktion, die L@"osung von
3417 @code{z = W(z) * exp(W(z))}.
3418 @end deffn
3420 @c --- 10.07.2011 DK -----------------------------------------------------------
3421 @anchor{nzeta}
3422 @deffn {Funktion} nzeta (@var{z})
3424 Die Plasma Dispersion Funktion
3425 @code{nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))}.
3426 @end deffn
3428 @c --- 10.07.2011 DK -----------------------------------------------------------
3429 @anchor{nzetar}
3430 @deffn {Funktion} nzetar (@var{z})
3432 Gibt @code{realpart(nzeta(z))} zur@"uck.
3433 @end deffn
3435 @c --- 10.07.2011 DK -----------------------------------------------------------
3436 @anchor{nzetai}
3437 @deffn {Funktion} nzetai (@var{z})
3439 Gibt @code{imagpart(nzeta(z))} zur@"uck.
3440 @end deffn
3442 @c --- 10.07.2011 DK -----------------------------------------------------------
3443 @anchor{%s}
3444 @deffn {Funktion} %s [@var{u},@var{v}] (@var{z})
3446 Lommels kleine Funktion @code{s[u,v](z)}. Siehe Gradshteyn & Ryzhik 8.570.1.
3447 @end deffn
3449 @c --- End of file Special.de.texi ---------------------------------------------