...
Run Format

Source file src/math/jn.go

     1	// Copyright 2010 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package math
     6	
     7	/*
     8		Bessel function of the first and second kinds of order n.
     9	*/
    10	
    11	// The original C code and the long comment below are
    12	// from FreeBSD's /usr/src/lib/msun/src/e_jn.c and
    13	// came with this notice. The go code is a simplified
    14	// version of the original C.
    15	//
    16	// ====================================================
    17	// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
    18	//
    19	// Developed at SunPro, a Sun Microsystems, Inc. business.
    20	// Permission to use, copy, modify, and distribute this
    21	// software is freely granted, provided that this notice
    22	// is preserved.
    23	// ====================================================
    24	//
    25	// __ieee754_jn(n, x), __ieee754_yn(n, x)
    26	// floating point Bessel's function of the 1st and 2nd kind
    27	// of order n
    28	//
    29	// Special cases:
    30	//      y0(0)=y1(0)=yn(n,0) = -inf with division by zero signal;
    31	//      y0(-ve)=y1(-ve)=yn(n,-ve) are NaN with invalid signal.
    32	// Note 2. About jn(n,x), yn(n,x)
    33	//      For n=0, j0(x) is called,
    34	//      for n=1, j1(x) is called,
    35	//      for n<x, forward recursion is used starting
    36	//      from values of j0(x) and j1(x).
    37	//      for n>x, a continued fraction approximation to
    38	//      j(n,x)/j(n-1,x) is evaluated and then backward
    39	//      recursion is used starting from a supposed value
    40	//      for j(n,x). The resulting value of j(0,x) is
    41	//      compared with the actual value to correct the
    42	//      supposed value of j(n,x).
    43	//
    44	//      yn(n,x) is similar in all respects, except
    45	//      that forward recursion is used for all
    46	//      values of n>1.
    47	
    48	// Jn returns the order-n Bessel function of the first kind.
    49	//
    50	// Special cases are:
    51	//	Jn(n, ±Inf) = 0
    52	//	Jn(n, NaN) = NaN
    53	func Jn(n int, x float64) float64 {
    54		const (
    55			TwoM29 = 1.0 / (1 << 29) // 2**-29 0x3e10000000000000
    56			Two302 = 1 << 302        // 2**302 0x52D0000000000000
    57		)
    58		// special cases
    59		switch {
    60		case IsNaN(x):
    61			return x
    62		case IsInf(x, 0):
    63			return 0
    64		}
    65		// J(-n, x) = (-1)**n * J(n, x), J(n, -x) = (-1)**n * J(n, x)
    66		// Thus, J(-n, x) = J(n, -x)
    67	
    68		if n == 0 {
    69			return J0(x)
    70		}
    71		if x == 0 {
    72			return 0
    73		}
    74		if n < 0 {
    75			n, x = -n, -x
    76		}
    77		if n == 1 {
    78			return J1(x)
    79		}
    80		sign := false
    81		if x < 0 {
    82			x = -x
    83			if n&1 == 1 {
    84				sign = true // odd n and negative x
    85			}
    86		}
    87		var b float64
    88		if float64(n) <= x {
    89			// Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x)
    90			if x >= Two302 { // x > 2**302
    91	
    92				// (x >> n**2)
    93				//          Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
    94				//          Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
    95				//          Let s=sin(x), c=cos(x),
    96				//              xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then
    97				//
    98				//                 n    sin(xn)*sqt2    cos(xn)*sqt2
    99				//              ----------------------------------
   100				//                 0     s-c             c+s
   101				//                 1    -s-c            -c+s
   102				//                 2    -s+c            -c-s
   103				//                 3     s+c             c-s
   104	
   105				var temp float64
   106				switch n & 3 {
   107				case 0:
   108					temp = Cos(x) + Sin(x)
   109				case 1:
   110					temp = -Cos(x) + Sin(x)
   111				case 2:
   112					temp = -Cos(x) - Sin(x)
   113				case 3:
   114					temp = Cos(x) - Sin(x)
   115				}
   116				b = (1 / SqrtPi) * temp / Sqrt(x)
   117			} else {
   118				b = J1(x)
   119				for i, a := 1, J0(x); i < n; i++ {
   120					a, b = b, b*(float64(i+i)/x)-a // avoid underflow
   121				}
   122			}
   123		} else {
   124			if x < TwoM29 { // x < 2**-29
   125				// x is tiny, return the first Taylor expansion of J(n,x)
   126				// J(n,x) = 1/n!*(x/2)**n  - ...
   127	
   128				if n > 33 { // underflow
   129					b = 0
   130				} else {
   131					temp := x * 0.5
   132					b = temp
   133					a := 1.0
   134					for i := 2; i <= n; i++ {
   135						a *= float64(i) // a = n!
   136						b *= temp       // b = (x/2)**n
   137					}
   138					b /= a
   139				}
   140			} else {
   141				// use backward recurrence
   142				//                      x      x**2      x**2
   143				//  J(n,x)/J(n-1,x) =  ----   ------   ------   .....
   144				//                      2n  - 2(n+1) - 2(n+2)
   145				//
   146				//                      1      1        1
   147				//  (for large x)   =  ----  ------   ------   .....
   148				//                      2n   2(n+1)   2(n+2)
   149				//                      -- - ------ - ------ -
   150				//                       x     x         x
   151				//
   152				// Let w = 2n/x and h=2/x, then the above quotient
   153				// is equal to the continued fraction:
   154				//                  1
   155				//      = -----------------------
   156				//                     1
   157				//         w - -----------------
   158				//                        1
   159				//              w+h - ---------
   160				//                     w+2h - ...
   161				//
   162				// To determine how many terms needed, let
   163				// Q(0) = w, Q(1) = w(w+h) - 1,
   164				// Q(k) = (w+k*h)*Q(k-1) - Q(k-2),
   165				// When Q(k) > 1e4	good for single
   166				// When Q(k) > 1e9	good for double
   167				// When Q(k) > 1e17	good for quadruple
   168	
   169				// determine k
   170				w := float64(n+n) / x
   171				h := 2 / x
   172				q0 := w
   173				z := w + h
   174				q1 := w*z - 1
   175				k := 1
   176				for q1 < 1e9 {
   177					k++
   178					z += h
   179					q0, q1 = q1, z*q1-q0
   180				}
   181				m := n + n
   182				t := 0.0
   183				for i := 2 * (n + k); i >= m; i -= 2 {
   184					t = 1 / (float64(i)/x - t)
   185				}
   186				a := t
   187				b = 1
   188				//  estimate log((2/x)**n*n!) = n*log(2/x)+n*ln(n)
   189				//  Hence, if n*(log(2n/x)) > ...
   190				//  single 8.8722839355e+01
   191				//  double 7.09782712893383973096e+02
   192				//  long double 1.1356523406294143949491931077970765006170e+04
   193				//  then recurrent value may overflow and the result is
   194				//  likely underflow to zero
   195	
   196				tmp := float64(n)
   197				v := 2 / x
   198				tmp = tmp * Log(Abs(v*tmp))
   199				if tmp < 7.09782712893383973096e+02 {
   200					for i := n - 1; i > 0; i-- {
   201						di := float64(i + i)
   202						a, b = b, b*di/x-a
   203					}
   204				} else {
   205					for i := n - 1; i > 0; i-- {
   206						di := float64(i + i)
   207						a, b = b, b*di/x-a
   208						// scale b to avoid spurious overflow
   209						if b > 1e100 {
   210							a /= b
   211							t /= b
   212							b = 1
   213						}
   214					}
   215				}
   216				b = t * J0(x) / b
   217			}
   218		}
   219		if sign {
   220			return -b
   221		}
   222		return b
   223	}
   224	
   225	// Yn returns the order-n Bessel function of the second kind.
   226	//
   227	// Special cases are:
   228	//	Yn(n, +Inf) = 0
   229	//	Yn(n > 0, 0) = -Inf
   230	//	Yn(n < 0, 0) = +Inf if n is odd, -Inf if n is even
   231	//	Y1(n, x < 0) = NaN
   232	//	Y1(n, NaN) = NaN
   233	func Yn(n int, x float64) float64 {
   234		const Two302 = 1 << 302 // 2**302 0x52D0000000000000
   235		// special cases
   236		switch {
   237		case x < 0 || IsNaN(x):
   238			return NaN()
   239		case IsInf(x, 1):
   240			return 0
   241		}
   242	
   243		if n == 0 {
   244			return Y0(x)
   245		}
   246		if x == 0 {
   247			if n < 0 && n&1 == 1 {
   248				return Inf(1)
   249			}
   250			return Inf(-1)
   251		}
   252		sign := false
   253		if n < 0 {
   254			n = -n
   255			if n&1 == 1 {
   256				sign = true // sign true if n < 0 && |n| odd
   257			}
   258		}
   259		if n == 1 {
   260			if sign {
   261				return -Y1(x)
   262			}
   263			return Y1(x)
   264		}
   265		var b float64
   266		if x >= Two302 { // x > 2**302
   267			// (x >> n**2)
   268			//	    Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
   269			//	    Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
   270			//	    Let s=sin(x), c=cos(x),
   271			//		xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then
   272			//
   273			//		   n	sin(xn)*sqt2	cos(xn)*sqt2
   274			//		----------------------------------
   275			//		   0	 s-c		 c+s
   276			//		   1	-s-c 		-c+s
   277			//		   2	-s+c		-c-s
   278			//		   3	 s+c		 c-s
   279	
   280			var temp float64
   281			switch n & 3 {
   282			case 0:
   283				temp = Sin(x) - Cos(x)
   284			case 1:
   285				temp = -Sin(x) - Cos(x)
   286			case 2:
   287				temp = -Sin(x) + Cos(x)
   288			case 3:
   289				temp = Sin(x) + Cos(x)
   290			}
   291			b = (1 / SqrtPi) * temp / Sqrt(x)
   292		} else {
   293			a := Y0(x)
   294			b = Y1(x)
   295			// quit if b is -inf
   296			for i := 1; i < n && !IsInf(b, -1); i++ {
   297				a, b = b, (float64(i+i)/x)*b-a
   298			}
   299		}
   300		if sign {
   301			return -b
   302		}
   303		return b
   304	}
   305	

View as plain text