...
Run Format

Source file src/math/jn.go

Documentation: math

     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  //	Yn(n, x < 0) = NaN
   232  //	Yn(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