Mercurial > octave-libgccjit
annotate src/DLD-FUNCTIONS/besselj.cc @ 8920:eb63fbe60fab
update copyright notices
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Sat, 07 Mar 2009 10:41:27 -0500 |
parents | ab0674a8b345 |
children | 7c02ec148a3c |
rev | line source |
---|---|
3155 | 1 /* |
2 | |
7017 | 3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, |
8920 | 4 2007, 2008 John W. Eaton |
3155 | 5 |
6 This file is part of Octave. | |
7 | |
8 Octave is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
11 option) any later version. | |
3155 | 12 |
13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
7016 | 19 along with Octave; see the file COPYING. If not, see |
20 <http://www.gnu.org/licenses/>. | |
3155 | 21 |
22 */ | |
23 | |
24 #ifdef HAVE_CONFIG_H | |
25 #include <config.h> | |
26 #endif | |
27 | |
28 #include "lo-specfun.h" | |
4153 | 29 #include "quit.h" |
3155 | 30 |
31 #include "defun-dld.h" | |
32 #include "error.h" | |
33 #include "gripes.h" | |
34 #include "oct-obj.h" | |
35 #include "utils.h" | |
36 | |
3220 | 37 enum bessel_type |
38 { | |
39 BESSEL_J, | |
40 BESSEL_Y, | |
41 BESSEL_I, | |
42 BESSEL_K, | |
43 BESSEL_H1, | |
44 BESSEL_H2 | |
45 }; | |
46 | |
47 #define DO_BESSEL(type, alpha, x, scaled, ierr, result) \ | |
3155 | 48 do \ |
49 { \ | |
50 switch (type) \ | |
51 { \ | |
3220 | 52 case BESSEL_J: \ |
53 result = besselj (alpha, x, scaled, ierr); \ | |
54 break; \ | |
55 \ | |
56 case BESSEL_Y: \ | |
57 result = bessely (alpha, x, scaled, ierr); \ | |
3155 | 58 break; \ |
59 \ | |
3220 | 60 case BESSEL_I: \ |
61 result = besseli (alpha, x, scaled, ierr); \ | |
3155 | 62 break; \ |
63 \ | |
3220 | 64 case BESSEL_K: \ |
65 result = besselk (alpha, x, scaled, ierr); \ | |
3155 | 66 break; \ |
67 \ | |
3220 | 68 case BESSEL_H1: \ |
69 result = besselh1 (alpha, x, scaled, ierr); \ | |
70 break; \ | |
71 \ | |
72 case BESSEL_H2: \ | |
73 result = besselh2 (alpha, x, scaled, ierr); \ | |
3155 | 74 break; \ |
75 \ | |
76 default: \ | |
77 break; \ | |
78 } \ | |
79 } \ | |
80 while (0) | |
81 | |
82 static void | |
3220 | 83 gripe_bessel_arg (const char *fn, const char *arg) |
3155 | 84 { |
3220 | 85 error ("%s: expecting scalar or matrix as %s argument", fn, arg); |
3155 | 86 } |
87 | |
88 octave_value_list | |
3220 | 89 do_bessel (enum bessel_type type, const char *fn, |
90 const octave_value_list& args, int nargout) | |
3155 | 91 { |
3220 | 92 octave_value_list retval; |
3155 | 93 |
94 int nargin = args.length (); | |
95 | |
3220 | 96 if (nargin == 2 || nargin == 3) |
3155 | 97 { |
3220 | 98 bool scaled = (nargin == 3); |
99 | |
3155 | 100 octave_value alpha_arg = args(0); |
3220 | 101 octave_value x_arg = args(1); |
3155 | 102 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
103 if (alpha_arg.is_single_type () || x_arg.is_single_type ()) |
3155 | 104 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
105 if (alpha_arg.is_scalar_type ()) |
3155 | 106 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
107 float alpha = args(0).float_value (); |
4844 | 108 |
109 if (! error_state) | |
3220 | 110 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
111 if (x_arg.is_scalar_type ()) |
3220 | 112 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
113 FloatComplex x = x_arg.float_complex_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
114 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
115 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
116 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
117 octave_idx_type ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
118 octave_value result; |
3155 | 119 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
120 DO_BESSEL (type, alpha, x, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
121 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
122 if (nargout > 1) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
123 retval(1) = static_cast<float> (ierr); |
3220 | 124 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
125 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
126 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
127 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
128 gripe_bessel_arg (fn, "second"); |
3220 | 129 } |
130 else | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
131 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
132 FloatComplexNDArray x = x_arg.float_complex_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
133 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
134 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
135 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
136 ArrayN<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
137 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
138 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
139 DO_BESSEL (type, alpha, x, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
140 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
141 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
142 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
143 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
144 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
145 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
146 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
147 gripe_bessel_arg (fn, "second"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
148 } |
3220 | 149 } |
150 else | |
4844 | 151 gripe_bessel_arg (fn, "first"); |
152 } | |
153 else | |
154 { | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
155 dim_vector dv0 = args(0).dims (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
156 dim_vector dv1 = args(1).dims (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
157 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
158 bool args0_is_row_vector = (dv0 (1) == dv0.numel ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
159 bool args1_is_col_vector = (dv1 (0) == dv1.numel ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
160 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
161 if (args0_is_row_vector && args1_is_col_vector) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
162 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
163 FloatRowVector ralpha = args(0).float_row_vector_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
164 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
165 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
166 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
167 FloatComplexColumnVector cx = |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
168 x_arg.float_complex_column_vector_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
169 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
170 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
171 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
172 Array2<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
173 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
174 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
175 DO_BESSEL (type, ralpha, cx, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
176 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
177 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
178 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
179 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
180 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
181 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
182 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
183 gripe_bessel_arg (fn, "second"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
184 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
185 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
186 gripe_bessel_arg (fn, "first"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
187 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
188 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
189 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
190 FloatNDArray alpha = args(0).float_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
191 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
192 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
193 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
194 if (x_arg.is_scalar_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
195 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
196 FloatComplex x = x_arg.float_complex_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
197 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
198 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
199 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
200 ArrayN<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
201 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
202 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
203 DO_BESSEL (type, alpha, x, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
204 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
205 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
206 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
207 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
208 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
209 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
210 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
211 gripe_bessel_arg (fn, "second"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
212 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
213 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
214 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
215 FloatComplexNDArray x = x_arg.float_complex_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
216 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
217 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
218 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
219 ArrayN<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
220 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
221 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
222 DO_BESSEL (type, alpha, x, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
223 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
224 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
225 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
226 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
227 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
228 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
229 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
230 gripe_bessel_arg (fn, "second"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
231 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
232 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
233 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
234 gripe_bessel_arg (fn, "first"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
235 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
236 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
237 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
238 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
239 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
240 if (alpha_arg.is_scalar_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
241 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
242 double alpha = args(0).double_value (); |
3220 | 243 |
4844 | 244 if (! error_state) |
245 { | |
246 if (x_arg.is_scalar_type ()) | |
247 { | |
248 Complex x = x_arg.complex_value (); | |
3155 | 249 |
4844 | 250 if (! error_state) |
3155 | 251 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
252 octave_idx_type ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
253 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
254 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
255 DO_BESSEL (type, alpha, x, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
256 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
257 if (nargout > 1) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
258 retval(1) = static_cast<double> (ierr); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
259 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
260 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
261 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
262 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
263 gripe_bessel_arg (fn, "second"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
264 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
265 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
266 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
267 ComplexNDArray x = x_arg.complex_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
268 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
269 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
270 { |
5275 | 271 ArrayN<octave_idx_type> ierr; |
3220 | 272 octave_value result; |
273 | |
274 DO_BESSEL (type, alpha, x, scaled, ierr, result); | |
275 | |
276 if (nargout > 1) | |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
277 retval(1) = NDArray (ierr); |
3220 | 278 |
279 retval(0) = result; | |
3155 | 280 } |
4844 | 281 else |
282 gripe_bessel_arg (fn, "second"); | |
3155 | 283 } |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
284 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
285 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
286 gripe_bessel_arg (fn, "first"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
287 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
288 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
289 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
290 dim_vector dv0 = args(0).dims (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
291 dim_vector dv1 = args(1).dims (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
292 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
293 bool args0_is_row_vector = (dv0 (1) == dv0.numel ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
294 bool args1_is_col_vector = (dv1 (0) == dv1.numel ()); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
295 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
296 if (args0_is_row_vector && args1_is_col_vector) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
297 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
298 RowVector ralpha = args(0).row_vector_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
299 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
300 if (! error_state) |
4844 | 301 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
302 ComplexColumnVector cx = |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
303 x_arg.complex_column_vector_value (); |
4844 | 304 |
305 if (! error_state) | |
306 { | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
307 Array2<octave_idx_type> ierr; |
4844 | 308 octave_value result; |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
309 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
310 DO_BESSEL (type, ralpha, cx, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
311 |
4844 | 312 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
313 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
314 |
4844 | 315 retval(0) = result; |
316 } | |
317 else | |
318 gripe_bessel_arg (fn, "second"); | |
319 } | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
320 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
321 gripe_bessel_arg (fn, "first"); |
3155 | 322 } |
4844 | 323 else |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
324 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
325 NDArray alpha = args(0).array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
326 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
327 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
328 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
329 if (x_arg.is_scalar_type ()) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
330 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
331 Complex x = x_arg.complex_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
332 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
333 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
334 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
335 ArrayN<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
336 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
337 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
338 DO_BESSEL (type, alpha, x, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
339 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
340 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
341 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
342 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
343 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
344 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
345 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
346 gripe_bessel_arg (fn, "second"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
347 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
348 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
349 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
350 ComplexNDArray x = x_arg.complex_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
351 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
352 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
353 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
354 ArrayN<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
355 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
356 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
357 DO_BESSEL (type, alpha, x, scaled, ierr, result); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
358 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
359 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
360 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
361 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
362 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
363 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
364 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
365 gripe_bessel_arg (fn, "second"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
366 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
367 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
368 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
369 gripe_bessel_arg (fn, "first"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
370 } |
3155 | 371 } |
372 } | |
373 } | |
374 else | |
5823 | 375 print_usage (); |
3155 | 376 |
377 return retval; | |
378 } | |
379 | |
3220 | 380 DEFUN_DLD (besselj, args, nargout, |
3459 | 381 "-*- texinfo -*-\n\ |
382 @deftypefn {Loadable Function} {[@var{j}, @var{ierr}] =} besselj (@var{alpha}, @var{x}, @var{opt})\n\ | |
383 @deftypefnx {Loadable Function} {[@var{y}, @var{ierr}] =} bessely (@var{alpha}, @var{x}, @var{opt})\n\ | |
384 @deftypefnx {Loadable Function} {[@var{i}, @var{ierr}] =} besseli (@var{alpha}, @var{x}, @var{opt})\n\ | |
385 @deftypefnx {Loadable Function} {[@var{k}, @var{ierr}] =} besselk (@var{alpha}, @var{x}, @var{opt})\n\ | |
386 @deftypefnx {Loadable Function} {[@var{h}, @var{ierr}] =} besselh (@var{alpha}, @var{k}, @var{x}, @var{opt})\n\ | |
387 Compute Bessel or Hankel functions of various kinds:\n\ | |
3155 | 388 \n\ |
3459 | 389 @table @code\n\ |
390 @item besselj\n\ | |
8278
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
391 Bessel functions of the first kind. If the argument @var{opt} is supplied, \n\ |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
392 the result is multiplied by @code{exp(-abs(imag(x)))}.\n\ |
3459 | 393 @item bessely\n\ |
8278
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
394 Bessel functions of the second kind. If the argument @var{opt} is supplied,\n\ |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
395 the result is multiplied by @code{exp(-abs(imag(x)))}.\n\ |
3459 | 396 @item besseli\n\ |
8278
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
397 Modified Bessel functions of the first kind. If the argument @var{opt} is supplied,\n\ |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
398 the result is multiplied by @code{exp(-abs(real(x)))}.\n\ |
3459 | 399 @item besselk\n\ |
8278
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
400 Modified Bessel functions of the second kind. If the argument @var{opt} is supplied,\n\ |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
401 the result is multiplied by @code{exp(x)}.\n\ |
3459 | 402 @item besselh\n\ |
403 Compute Hankel functions of the first (@var{k} = 1) or second (@var{k}\n\ | |
8278
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
404 = 2) kind. If the argument @var{opt} is supplied, the result is multiplied by\n\ |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
405 @code{exp (-I*@var{x})} for @var{k} = 1 or @code{exp (I*@var{x})} for\n\ |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
406 @var{k} = 2.\n\ |
3459 | 407 @end table\n\ |
3220 | 408 \n\ |
3459 | 409 If @var{alpha} is a scalar, the result is the same size as @var{x}.\n\ |
410 If @var{x} is a scalar, the result is the same size as @var{alpha}.\n\ | |
411 If @var{alpha} is a row vector and @var{x} is a column vector, the\n\ | |
412 result is a matrix with @code{length (@var{x})} rows and\n\ | |
413 @code{length (@var{alpha})} columns. Otherwise, @var{alpha} and\n\ | |
414 @var{x} must conform and the result will be the same size.\n\ | |
3155 | 415 \n\ |
3459 | 416 The value of @var{alpha} must be real. The value of @var{x} may be\n\ |
417 complex.\n\ | |
418 \n\ | |
419 If requested, @var{ierr} contains the following status information\n\ | |
420 and is the same size as the result.\n\ | |
3548 | 421 \n\ |
3459 | 422 @enumerate 0\n\ |
423 @item\n\ | |
424 Normal return.\n\ | |
425 @item\n\ | |
426 Input error, return @code{NaN}.\n\ | |
427 @item\n\ | |
428 Overflow, return @code{Inf}.\n\ | |
429 @item\n\ | |
430 Loss of significance by argument reduction results in less than\n\ | |
431 half of machine accuracy.\n\ | |
432 @item\n\ | |
433 Complete loss of significance by argument reduction, return @code{NaN}.\n\ | |
434 @item\n\ | |
435 Error---no computation, algorithm termination condition not met,\n\ | |
436 return @code{NaN}.\n\ | |
437 @end enumerate\n\ | |
438 @end deftypefn") | |
3155 | 439 { |
3220 | 440 return do_bessel (BESSEL_J, "besselj", args, nargout); |
3155 | 441 } |
442 | |
3220 | 443 DEFUN_DLD (bessely, args, nargout, |
3459 | 444 "-*- texinfo -*-\n\ |
445 @deftypefn {Loadable Function} {[@var{y}, @var{ierr}] =} bessely (@var{alpha}, @var{x}, @var{opt})\n\ | |
446 See besselj.\n\ | |
447 @end deftypefn") | |
3155 | 448 { |
3220 | 449 return do_bessel (BESSEL_Y, "bessely", args, nargout); |
3155 | 450 } |
451 | |
3220 | 452 DEFUN_DLD (besseli, args, nargout, |
3459 | 453 "-*- texinfo -*-\n\ |
454 @deftypefn {Loadable Function} {[@var{i}, @var{ierr}] =} besseli (@var{alpha}, @var{x}, @var{opt})\n\ | |
455 See besselj.\n\ | |
456 @end deftypefn") | |
3155 | 457 { |
3220 | 458 return do_bessel (BESSEL_I, "besseli", args, nargout); |
3155 | 459 } |
460 | |
3220 | 461 DEFUN_DLD (besselk, args, nargout, |
3459 | 462 "-*- texinfo -*-\n\ |
463 @deftypefn {Loadable Function} {[@var{k}, @var{ierr}] =} besselk (@var{alpha}, @var{x}, @var{opt})\n\ | |
464 See besselj.\n\ | |
465 @end deftypefn") | |
3220 | 466 { |
467 return do_bessel (BESSEL_K, "besselk", args, nargout); | |
468 } | |
469 | |
470 DEFUN_DLD (besselh, args, nargout, | |
3459 | 471 "-*- texinfo -*-\n\ |
472 @deftypefn {Loadable Function} {[@var{h}, @var{ierr}] =} besselh (@var{alpha}, @var{k}, @var{x}, @var{opt})\n\ | |
473 See besselj.\n\ | |
474 @end deftypefn") | |
3220 | 475 { |
476 octave_value_list retval; | |
477 | |
478 int nargin = args.length (); | |
479 | |
480 if (nargin == 2) | |
481 { | |
482 retval = do_bessel (BESSEL_H1, "besselh", args, nargout); | |
483 } | |
484 else if (nargin == 3 || nargin == 4) | |
485 { | |
5275 | 486 octave_idx_type kind = args(1).int_value (); |
3220 | 487 |
3810 | 488 if (! error_state) |
3220 | 489 { |
490 octave_value_list tmp_args; | |
491 | |
492 if (nargin == 4) | |
493 tmp_args(2) = args(3); | |
494 | |
495 tmp_args(1) = args(2); | |
496 tmp_args(0) = args(0); | |
497 | |
498 if (kind == 1) | |
499 retval = do_bessel (BESSEL_H1, "besselh", tmp_args, nargout); | |
500 else if (kind == 2) | |
501 retval = do_bessel (BESSEL_H2, "besselh", tmp_args, nargout); | |
502 else | |
503 error ("besselh: expecting K = 1 or 2"); | |
504 } | |
505 else | |
506 error ("besselh: invalid value of K"); | |
507 } | |
508 else | |
5823 | 509 print_usage (); |
3220 | 510 |
511 return retval; | |
512 } | |
513 | |
514 DEFUN_DLD (airy, args, nargout, | |
3459 | 515 "-*- texinfo -*-\n\ |
516 @deftypefn {Loadable Function} {[@var{a}, @var{ierr}] =} airy (@var{k}, @var{z}, @var{opt})\n\ | |
3220 | 517 Compute Airy functions of the first and second kind, and their\n\ |
518 derivatives.\n\ | |
519 \n\ | |
3459 | 520 @example\n\ |
7031 | 521 K Function Scale factor (if 'opt' is supplied)\n\ |
522 --- -------- ---------------------------------------\n\ | |
523 0 Ai (Z) exp ((2/3) * Z * sqrt (Z))\n\ | |
524 1 dAi(Z)/dZ exp ((2/3) * Z * sqrt (Z))\n\ | |
525 2 Bi (Z) exp (-abs (real ((2/3) * Z *sqrt (Z))))\n\ | |
526 3 dBi(Z)/dZ exp (-abs (real ((2/3) * Z *sqrt (Z))))\n\ | |
3459 | 527 @end example\n\ |
3220 | 528 \n\ |
3549 | 529 The function call @code{airy (@var{z})} is equivalent to\n\ |
3459 | 530 @code{airy (0, @var{z})}.\n\ |
3155 | 531 \n\ |
3549 | 532 The result is the same size as @var{z}.\n\ |
3220 | 533 \n\ |
3459 | 534 If requested, @var{ierr} contains the following status information and\n\ |
535 is the same size as the result.\n\ | |
3548 | 536 \n\ |
3459 | 537 @enumerate 0\n\ |
538 @item\n\ | |
539 Normal return.\n\ | |
540 @item\n\ | |
541 Input error, return @code{NaN}.\n\ | |
542 @item\n\ | |
543 Overflow, return @code{Inf}.\n\ | |
544 @item\n\ | |
545 Loss of significance by argument reduction results in less than half\n\ | |
546 of machine accuracy.\n\ | |
547 @item\n\ | |
548 Complete loss of significance by argument reduction, return @code{NaN}.\n\ | |
549 @item\n\ | |
550 Error---no computation, algorithm termination condition not met,\n\ | |
5448 | 551 return @code{NaN}.\n\ |
3459 | 552 @end enumerate\n\ |
553 @end deftypefn") | |
3155 | 554 { |
3220 | 555 octave_value_list retval; |
556 | |
557 int nargin = args.length (); | |
558 | |
559 if (nargin > 0 && nargin < 4) | |
560 { | |
561 bool scale = (nargin == 3); | |
562 | |
563 int kind = 0; | |
564 | |
565 if (nargin > 1) | |
566 { | |
5760 | 567 kind = args(0).int_value (); |
3220 | 568 |
569 if (! error_state) | |
570 { | |
571 if (kind < 0 || kind > 3) | |
572 error ("airy: expecting K = 0, 1, 2, or 3"); | |
573 } | |
574 else | |
575 error ("airy: expecting integer value for K"); | |
576 } | |
577 | |
578 if (! error_state) | |
579 { | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
580 int idx = nargin == 1 ? 0 : 1; |
3220 | 581 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
582 if (args (idx).is_single_type ()) |
3220 | 583 { |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
584 FloatComplexNDArray z = args(idx).float_complex_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
585 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
586 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
587 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
588 ArrayN<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
589 octave_value result; |
3220 | 590 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
591 if (kind > 1) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
592 result = biry (z, kind == 3, scale, ierr); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
593 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
594 result = airy (z, kind == 1, scale, ierr); |
3220 | 595 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
596 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
597 retval(1) = NDArray (ierr); |
3220 | 598 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
599 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
600 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
601 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
602 error ("airy: expecting complex matrix for Z"); |
3220 | 603 } |
604 else | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
605 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
606 ComplexNDArray z = args(idx).complex_array_value (); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
607 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
608 if (! error_state) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
609 { |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
610 ArrayN<octave_idx_type> ierr; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
611 octave_value result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
612 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
613 if (kind > 1) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
614 result = biry (z, kind == 3, scale, ierr); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
615 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
616 result = airy (z, kind == 1, scale, ierr); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
617 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
618 if (nargout > 1) |
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
619 retval(1) = NDArray (ierr); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
620 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
621 retval(0) = result; |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
622 } |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
623 else |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
624 error ("airy: expecting complex matrix for Z"); |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7031
diff
changeset
|
625 } |
3220 | 626 } |
627 } | |
628 else | |
5823 | 629 print_usage (); |
3220 | 630 |
631 return retval; | |
3155 | 632 } |
633 | |
634 /* | |
8278
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
635 %! # Test values computed with GP/PARI version 2.3.3 |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
636 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
637 %!shared alpha, x, jx, yx, ix, kx, nix |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
638 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
639 %! # Bessel functions, even order, positive and negative x |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
640 %! alpha = 2; x = 1.25; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
641 %! jx = 0.1710911312405234823613091417; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
642 %! yx = -1.193199310178553861283790424; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
643 %! ix = 0.2220184483766341752692212604; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
644 %! kx = 0.9410016167388185767085460540; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
645 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
646 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
647 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
648 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
649 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
650 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
651 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
652 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
653 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
654 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
655 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
656 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
657 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
658 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
659 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
660 %!assert(besselj(-alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
661 %!assert(bessely(-alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
662 %!assert(besseli(-alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
663 %!assert(besselk(-alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
664 %!assert(besselh(-alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
665 %!assert(besselh(-alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
666 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
667 %!assert(besselj(-alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
668 %!assert(bessely(-alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
669 %!assert(besseli(-alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
670 %!assert(besselk(-alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
671 %!assert(besselh(-alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
672 %!assert(besselh(-alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
673 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
674 %! x *= -1; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
675 %! yx = -1.193199310178553861283790424 + 0.3421822624810469647226182835*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
676 %! kx = 0.9410016167388185767085460540 - 0.6974915263814386815610060884*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
677 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
678 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
679 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
680 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
681 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
682 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
683 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
684 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
685 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
686 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
687 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
688 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
689 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
690 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
691 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
692 %! # Bessel functions, odd order, positive and negative x |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
693 %! alpha = 3; x = 2.5; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
694 %! jx = 0.2166003910391135247666890035; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
695 %! yx = -0.7560554967536709968379029772; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
696 %! ix = 0.4743704087780355895548240179; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
697 %! kx = 0.2682271463934492027663765197; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
698 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
699 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
700 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
701 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
702 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
703 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
704 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
705 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
706 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
707 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
708 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
709 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
710 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
711 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
712 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
713 %!assert(besselj(-alpha,x), -jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
714 %!assert(bessely(-alpha,x), -yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
715 %!assert(besseli(-alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
716 %!assert(besselk(-alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
717 %!assert(besselh(-alpha,1,x), -(jx + I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
718 %!assert(besselh(-alpha,2,x), -(jx - I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
719 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
720 %!assert(besselj(-alpha,x,1), -jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
721 %!assert(bessely(-alpha,x,1), -yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
722 %!assert(besseli(-alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
723 %!assert(besselk(-alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
724 %!assert(besselh(-alpha,1,x,1), -(jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
725 %!assert(besselh(-alpha,2,x,1), -(jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
726 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
727 %! x *= -1; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
728 %! jx = -jx; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
729 %! yx = 0.7560554967536709968379029772 - 0.4332007820782270495333780070*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
730 %! ix = -ix; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
731 %! kx = -0.2682271463934492027663765197 - 1.490278591297463775542004240*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
732 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
733 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
734 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
735 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
736 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
737 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
738 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
739 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
740 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
741 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
742 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
743 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
744 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
745 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
746 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
747 %! # Bessel functions, fractional order, positive and negative x |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
748 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
749 %! alpha = 3.5; x = 2.75; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
750 %! jx = 0.1691636439842384154644784389; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
751 %! yx = -0.8301381935499356070267953387; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
752 %! ix = 0.3930540878794826310979363668; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
753 %! kx = 0.2844099013460621170288192503; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
754 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
755 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
756 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
757 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
758 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
759 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
760 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
761 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
762 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
763 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
764 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
765 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
766 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
767 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
768 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
769 %! nix = 0.2119931212254662995364461998; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
770 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
771 %!assert(besselj(-alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
772 %!assert(bessely(-alpha,x), -jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
773 %!assert(besseli(-alpha,x), nix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
774 %!assert(besselk(-alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
775 %!assert(besselh(-alpha,1,x), -I*(jx + I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
776 %!assert(besselh(-alpha,2,x), I*(jx - I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
777 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
778 %!assert(besselj(-alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
779 %!assert(bessely(-alpha,x,1), -jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
780 %!assert(besseli(-alpha,x,1), nix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
781 %!assert(besselk(-alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
782 %!assert(besselh(-alpha,1,x,1), -I*(jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
783 %!assert(besselh(-alpha,2,x,1), I*(jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
784 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
785 %! x *= -1; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
786 %! jx *= -I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
787 %! yx = -0.8301381935499356070267953387*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
788 %! ix *= -I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
789 %! kx = -0.9504059335995575096509874508*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
790 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
791 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
792 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
793 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
794 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
795 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
796 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
797 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
798 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
799 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
800 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
801 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
802 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
803 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
804 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
805 %! # Bessel functions, even order, complex x |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
806 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
807 %! alpha = 2; x = 1.25 + 3.625 * I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
808 %! jx = -1.299533366810794494030065917 + 4.370833116012278943267479589*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
809 %! yx = -4.370357232383223896393056727 - 1.283083391453582032688834041*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
810 %! ix = -0.6717801680341515541002273932 - 0.2314623443930774099910228553*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
811 %! kx = -0.01108009888623253515463783379 + 0.2245218229358191588208084197*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
812 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
813 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
814 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
815 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
816 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
817 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
818 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
819 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
820 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
821 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
822 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
823 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
824 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
825 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
826 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
827 %!assert(besselj(-alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
828 %!assert(bessely(-alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
829 %!assert(besseli(-alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
830 %!assert(besselk(-alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
831 %!assert(besselh(-alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
832 %!assert(besselh(-alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
833 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
834 %!assert(besselj(-alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
835 %!assert(bessely(-alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
836 %!assert(besseli(-alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
837 %!assert(besselk(-alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
838 %!assert(besselh(-alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
839 %!assert(besselh(-alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
840 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
841 %! # Bessel functions, odd order, complex x |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
842 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
843 %! alpha = 3; x = 2.5 + 1.875 * I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
844 %! jx = 0.1330721523048277493333458596 + 0.5386295217249660078754395597*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
845 %! yx = -0.6485072392105829901122401551 + 0.2608129289785456797046996987*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
846 %! ix = -0.6182064685486998097516365709 + 0.4677561094683470065767989920*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
847 %! kx = -0.1568585587733540007867882337 - 0.05185853709490846050505141321*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
848 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
849 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
850 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
851 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
852 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
853 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
854 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
855 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
856 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
857 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
858 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
859 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
860 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
861 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
862 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
863 %!assert(besselj(-alpha,x), -jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
864 %!assert(bessely(-alpha,x), -yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
865 %!assert(besseli(-alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
866 %!assert(besselk(-alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
867 %!assert(besselh(-alpha,1,x), -(jx + I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
868 %!assert(besselh(-alpha,2,x), -(jx - I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
869 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
870 %!assert(besselj(-alpha,x,1), -jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
871 %!assert(bessely(-alpha,x,1), -yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
872 %!assert(besseli(-alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
873 %!assert(besselk(-alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
874 %!assert(besselh(-alpha,1,x,1), -(jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
875 %!assert(besselh(-alpha,2,x,1), -(jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
876 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
877 %! # Bessel functions, fractional order, complex x |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
878 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
879 %! alpha = 3.5; x = 1.75 + 4.125 * I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
880 %! jx = -3.018566131370455929707009100 - 0.7585648436793900607704057611*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
881 %! yx = 0.7772278839106298215614791107 - 3.018518722313849782683792010*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
882 %! ix = 0.2100873577220057189038160913 - 0.6551765604618246531254970926*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
883 %! kx = 0.1757147290513239935341488069 + 0.08772348296883849205562558311*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
884 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
885 %!assert(besselj(alpha,x), jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
886 %!assert(bessely(alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
887 %!assert(besseli(alpha,x), ix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
888 %!assert(besselk(alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
889 %!assert(besselh(alpha,1,x), jx + I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
890 %!assert(besselh(alpha,2,x), jx - I*yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
891 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
892 %!assert(besselj(alpha,x,1), jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
893 %!assert(bessely(alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
894 %!assert(besseli(alpha,x,1), ix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
895 %!assert(besselk(alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
896 %!assert(besselh(alpha,1,x,1), (jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
897 %!assert(besselh(alpha,2,x,1), (jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
898 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
899 %! nix = 0.09822388691172060573913739253 - 0.7110230642207380127317227407*I; |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
900 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
901 %!assert(besselj(-alpha,x), yx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
902 %!assert(bessely(-alpha,x), -jx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
903 %!assert(besseli(-alpha,x), nix, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
904 %!assert(besselk(-alpha,x), kx, 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
905 %!assert(besselh(-alpha,1,x), -I*(jx + I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
906 %!assert(besselh(-alpha,2,x), I*(jx - I*yx), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
907 %! |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
908 %!assert(besselj(-alpha,x,1), yx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
909 %!assert(bessely(-alpha,x,1), -jx*exp(-abs(imag(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
910 %!assert(besseli(-alpha,x,1), nix*exp(-abs(real(x))), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
911 %!assert(besselk(-alpha,x,1), kx*exp(x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
912 %!assert(besselh(-alpha,1,x,1), -I*(jx + I*yx)*exp(-I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
913 %!assert(besselh(-alpha,2,x,1), I*(jx - I*yx)*exp(I*x), 100*eps) |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
914 */ |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
915 |
ab0674a8b345
fix scaling factor for negative alpha in zbesi,cbesi
Brian Gough <bjg@gnu.org>
parents:
7919
diff
changeset
|
916 /* |
3155 | 917 ;;; Local Variables: *** |
918 ;;; mode: C++ *** | |
919 ;;; End: *** | |
920 */ |