27 #if defined (HAVE_CONFIG_H) 137 double zr = z.real ();
138 double zi = z.imag ();
149 Complex expz = exp (- 2.0 / 3.0 * z * sqrt (z));
151 double rexpz = expz.real ();
152 double iexpz = expz.imag ();
154 double tmp =
ar*rexpz - ai*iexpz;
156 ai =
ar*iexpz + ai*rexpz;
160 if (zi == 0.0 && (! scaled || zr >= 0.0))
214 float ar =
a.real ();
215 float ai =
a.imag ();
221 float rexpz = expz.real ();
222 float iexpz = expz.imag ();
224 float tmp =
ar*rexpz - ai*iexpz;
226 ai =
ar*iexpz + ai*rexpz;
230 if (z.imag () == 0.0 && (! scaled || z.real () >= 0.0))
273 return x ==
static_cast<double> (
static_cast<long> (
x));
306 double zr = z.
real ();
307 double zi = z.
imag ();
313 if (zi == 0.0 && zr >= 0.0)
323 if ((static_cast<long> (alpha)) & 1)
335 tmp -= sin (M_PI * alpha) *
zbesy (z, alpha, kode,
ierr);
361 double zr = z.real ();
362 double zi = z.imag ();
366 if (zr == 0.0 && zi == 0.0)
378 if (zi == 0.0 && zr >= 0.0)
389 if ((static_cast<long> (alpha - 0.5)) & 1)
401 tmp += sin (M_PI * alpha) *
zbesj (z, alpha, kode,
ierr);
425 double zr = z.
real ();
426 double zi = z.
imag ();
432 if (zi == 0.0 && zr >= 0.0)
452 Complex tmp2 = (2.0 / M_PI) * sin (M_PI * alpha)
458 tmp2 *= exp (-z -
std::abs (z.real ()));
485 double zr = z.
real ();
486 double zi = z.
imag ();
490 if (zr == 0.0 && zi == 0.0)
502 if (zi == 0.0 && zr >= 0.0)
530 double zr = z.
real ();
531 double zi = z.
imag ();
533 F77_FUNC (zbesh,
ZBESH) (zr, zi, alpha, kode, 1, 1, &yr, &yi, nz,
566 double zr = z.
real ();
567 double zi = z.
imag ();
569 F77_FUNC (zbesh,
ZBESH) (zr, zi, alpha, kode, 2, 1, &yr, &yi, nz,
651 if (x_nr != alpha_nr || x_nc != alpha_nc)
652 (*current_liboctave_error_handler)
653 (
"%s: the sizes of alpha and x must conform", fn);
710 (
"%s: the sizes of alpha and x must conform", fn);
742 #define SS_BESSEL(name, fcn) \ 744 name (double alpha, const Complex& x, bool scaled, octave_idx_type& ierr) \ 746 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 749 #define SM_BESSEL(name, fcn) \ 751 name (double alpha, const ComplexMatrix& x, bool scaled, \ 752 Array<octave_idx_type>& ierr) \ 754 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 757 #define MS_BESSEL(name, fcn) \ 759 name (const Matrix& alpha, const Complex& x, bool scaled, \ 760 Array<octave_idx_type>& ierr) \ 762 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 765 #define MM_BESSEL(name, fcn) \ 767 name (const Matrix& alpha, const ComplexMatrix& x, bool scaled, \ 768 Array<octave_idx_type>& ierr) \ 770 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 773 #define SN_BESSEL(name, fcn) \ 775 name (double alpha, const ComplexNDArray& x, bool scaled, \ 776 Array<octave_idx_type>& ierr) \ 778 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 781 #define NS_BESSEL(name, fcn) \ 783 name (const NDArray& alpha, const Complex& x, bool scaled, \ 784 Array<octave_idx_type>& ierr) \ 786 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 789 #define NN_BESSEL(name, fcn) \ 791 name (const NDArray& alpha, const ComplexNDArray& x, bool scaled, \ 792 Array<octave_idx_type>& ierr) \ 794 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 797 #define RC_BESSEL(name, fcn) \ 799 name (const RowVector& alpha, const ComplexColumnVector& x, bool scaled, \ 800 Array<octave_idx_type>& ierr) \ 802 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 805 #define ALL_BESSEL(name, fcn) \ 806 SS_BESSEL (name, fcn) \ 807 SM_BESSEL (name, fcn) \ 808 MS_BESSEL (name, fcn) \ 809 MM_BESSEL (name, fcn) \ 810 SN_BESSEL (name, fcn) \ 811 NS_BESSEL (name, fcn) \ 812 NN_BESSEL (name, fcn) \ 813 RC_BESSEL (name, fcn) 853 return x ==
static_cast<float> (
static_cast<long> (
x));
872 if (z.imag () == 0.0 && z.real () >= 0.0)
882 if ((static_cast<long> (alpha)) & 1)
895 tmp -= sinf (static_cast<float> (M_PI) * alpha)
923 if (z.real () == 0.0 && z.imag () == 0.0)
935 if (z.imag () == 0.0 && z.real () >= 0.0)
946 if ((static_cast<long> (alpha - 0.5)) & 1)
959 tmp += sinf (static_cast<float> (M_PI) * alpha)
988 if (z.imag () == 0.0 && z.real () >= 0.0)
1002 * sinf (static_cast<float> (M_PI) * alpha)
1008 tmp2 *= exp (-z -
std::abs (z.real ()));
1036 if (z.real () == 0.0 && z.imag () == 0.0)
1047 if (z.imag () == 0.0 && z.real () >= 0.0)
1193 if (x_nr != alpha_nr || x_nc != alpha_nc)
1194 (*current_liboctave_error_handler)
1195 (
"%s: the sizes of alpha and x must conform", fn);
1253 (
"%s: the sizes of alpha and x must conform", fn);
1285 #define SS_BESSEL(name, fcn) \ 1287 name (float alpha, const FloatComplex& x, bool scaled, \ 1288 octave_idx_type& ierr) \ 1290 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1293 #define SM_BESSEL(name, fcn) \ 1294 FloatComplexMatrix \ 1295 name (float alpha, const FloatComplexMatrix& x, bool scaled, \ 1296 Array<octave_idx_type>& ierr) \ 1298 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1301 #define MS_BESSEL(name, fcn) \ 1302 FloatComplexMatrix \ 1303 name (const FloatMatrix& alpha, const FloatComplex& x, bool scaled, \ 1304 Array<octave_idx_type>& ierr) \ 1306 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1309 #define MM_BESSEL(name, fcn) \ 1310 FloatComplexMatrix \ 1311 name (const FloatMatrix& alpha, const FloatComplexMatrix& x, \ 1312 bool scaled, Array<octave_idx_type>& ierr) \ 1314 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1317 #define SN_BESSEL(name, fcn) \ 1318 FloatComplexNDArray \ 1319 name (float alpha, const FloatComplexNDArray& x, bool scaled, \ 1320 Array<octave_idx_type>& ierr) \ 1322 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1325 #define NS_BESSEL(name, fcn) \ 1326 FloatComplexNDArray \ 1327 name (const FloatNDArray& alpha, const FloatComplex& x, \ 1328 bool scaled, Array<octave_idx_type>& ierr) \ 1330 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1333 #define NN_BESSEL(name, fcn) \ 1334 FloatComplexNDArray \ 1335 name (const FloatNDArray& alpha, const FloatComplexNDArray& x, \ 1336 bool scaled, Array<octave_idx_type>& ierr) \ 1338 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1341 #define RC_BESSEL(name, fcn) \ 1342 FloatComplexMatrix \ 1343 name (const FloatRowVector& alpha, \ 1344 const FloatComplexColumnVector& x, bool scaled, \ 1345 Array<octave_idx_type>& ierr) \ 1347 return do_bessel (fcn, #name, alpha, x, scaled, ierr); \ 1350 #define ALL_BESSEL(name, fcn) \ 1351 SS_BESSEL (name, fcn) \ 1352 SM_BESSEL (name, fcn) \ 1353 MS_BESSEL (name, fcn) \ 1354 MM_BESSEL (name, fcn) \ 1355 SN_BESSEL (name, fcn) \ 1356 NS_BESSEL (name, fcn) \ 1357 NN_BESSEL (name, fcn) \ 1358 RC_BESSEL (name, fcn) 1383 double zr = z.real ();
1384 double zi = z.imag ();
1397 double rexpz = expz.real ();
1398 double iexpz = expz.imag ();
1400 double tmp =
ar*rexpz - ai*iexpz;
1402 ai =
ar*iexpz + ai*rexpz;
1406 if (zi == 0.0 && (! scaled || zr >= 0.0))
1460 float ar =
a.real ();
1461 float ai =
a.imag ();
1468 float rexpz = expz.real ();
1469 float iexpz = expz.imag ();
1471 float tmp =
ar*rexpz - ai*iexpz;
1473 ai =
ar*iexpz + ai*rexpz;
1477 if (z.imag () == 0.0 && (! scaled || z.real () >= 0.0))
1537 ellipj (
double u,
double m,
double& sn,
double& cn,
double& dn,
double&
err)
1539 static const int Nmax = 16;
1540 double m1,
t=0, si_u, co_u, se_u, ta_u,
b,
c[Nmax],
a[Nmax], phi;
1545 (*current_liboctave_warning_with_id_handler)
1546 (
"Octave:ellipj-invalid-m",
1547 "ellipj: invalid M value, required value 0 <= M <= 1");
1554 double sqrt_eps = std::sqrt (std::numeric_limits<double>::epsilon ());
1560 t = 0.25*m*(
u - si_u*co_u);
1561 sn = si_u -
t * co_u;
1562 cn = co_u +
t * si_u;
1563 dn = 1 - 0.5*m*si_u*si_u;
1565 else if ((1 - m) < sqrt_eps)
1573 sn = ta_u + 0.25*m1*(si_u*co_u -
u)*se_u*se_u;
1574 cn = se_u - 0.25*m1*(si_u*co_u -
u)*ta_u*se_u;
1575 dn = se_u + 0.25*m1*(si_u*co_u +
u)*ta_u*se_u;
1582 b = std::sqrt (1 - m);
1583 c[0] = std::sqrt (m);
1584 for (n = 1; n < Nmax; ++n)
1586 a[n] = (
a[n - 1] +
b)/2;
1587 c[n] = (
a[n - 1] -
b)/2;
1588 b = std::sqrt (
a[n - 1]*
b);
1589 if (
c[n]/
a[n] < std::numeric_limits<double>::epsilon ())
break;
1597 for (ii = 1; n > 0; ii = ii*2, --n) ;
1599 for (n = Nn; n > 0; --n)
1601 phi = (
std::asin ((
c[n]/
a[n])* sin (phi)) + phi)/2;
1605 dn = std::sqrt (1 - m*sn*sn);
1613 double m1 = 1 - m, ss1, cc1, dd1;
1626 double ss, cc, dd, ddd;
1629 ddd = cc1*cc1 + m*ss*ss*ss1*ss1;
1630 sn =
Complex (ss*dd1/ddd, cc*dd*ss1*cc1/ddd);
1631 cn =
Complex (cc*cc1/ddd, -ss*dd*ss1*dd1/ddd);
1632 dn =
Complex (dd*cc1*dd1/ddd, -m*ss*cc*ss1/ddd);
1674 static const double a[] =
1676 -2.806989788730439e+01, 1.562324844726888e+02,
1677 -1.951109208597547e+02, 9.783370457507161e+01,
1678 -2.168328665628878e+01, 1.772453852905383e+00
1680 static const double b[] =
1682 -5.447609879822406e+01, 1.615858368580409e+02,
1683 -1.556989798598866e+02, 6.680131188771972e+01,
1684 -1.328068155288572e+01
1686 static const double c[] =
1688 -5.504751339936943e-03, -2.279687217114118e-01,
1689 -1.697592457770869e+00, -1.802933168781950e+00,
1690 3.093354679843505e+00, 2.077595676404383e+00
1692 static const double d[] =
1694 7.784695709041462e-03, 3.224671290700398e-01,
1695 2.445134137142996e+00, 3.754408661907416e+00
1698 static const double spi2 = 8.862269254527579e-01;
1699 static const double pbreak_lo = 0.04850;
1700 static const double pbreak_hi = 1.95150;
1704 if (
x >= pbreak_lo &&
x <= pbreak_hi)
1707 const double q = 0.5*(1-
x), r = q*q;
1708 const double yn = (((((
a[0]*r +
a[1])*r +
a[2])*r +
a[3])*r +
a[4])*r +
a[5])*q;
1709 const double yd = ((((
b[0]*r +
b[1])*r +
b[2])*r +
b[3])*r +
b[4])*r + 1.0;
1712 else if (
x > 0.0 &&
x < 2.0)
1715 const double q = (
x < 1
1719 const double yn = ((((
c[0]*q +
c[1])*q +
c[2])*q +
c[3])*q +
c[4])*q +
c[5];
1721 const double yd = (((
d[0]*q +
d[1])*q +
d[2])*q +
d[3])*q + 1.0;
1738 double u = (
erf (
y) - (1-
x)) * spi2 * exp (
y*
y);
1804 static const double a[] =
1806 -2.806989788730439e+01, 1.562324844726888e+02,
1807 -1.951109208597547e+02, 9.783370457507161e+01,
1808 -2.168328665628878e+01, 1.772453852905383e+00
1810 static const double b[] =
1812 -5.447609879822406e+01, 1.615858368580409e+02,
1813 -1.556989798598866e+02, 6.680131188771972e+01,
1814 -1.328068155288572e+01
1816 static const double c[] =
1818 -5.504751339936943e-03, -2.279687217114118e-01,
1819 -1.697592457770869e+00, -1.802933168781950e+00,
1820 3.093354679843505e+00, 2.077595676404383e+00
1822 static const double d[] =
1824 7.784695709041462e-03, 3.224671290700398e-01,
1825 2.445134137142996e+00, 3.754408661907416e+00
1828 static const double spi2 = 8.862269254527579e-01;
1829 static const double pbreak = 0.95150;
1830 double ax = fabs (
x),
y;
1836 const double q = 0.5 *
x, r = q*q;
1837 const double yn = (((((
a[0]*r +
a[1])*r +
a[2])*r +
a[3])*r +
a[4])*r +
a[5])*q;
1838 const double yd = ((((
b[0]*r +
b[1])*r +
b[2])*r +
b[3])*r +
b[4])*r + 1.0;
1844 const double q = std::sqrt (-2*
std::log (0.5*(1-ax)));
1845 const double yn = ((((
c[0]*q +
c[1])*q +
c[2])*q +
c[3])*q +
c[4])*q +
c[5];
1846 const double yd = (((
d[0]*q +
d[1])*q +
d[2])*q +
d[3])*q + 1.0;
1857 double u = (
erf (
y) -
x) * spi2 * exp (
y*
y);
1881 double im =
x.imag ();
1883 double v = sin (im/2);
1900 float im =
x.imag ();
1902 float v = sin (im/2);
1963 double r =
x.real (),
i =
x.imag ();
1965 if (fabs (r) < 0.5 && fabs (
i) < 0.5)
1967 double u = 2*r + r*r +
i*
i;
1982 float r =
x.real (),
i =
x.imag ();
1984 if (fabs (r) < 0.5 && fabs (
i) < 0.5)
1986 float u = 2*r + r*r +
i*
i;
1996 static const double pi = 3.14159265358979323846;
1998 template <
typename T>
2019 template <
typename T>
2027 static const T dg_coeff[10] =
2029 -0.83333333333333333e-1, 0.83333333333333333e-2,
2030 -0.39682539682539683e-2, 0.41666666666666667e-2,
2031 -0.75757575757575758e-2, 0.21092796092796093e-1,
2032 -0.83333333333333333e-1, 0.4432598039215686,
2033 -0.3053954330270122e+1, 0.125318899521531e+2
2036 T overz2 = T (1.0) / (zc * zc);
2041 p += dg_coeff[
k] * overz2k;
2042 p +=
xlog (zc) - T (0.5) / zc;
2046 template <
typename T>
2050 static const double euler_mascheroni =
2051 0.577215664901532860606512090082402431042;
2063 p =
psi (1 - z) - (
pi / tan (
pi * z));
2068 p = - euler_mascheroni;
2076 p += 1.0 / (2 *
k - 1);
2078 p = - euler_mascheroni - 2 *
std::log (2) + 2 * (
p);
2088 const signed char n = 10 - z;
2089 for (
signed char k = n - 1;
k >= 0;
k--)
2103 template <
typename T>
2109 typedef typename std::complex<T>::value_type P;
2114 std::complex<T> dgam (0.0, 0.0);
2116 dgam = std::complex<T> (
psi (z_r), 0.0);
2118 dgam =
psi (P (1.0) - z)- (P (
pi) / tan (P (
pi) * z));
2122 std::complex<T> z_m = z;
2125 unsigned char n = 8 - z_ra;
2126 z_m = z + std::complex<T> (n, 0.0);
2131 std::complex<T> z_p = z + P (n - 1);
2132 for (
unsigned char k = n;
k > 0;
k--, z_p -= 1.0)
2133 dgam -= P (1.0) / z_p;
2152 template <
typename T>
2161 F77_INT n = to_f77_int (n_arg);
2173 F77_INT n = to_f77_int (n_arg);
2180 template <
typename T>
2186 fortran_psifn<T> (z, n, ans,
ierr);
2195 ans = ans / (
std::pow (-1.0, n + 1) /
gamma (
double (n+1)));
2215 #if defined (HAVE_LGAMMA_R) 2217 result = lgamma_r (
x, &sgngam);
2220 int sgngam = signgam;
2234 #if defined (HAVE_LGAMMAF_R) 2236 result = lgammaf_r (
x, &sgngam);
2239 int sgngam = signgam;
2264 #if defined (OCTAVE_USE_DEPRECATED_FUNCTIONS)
octave_idx_type rows(void) const
subroutine ZBESK(ZR, ZI, FNU, KODE, N, CYR, CYI, NZ, IERR)
subroutine CBESH(Z, FNU, KODE, M, N, CY, NZ, IERR)
subroutine ZBESY(ZR, ZI, FNU, KODE, N, CYR, CYI, NZ, CWRKR, CWRKI, IERR)
Complex(* dptr)(const Complex &, double, int, octave_idx_type &)
void fortran_psifn< double >(double z, octave_idx_type n_arg, double &ans, octave_idx_type &ierr)
static FloatComplex cbesh1(const FloatComplex &z, float alpha, int kode, octave_idx_type &ierr)
void fortran_psifn< float >(float z, octave_idx_type n_arg, float &ans, octave_idx_type &ierr)
std::complex< double > erfi(std::complex< double > z, double relerr=0)
identity matrix If supplied two scalar respectively For allows like xample val
F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE * f
FloatComplexMatrix besselh1(const FloatRowVector &alpha, const FloatComplexColumnVector &x, bool scaled, Array< octave_idx_type > &ierr)
static Complex zbesk(const Complex &z, double alpha, int kode, octave_idx_type &ierr)
OCTAVE_NORETURN liboctave_error_handler current_liboctave_error_handler
Complex besselk(double alpha, const Complex &x, bool scaled, octave_idx_type &ierr)
octave_value imag(void) const
Complex rc_lgamma(double x)
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the base of natural logarithms The constant ex $e satisfies the equation log(e)
Complex besselh1(double alpha, const Complex &x, bool scaled, octave_idx_type &ierr)
subroutine ZBESI(ZR, ZI, FNU, KODE, N, CYR, CYI, NZ, IERR)
subroutine CAIRY(Z, ID, KODE, AI, NZ, IERR)
std::complex< T > floor(const std::complex< T > &x)
subroutine ZBESH(ZR, ZI, FNU, KODE, M, N, CYR, CYI, NZ, IERR)
const dim_vector & dims(void) const
Return a const-reference so that dims ()(i) works efficiently.
static T xlog(const T &x)
std::complex< double > Dawson(std::complex< double > z, double relerr=0)
subroutine ZBESJ(ZR, ZI, FNU, KODE, N, CYR, CYI, NZ, IERR)
double lo_ieee_nan_value(void)
octave_value real(void) const
FloatComplexMatrix besselh2(const FloatRowVector &alpha, const FloatComplexColumnVector &x, bool scaled, Array< octave_idx_type > &ierr)
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function t
nd example oindent opens the file binary numeric values will be read assuming they are stored in IEEE format with the least significant bit and then converted to the native representation Opening a file that is already open simply opens it again and returns a separate file id It is not an error to open a file several though writing to the same file through several different file ids may produce unexpected results The possible values of text mode reading and writing automatically converts linefeeds to the appropriate line end character for the you may append a you must also open the file in binary mode The parameter conversions are currently only supported for and permissions will be set to and then everything is written in a single operation This is very efficient and improves performance c
Complex asin(const Complex &x)
#define F77_XFCN(f, F, args)
Complex erfc(const Complex &x)
std::complex< double > erf(std::complex< double > z, double relerr=0)
FloatComplexMatrix besseli(const FloatRowVector &alpha, const FloatComplexColumnVector &x, bool scaled, Array< octave_idx_type > &ierr)
F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE * d
static Complex zbesj(const Complex &z, double alpha, int kode, octave_idx_type &ierr)
#define ALL_BESSEL(name, fcn)
FloatComplexNDArray biry(const FloatComplexNDArray &z, bool deriv, bool scaled, Array< octave_idx_type > &ierr)
octave_idx_type cols(void) const
octave_value resize(const dim_vector &dv, bool fill=false) const
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
subroutine DPSIFN(X, N, KODE, M, ANS, NZ, IERR)
subroutine CBESJ(Z, FNU, KODE, N, CY, NZ, IERR)
Complex expm1(const Complex &x)
Complex besseli(double alpha, const Complex &x, bool scaled, octave_idx_type &ierr)
FloatComplexMatrix besselk(const FloatRowVector &alpha, const FloatComplexColumnVector &x, bool scaled, Array< octave_idx_type > &ierr)
subroutine CBIRY(Z, ID, KODE, BI, IERR)
static double do_erfinv(double x, bool refine)
Complex log1p(const Complex &x)
static FloatComplex cbesk(const FloatComplex &z, float alpha, int kode, octave_idx_type &ierr)
subroutine CBESK(Z, FNU, KODE, N, CY, NZ, IERR)
static void fortran_psifn(T z, octave_idx_type n, T &ans, octave_idx_type &ierr)
std::complex< double > w(std::complex< double > z, double relerr=0)
static Complex zbesi(const Complex &z, double alpha, int kode, octave_idx_type &ierr)
static double do_erfcinv(double x, bool refine)
static Complex zbesh2(const Complex &z, double alpha, int kode, octave_idx_type &ierr)
static Complex bessel_return_value(const Complex &val, octave_idx_type ierr)
static T lanczos_approximation_psi(const T zc)
octave_int< T > pow(const octave_int< T > &a, const octave_int< T > &b)
std::complex< double > erfcx(std::complex< double > z, double relerr=0)
Complex erf(const Complex &x)
F77_RET_T F77_FUNC(xerbla, XERBLA)
With real return the complex result
static FloatComplex cbesy(const FloatComplex &z, float alpha, int kode, octave_idx_type &ierr)
N Dimensional Array with copy-on-write semantics.
static Complex zbesy(const Complex &z, double alpha, int kode, octave_idx_type &ierr)
subroutine CBESI(Z, FNU, KODE, N, CY, NZ, IERR)
static FloatComplex cbesh2(const FloatComplex &z, float alpha, int kode, octave_idx_type &ierr)
subroutine ZBIRY(ZR, ZI, ID, KODE, BIR, BII, IERR)
octave_idx_type numel(int n=0) const
Number of elements that a matrix with this dimensions would have.
octave_f77_int_type F77_INT
static FloatComplex cbesi(const FloatComplex &z, float alpha, int kode, octave_idx_type &ierr)
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the IEEE symbol NaN(Not a Number). NaN is the result of operations which do not produce a well defined 0 result. Common operations which produce a NaN are arithmetic with infinity ex($\infty - \infty$)
FloatComplex(* fptr)(const FloatComplex &, float, int, octave_idx_type &)
bool negative_sign(double x)
subroutine CBESY(Z, FNU, KODE, N, CY, NZ, CWRK, IERR)
static FloatComplex cbesj(const FloatComplex &z, float alpha, int kode, octave_idx_type &ierr)
static Complex zbesh1(const Complex &z, double alpha, int kode, octave_idx_type &ierr)
Complex rc_log1p(double x)
the element is set to zero In other the statement xample y
Complex besselh2(double alpha, const Complex &x, bool scaled, octave_idx_type &ierr)
void ellipj(double u, double m, double &sn, double &cn, double &dn, double &err)
#define F77_CONST_CMPLX_ARG(x)
std::complex< float > FloatComplex
OCTAVE_EXPORT octave_value_list error nd deftypefn *const octave_scalar_map err
Complex airy(const Complex &z, bool deriv, bool scaled, octave_idx_type &ierr)
FloatComplexMatrix besselj(const FloatRowVector &alpha, const FloatComplexColumnVector &x, bool scaled, Array< octave_idx_type > &ierr)
FloatComplexMatrix bessely(const FloatRowVector &alpha, const FloatComplexColumnVector &x, bool scaled, Array< octave_idx_type > &ierr)
std::complex< double > Complex
FloatComplexNDArray airy(const FloatComplexNDArray &z, bool deriv, bool scaled, Array< octave_idx_type > &ierr)
static bool is_integer_value(double x)
octave_idx_type numel(void) const
Number of elements in the array.
ColumnVector real(const ComplexColumnVector &a)
Vector representing the dimensions (size) of an Array.
F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE const F77_INT F77_INT & ierr
subroutine ZAIRY(ZR, ZI, ID, KODE, AIR, AII, NZ, IERR)
subroutine PSIFN(X, N, KODE, M, ANS, NZ, IERR)
F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T const F77_DBLE * x
Complex besselj(double alpha, const Complex &x, bool scaled, octave_idx_type &ierr)
Complex bessely(double alpha, const Complex &x, bool scaled, octave_idx_type &ierr)
static Complex do_bessel(dptr f, const char *, double alpha, const Complex &x, bool scaled, octave_idx_type &ierr)
Complex biry(const Complex &z, bool deriv, bool scaled, octave_idx_type &ierr)
std::complex< double > erfc(std::complex< double > z, double relerr=0)