Documentation of struve_h was Re: float of struve_h functions?
Subject: Documentation of struve_h was Re: float of struve_h functions?
From: Dieter Kaiser
Date: Wed, 26 Oct 2011 23:28:02 +0200
Am Sonntag, den 23.10.2011, 15:52 +0100 schrieb Rupert Swarbrick:
> How about something like the following?
>
> Dieter Kaiser <drdieterkaiser at web.de> writes:
> > This is the German documentation of struve_h:
> >
> > -- Funktion: struve_h (<v>, <z>)
> > Die Struve-Funktion H der Ordnung v mit dem Argument z. Siehe
> > Abramowitz und Stegun, Handbook of Mathematical Functions, Kapitel
> > 12. Die Definition ist
> >
> > inf
> > ==== k 2 k
> > z v + 1 \ (- 1) z
> > H (z) = (-) > ----------------------------------
> > v 2 / 2 k 3 3
> > ==== 2 gamma(k + -) gamma(v + k + -)
> > k = 0 2 2
> >
> > Die Struve-Funktion `struve_h' ist f?r das numerische und
> > symbolische Rechnen geeignet. Im Unterschied zu den
> > Bessel-Funktionen ist jedoch die Implementation der Funktion
> > `struve_h' weniger vollst?ndig.
> >
> > Maxima berechnet `struve_h' numerisch f?r reelle und komplexe
> > Gleitkommazahlen als Argumente f?r v und z. Mit der Funktion
> > `float' oder der Optionsvariablen `numer' kann die numerische
> > Auswertung erzwungen werden, wenn die Argumente Zahlen sind.
> >
> > Hat die Optionsvariable `besselexpand' den Wert `true', wird die
> > Struve-Funktion `struve_h' mit einer halbzahligen Ordnung v als
> > Sinus- und Kosinusfunktionen entwickelt.
> >
> > Maxima kennt die Ableitung der Struve-Funktion `struve_h' nach dem
> > Argument z.
> >
> > Siehe auch die Struve-Funktion `struve_l'.
> >
> > Beispiele:
> >
> ....
>
> -- Function: struve_h (<v>, <z>)
>
> The Struve function, H, of order v with argument z. See Abramowitz and
> Stegun, Handbook of Mathematical Functions, chapter 12. The definition
> is
>
> inf
> ==== k 2 k
> z v + 1 \ (- 1) z
> H (z) = (-) > ----------------------------------
> v 2 / 2 k 3 3
> ==== 2 gamma(k + -) gamma(v + k + -)
> k = 0 2 2
>
>
> The Struve function `struve_h' is suitable for both numerical and
> symbolic calculations. The implementation of `struve_h' is not
> currently as complete as that for the Bessel functions.
>
> Maxima can find numerical values for `struve_h' for real and complex
> floating point arguments for v and z. To force `struve_h' to evaluate
> to a number when given numerical arguments, use either the `float'
> function or the `numer' option variable.
>
> If the option variable `besselexpand' is true and the order is a half
> integer, the Struve function `struve_h' is simplified to a function in
> sines and cosines.
>
> Maxima knows the derivative of the Struve function `struve_h' with
> respect to the argument z.
>
> See also the Struve function `struve_l'.
>
> Examples:
>
> ...
>
> -----------
>
> It might be nice to specify in what way the implementation for
> `struve_h' is not very complete. I don't actually know anything about
> H_v(z), so I suspect I'm not the best person to try and work that out...
Thank your very much for the English translation. There is simply much
more functionality implemented for the Bessel functions. The German
documentation for Bessel J is more verbose.
First the English documentation
-------------------------------------------------------------------
Function: bessel_j (v, z)
The Bessel function of the first kind of order v and argument z.
bessel_j is defined as
inf
==== k - v - 2 k v + 2 k
\ (- 1) 2 z
> --------------------------
/ k! gamma(v + k + 1)
====
k = 0
although the infinite series is not used for computations.
-------------------------------------------------------------------
And this is the German documentation:
-------------------------------------------------------------------
-- Funktion: bessel_j (<v>, <z>)
Die Bessel-Funktion der ersten Art der Ordnung v mit dem Argument
z. `bessel_j' ist definiert als
inf
==== k
\ (- 1) z 2 k + v
J (z) = > ------------------- (-)
v / k! gamma(v + k + 1) 2
====
k = 0
Die Reihenentwicklung wird nicht f?r die numerische Berechnung
genutzt.
Die Bessel-Funktion `bessel_j' ist f?r das numerische und
symbolische Rechnen geeignet.
Maxima berechnet `bessel_j' numerisch f?r reelle und komplexe
Gleitkommazahlen als Argumente f?r v und z. Mit der Funktion
`float' oder der Optionsvariablen `numer' kann die numerische
Auswertung erzwungen werden, wenn die Argumente ganze oder
rationale Zahlen sind. Die numerische Berechnung f?r gro?e
Gleitkommazahlen ist nicht implementiert. In diesem Fall gibt
Maxima eine Substantivform zur?ck.
`bessel_j' hat die folgenden Eigenschaften, die mit mit der
Funktion `properties' angezeigt werden und auf das symbolische
Rechnen Einfluss haben:
`conjugate function'
`bessel_j' hat Spiegelsymmetrie, wenn das Argument <z> keine
negative reelle Zahl ist. Die Spiegelsymmetrie wird zum
Beispiel von der Funktion `conjugate' f?r die Vereinfachung
eines Ausdrucks genutzt.
`complex characteristic'
Maxima kennt den Realteil und den Imagin?rteil von `bessel_j'
f?r spezielle Argumente v und z.
`limit function'
Maxima kennt spezielle Grenzwerte der Funktion `bessel_j'.
`integral'
Maxima kennt das Integral der Funktion `bessel_j' f?r die
Integrationsvariable z.
`gradef'
Maxima kennt die Ableitungen der Funktion `bessel_j' nach den
Argumenten v und z.
Die Vereinfachung der Bessel-Funktion `bessel_j' wird von den
folgenden Optionsvariablen kontrolliert:
`distribute_over'
Hat die Optionsvariable `distribute_over' den Wert `true'
und sind die Argumente von `bessel_j' eine Matrix, Liste oder
Gleichung wird die Funktion auf die Elemente oder beiden
Seiten der Gleichung angewendet. Der Standardwert ist `true'.
`besselexpand'
Hat die Optionsvariable `besselexpand' den Wert `true', wird
`bessel_j' mit einer halbzahligen Ordnung v als Sinus- und
Kosinusfunktionen entwickelt.
`bessel_reduce'
Hat die Optionsvariable `bessel_reduce' den Wert `true', wird
`bessel_j' mit einer ganzzahligen Ordnung n nach
Bessel-Funktionen `bessel_j' mit der niedrigsten Ordnung `0'
und `1' entwickelt.
`hypergeometric_representation'
Hat die Optionsvariable `hypergeometric_representation' den
Wert `true', dann wird `bessel_j' als hypergeometrische
Funktion dargestellt.
Weiterhin kennt Maxima die geraden und ungeraden
Symmetrieeigenschaften von `bessel_j'. F?r eine ganze Zahl n
vereinfacht daher `bessel_j(-n, z)' zu `(-1)^n bessel_j(n, z)'.
Maxima kennt noch die Funktion `spherical_bessel_j', die im Paket
`orthopoly' definiert ist. Siehe auch die anderen
Bessel-Funktionen `bessel_y', `bessel_i' und `bessel_k' sowie
die weiteren mit den Bessel-Funktionen verwandten Funktionen wie
die Hankel-Funktionen in *note Hankel-Funktionen::,
Airy-Funktionen in *note Airy-Funktionen:: und Struve-Funktionen
in *note Struve-Funktionen::.
Beispiele:
Numerisches Rechnen mit der Bessel-Funktion. F?r gro?e
Gleitkommazahlen ist die numerische Berechnung nicht implementiert.
(%i1) bessel_j(1,[0.5, 0.5+%i]);
(%o1) [.2422684576748739, .5124137767280905 %i
+ .3392601907198862]
(%i2) bessel_j(1,[0.5b0, 0.5b0+%i]);
(%o2) [bessel_j(1, 5.0b-1), bessel_j(1, %i + 5.0b-1)]
Vereinfachungen der Bessel-Funktion mit den Optionsvariablen
`besselexpand' und `bessel_reduce'.
(%i3) bessel_j(1/2,x), besselexpand:true;
sqrt(2) sin(x)
(%o3) -----------------
sqrt(%pi) sqrt(x)
(%i4) bessel_j(3,x), bessel_reduce:true;
2 bessel_j(1, x)
4 (---------------- - bessel_j(0, x))
x
(%o4) ------------------------------------- - bessel_j(1, x)
x
Ableitungen und Integrale der Bessel-Funktion. Das letzte
Beispiel zeigt die Laplace-Transformation der Bessel-Funktion mit
der Funktion `laplace'.
(%i5) diff(bessel_j(2,x), x);
bessel_j(1, x) - bessel_j(3, x)
(%o5) -------------------------------
2
(%i6) diff(bessel_j(v,x), x);
bessel_j(v - 1, x) - bessel_j(v + 1, x)
(%o6) ---------------------------------------
2
(%i7) integrate(bessel_j(v,x), x);
(%o7)
2
v 1 v 3 x - v - 1 v
+ 1
hypergeometric([- + -], [- + -, v + 1], - --) 2 x
2 2 2 2 4
-------------------------------------------------------------
v 1
(- + -) gamma(v + 1)
2 2
(%i8) laplace(bessel_j(2,t), t, s);
1 2
(1 - sqrt(-- + 1)) s
2
s
(%o8) ---------------------
1
sqrt(-- + 1)
2
s
Bessel-Funktionen als L?sung einer linearen Differentialgleichung
zweiter Ordnung.
(%i1) depends(y, x);
(%o1) [y(x)]
(%i2) declare(n, integer);
(%o2) done
(%i3) 'diff(y, x, 2)*x^2 + 'diff(y, x)*x + y*(x^2-n^2) = 0;
2
2 2 d y 2 dy
(%o3) y (x - n ) + --- x + -- x = 0
2 dx
dx
(%i4) ode2(%, y, x);
(%o4) y = %k2 bessel_y(n, x) + %k1 bessel_j(n, x)
Dieter Kaiser