Mercurial > octave

comparison libinterp/corefcn/besselj.cc @ 30896:c9788d7f6e65

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: Use "fcn" as preferred abbreviation for "function" in libinterp/. * __eigs__.cc, bsxfun.cc, cellfun.cc, daspk.cc, dasrt.cc, dassl.cc, data.cc, debug.cc, error.cc, graphics.cc, graphics.in.h, gzfstream.h, ls-hdf5.cc, lsode.cc, max.cc, oct-opengl.h, quad.cc, strfns.cc, utils.cc, utils.h, variables.cc, __ode15__.cc, gzip.cc, cdef-manager.cc, ov-fcn-handle.cc, ov-java.cc, ov-usr-fcn.cc, bp-table.cc, bp-table.h, lex.h, lex.ll, oct-parse.yy, pt-eval.cc: Replace "func", "fun", "fn" in documentation and variable names with "fcn".
author Rik <rik@octave.org>
date Tue, 05 Apr 2022 08:33:58 -0700
parents 796f54d4ddbf
children 85a67c1a5712
comparison
equal deleted inserted replaced
30895:360d330cc30e 30896:c9788d7f6e65
81 } \ 81 } \
82 } \ 82 } \
83 while (0) 83 while (0)
84 84
85 octave_value_list 85 octave_value_list
86 do_bessel (enum bessel_type type, const char *fn, 86 do_bessel (enum bessel_type type, const char *fcn,
87 const octave_value_list& args, int nargout) 87 const octave_value_list& args, int nargout)
88 { 88 {
89 int nargin = args.length (); 89 int nargin = args.length ();
90 90
91 if (nargin < 2 || nargin > 3) 91 if (nargin < 2 || nargin > 3)
110 } 110 }
111 else if (opt_arg.islogical ()) 111 else if (opt_arg.islogical ())
112 scaled = opt_arg.bool_value (); 112 scaled = opt_arg.bool_value ();
113 113
114 if (rpt_error) 114 if (rpt_error)
115 error ("%s: OPT must be 0 (or false) or 1 (or true)", fn); 115 error ("%s: OPT must be 0 (or false) or 1 (or true)", fcn);
116 } 116 }
117 117
118 octave_value alpha_arg = args(0); 118 octave_value alpha_arg = args(0);
119 octave_value x_arg = args(1); 119 octave_value x_arg = args(1);
120 120
121 if (alpha_arg.is_single_type () || x_arg.is_single_type ()) 121 if (alpha_arg.is_single_type () || x_arg.is_single_type ())
122 { 122 {
123 if (alpha_arg.is_scalar_type ()) 123 if (alpha_arg.is_scalar_type ())
124 { 124 {
125 float alpha = args(0).xfloat_value ("%s: ALPHA must be a scalar or matrix", fn); 125 float alpha = args(0).xfloat_value ("%s: ALPHA must be a scalar or matrix", fcn);
126 126
127 if (x_arg.is_scalar_type ()) 127 if (x_arg.is_scalar_type ())
128 { 128 {
129 FloatComplex x = x_arg.xfloat_complex_value ("%s: X must be a scalar or matrix", fn); 129 FloatComplex x = x_arg.xfloat_complex_value ("%s: X must be a scalar or matrix", fcn);
130 130
131 octave_idx_type ierr; 131 octave_idx_type ierr;
132 octave_value result; 132 octave_value result;
133 133
134 DO_BESSEL (type, alpha, x, scaled, ierr, result); 134 DO_BESSEL (type, alpha, x, scaled, ierr, result);
137 if (nargout > 1) 137 if (nargout > 1)
138 retval(1) = static_cast<float> (ierr); 138 retval(1) = static_cast<float> (ierr);
139 } 139 }
140 else 140 else
141 { 141 {
142 FloatComplexNDArray x = x_arg.xfloat_complex_array_value ("%s: X must be a scalar or matrix", fn); 142 FloatComplexNDArray x = x_arg.xfloat_complex_array_value ("%s: X must be a scalar or matrix", fcn);
143 143
144 Array<octave_idx_type> ierr; 144 Array<octave_idx_type> ierr;
145 octave_value result; 145 octave_value result;
146 146
147 DO_BESSEL (type, alpha, x, scaled, ierr, result); 147 DO_BESSEL (type, alpha, x, scaled, ierr, result);
159 bool args0_is_row_vector = (dv0(1) == dv0.numel ()); 159 bool args0_is_row_vector = (dv0(1) == dv0.numel ());
160 bool args1_is_col_vector = (dv1(0) == dv1.numel ()); 160 bool args1_is_col_vector = (dv1(0) == dv1.numel ());
161 161
162 if (args0_is_row_vector && args1_is_col_vector) 162 if (args0_is_row_vector && args1_is_col_vector)
163 { 163 {
164 FloatRowVector ralpha = args(0).xfloat_row_vector_value ("%s: ALPHA must be a scalar or matrix", fn); 164 FloatRowVector ralpha = args(0).xfloat_row_vector_value ("%s: ALPHA must be a scalar or matrix", fcn);
165 165
166 FloatComplexColumnVector cx 166 FloatComplexColumnVector cx
167 = x_arg.xfloat_complex_column_vector_value ("%s: X must be a scalar or matrix", fn); 167 = x_arg.xfloat_complex_column_vector_value ("%s: X must be a scalar or matrix", fcn);
168 168
169 Array<octave_idx_type> ierr; 169 Array<octave_idx_type> ierr;
170 octave_value result; 170 octave_value result;
171 171
172 DO_BESSEL (type, ralpha, cx, scaled, ierr, result); 172 DO_BESSEL (type, ralpha, cx, scaled, ierr, result);
175 if (nargout > 1) 175 if (nargout > 1)
176 retval(1) = NDArray (ierr); 176 retval(1) = NDArray (ierr);
177 } 177 }
178 else 178 else
179 { 179 {
180 FloatNDArray alpha = args(0).xfloat_array_value ("%s: ALPHA must be a scalar or matrix", fn); 180 FloatNDArray alpha = args(0).xfloat_array_value ("%s: ALPHA must be a scalar or matrix", fcn);
181 181
182 if (x_arg.is_scalar_type ()) 182 if (x_arg.is_scalar_type ())
183 { 183 {
184 FloatComplex x = x_arg.xfloat_complex_value ("%s: X must be a scalar or matrix", fn); 184 FloatComplex x = x_arg.xfloat_complex_value ("%s: X must be a scalar or matrix", fcn);
185 185
186 Array<octave_idx_type> ierr; 186 Array<octave_idx_type> ierr;
187 octave_value result; 187 octave_value result;
188 188
189 DO_BESSEL (type, alpha, x, scaled, ierr, result); 189 DO_BESSEL (type, alpha, x, scaled, ierr, result);
192 if (nargout > 1) 192 if (nargout > 1)
193 retval(1) = NDArray (ierr); 193 retval(1) = NDArray (ierr);
194 } 194 }
195 else 195 else
196 { 196 {
197 FloatComplexNDArray x = x_arg.xfloat_complex_array_value ("%s: X must be a scalar or matrix", fn); 197 FloatComplexNDArray x = x_arg.xfloat_complex_array_value ("%s: X must be a scalar or matrix", fcn);
198 198
199 Array<octave_idx_type> ierr; 199 Array<octave_idx_type> ierr;
200 octave_value result; 200 octave_value result;
201 201
202 DO_BESSEL (type, alpha, x, scaled, ierr, result); 202 DO_BESSEL (type, alpha, x, scaled, ierr, result);
210 } 210 }
211 else 211 else
212 { 212 {
213 if (alpha_arg.is_scalar_type ()) 213 if (alpha_arg.is_scalar_type ())
214 { 214 {
215 double alpha = args(0).xdouble_value ("%s: ALPHA must be a scalar or matrix", fn); 215 double alpha = args(0).xdouble_value ("%s: ALPHA must be a scalar or matrix", fcn);
216 216
217 if (x_arg.is_scalar_type ()) 217 if (x_arg.is_scalar_type ())
218 { 218 {
219 Complex x = x_arg.xcomplex_value ("%s: X must be a scalar or matrix", fn); 219 Complex x = x_arg.xcomplex_value ("%s: X must be a scalar or matrix", fcn);
220 220
221 octave_idx_type ierr; 221 octave_idx_type ierr;
222 octave_value result; 222 octave_value result;
223 223
224 DO_BESSEL (type, alpha, x, scaled, ierr, result); 224 DO_BESSEL (type, alpha, x, scaled, ierr, result);
227 if (nargout > 1) 227 if (nargout > 1)
228 retval(1) = static_cast<double> (ierr); 228 retval(1) = static_cast<double> (ierr);
229 } 229 }
230 else 230 else
231 { 231 {
232 ComplexNDArray x = x_arg.xcomplex_array_value ("%s: X must be a scalar or matrix", fn); 232 ComplexNDArray x = x_arg.xcomplex_array_value ("%s: X must be a scalar or matrix", fcn);
233 233
234 Array<octave_idx_type> ierr; 234 Array<octave_idx_type> ierr;
235 octave_value result; 235 octave_value result;
236 236
237 DO_BESSEL (type, alpha, x, scaled, ierr, result); 237 DO_BESSEL (type, alpha, x, scaled, ierr, result);
249 bool args0_is_row_vector = (dv0(1) == dv0.numel ()); 249 bool args0_is_row_vector = (dv0(1) == dv0.numel ());
250 bool args1_is_col_vector = (dv1(0) == dv1.numel ()); 250 bool args1_is_col_vector = (dv1(0) == dv1.numel ());
251 251
252 if (args0_is_row_vector && args1_is_col_vector) 252 if (args0_is_row_vector && args1_is_col_vector)
253 { 253 {
254 RowVector ralpha = args(0).xrow_vector_value ("%s: ALPHA must be a scalar or matrix", fn); 254 RowVector ralpha = args(0).xrow_vector_value ("%s: ALPHA must be a scalar or matrix", fcn);
255 255
256 ComplexColumnVector cx 256 ComplexColumnVector cx
257 = x_arg.xcomplex_column_vector_value ("%s: X must be a scalar or matrix", fn); 257 = x_arg.xcomplex_column_vector_value ("%s: X must be a scalar or matrix", fcn);
258 258
259 Array<octave_idx_type> ierr; 259 Array<octave_idx_type> ierr;
260 octave_value result; 260 octave_value result;
261 261
262 DO_BESSEL (type, ralpha, cx, scaled, ierr, result); 262 DO_BESSEL (type, ralpha, cx, scaled, ierr, result);
265 if (nargout > 1) 265 if (nargout > 1)
266 retval(1) = NDArray (ierr); 266 retval(1) = NDArray (ierr);
267 } 267 }
268 else 268 else
269 { 269 {
270 NDArray alpha = args(0).xarray_value ("%s: ALPHA must be a scalar or matrix", fn); 270 NDArray alpha = args(0).xarray_value ("%s: ALPHA must be a scalar or matrix", fcn);
271 271
272 if (x_arg.is_scalar_type ()) 272 if (x_arg.is_scalar_type ())
273 { 273 {
274 Complex x = x_arg.xcomplex_value ("%s: X must be a scalar or matrix", fn); 274 Complex x = x_arg.xcomplex_value ("%s: X must be a scalar or matrix", fcn);
275 275
276 Array<octave_idx_type> ierr; 276 Array<octave_idx_type> ierr;
277 octave_value result; 277 octave_value result;
278 278
279 DO_BESSEL (type, alpha, x, scaled, ierr, result); 279 DO_BESSEL (type, alpha, x, scaled, ierr, result);
282 if (nargout > 1) 282 if (nargout > 1)
283 retval(1) = NDArray (ierr); 283 retval(1) = NDArray (ierr);
284 } 284 }
285 else 285 else
286 { 286 {
287 ComplexNDArray x = x_arg.xcomplex_array_value ("%s: X must be a scalar or matrix", fn); 287 ComplexNDArray x = x_arg.xcomplex_array_value ("%s: X must be a scalar or matrix", fcn);
288 288
289 Array<octave_idx_type> ierr; 289 Array<octave_idx_type> ierr;
290 octave_value result; 290 octave_value result;
291 291
292 DO_BESSEL (type, alpha, x, scaled, ierr, result); 292 DO_BESSEL (type, alpha, x, scaled, ierr, result);