Py_complex cbesy_wrap_e( double v, Py_complex z) {
int n = 1;
int kode = 2;
int nz, ierr;
int sign = 1;
Py_complex cy_y, cy_j, cwork;
if (v < 0) {
v = -v;
sign = -1;
}
F_FUNC(zbesy,ZBESY)(CADDR(z), &v, &kode, &n, CADDR(cy_y), &nz, CADDR(cwork), &ierr);
DO_MTHERR("yve:", &cy_y);
if (ierr == 2) {
if (z.real >= 0 && z.imag == 0) {
/* overflow */
cy_y.real = NPY_INFINITY;
cy_y.imag = 0;
}
}
if (sign == -1) {
if (!reflect_jy(&cy_y, v)) {
F_FUNC(zbesj,ZBESJ)(CADDR(z), &v, &kode, &n, CADDR(cy_j), &nz, &ierr);
DO_MTHERR("yv(jv):", &cy_j);
cy_y = rotate_jy(cy_y, cy_j, -v);
}
}
return cy_y;
}
Py_complex cbesj_wrap( double v, Py_complex z) {
int n = 1;
int kode = 1;
int nz, ierr;
int sign = 1;
Py_complex cy_j, cy_y, cwork;
if (v < 0) {
v = -v;
sign = -1;
}
F_FUNC(zbesj,ZBESJ)(CADDR(z), &v, &kode, &n, CADDR(cy_j), &nz, &ierr);
DO_MTHERR("jv:", &cy_j);
if (ierr == 2) {
/* overflow */
cy_j = cbesj_wrap_e(v, z);
cy_j.real *= NPY_INFINITY;
cy_j.imag *= NPY_INFINITY;
}
if (sign == -1) {
if (!reflect_jy(&cy_j, v)) {
F_FUNC(zbesy,ZBESY)(CADDR(z), &v, &kode, &n, CADDR(cy_y), &nz, CADDR(cwork), &ierr);
DO_MTHERR("jv(yv):", &cy_y);
cy_j = rotate_jy(cy_j, cy_y, v);
}
}
return cy_j;
}
Py_complex cbesi_wrap_e( double v, Py_complex z) {
int n = 1;
int kode = 2;
int sign = 1;
int nz, ierr;
Py_complex cy, cy_k;
if (v < 0) {
v = -v;
sign = -1;
}
F_FUNC(zbesi,ZBESI)(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("ive:", &cy);
if (sign == -1) {
if (!reflect_i(&cy, v)) {
F_FUNC(zbesk,ZBESK)(CADDR(z), &v, &kode, &n, CADDR(cy_k), &nz, &ierr);
DO_MTHERR("ive(kv):", &cy_k);
/* adjust scaling to match zbesi */
cy_k = rotate(cy_k, -z.imag/NPY_PI);
if (z.real > 0) {
cy_k.real *= exp(-2*z.real);
cy_k.imag *= exp(-2*z.real);
}
/* v -> -v */
cy = rotate_i(cy, cy_k, v);
}
}
return cy;
}
int cairy_wrap_e_real(double z, double *ai, double *aip, double *bi, double *bip) {
int id = 0;
int kode = 2; /* Exponential scaling */
int nz, ierr;
Py_complex cz, cai, caip, cbi, cbip;
cz.real = z;
cz.imag = 0;
if (z < 0) {
*ai = NPY_NAN;
} else {
F_FUNC(zairy,ZAIRY)(CADDR(cz), &id, &kode, CADDR(cai), &nz, &ierr);
DO_MTHERR("airye:", &cai);
*ai = cai.real;
}
nz = 0;
F_FUNC(zbiry,ZBIRY)(CADDR(cz), &id, &kode, CADDR(cbi), &ierr);
DO_MTHERR("airye:", &cbi);
*bi = cbi.real;
id = 1;
if (z < 0) {
*aip = NPY_NAN;
} else {
F_FUNC(zairy,ZAIRY)(CADDR(cz), &id, &kode, CADDR(caip), &nz, &ierr);
DO_MTHERR("airye:", &caip);
*aip = caip.real;
}
nz = 0;
F_FUNC(zbiry,ZBIRY)(CADDR(cz), &id, &kode, CADDR(cbip), &ierr);
DO_MTHERR("airye:", &cbip);
*bip = cbip.real;
return 0;
}
int cairy_wrap_e(Py_complex z, Py_complex *ai, Py_complex *aip, Py_complex *bi, Py_complex *bip) {
int id = 0;
int kode = 2; /* Exponential scaling */
int nz, ierr;
F_FUNC(zairy,ZAIRY)(CADDR(z), &id, &kode, F2C_CST(ai), &nz, &ierr);
DO_MTHERR("airye:", ai);
nz = 0;
F_FUNC(zbiry,ZBIRY)(CADDR(z), &id, &kode, F2C_CST(bi), &ierr);
DO_MTHERR("airye:", bi);
id = 1;
F_FUNC(zairy,ZAIRY)(CADDR(z), &id, &kode, F2C_CST(aip), &nz, &ierr);
DO_MTHERR("airye:", aip);
nz = 0;
F_FUNC(zbiry,ZBIRY)(CADDR(z), &id, &kode, F2C_CST(bip), &ierr);
DO_MTHERR("airye:", bip);
return 0;
}
/**
* Modified Bessel function of the third kind
* multiplied by exp(x)
*
* @param x a real number
* @param v a real number, the order of the Bessel function
*
*/
double pnl_bessel_k_scaled( double v, double x )
{
int nz, ierr;
dcomplex cy, z = Complex (x, 0.);
int n = 1;
int kode = 2;
double nu = fabs (v);
pnl_zbesk(CADDR(z), &nu, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("kve:");
return cy.r;
}
/**
* Complex Modified Bessel function of the third kind
* multiplied by exp(z)
*
* @param z a complex number
* @param v a real number, the order of the Bessel function
*
*/
dcomplex pnl_complex_bessel_k_scaled( double v, dcomplex z )
{
int nz, ierr;
dcomplex cy;
int n = 1;
int kode = 2;
double nu = fabs (v);
pnl_zbesk(CADDR(z), &nu, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("kve:");
return cy;
}
int cairy_wrap(Py_complex z, Py_complex *ai, Py_complex *aip, Py_complex *bi, Py_complex *bip) {
int id = 0;
int ierr = 0;
int kode = 1;
int nz;
F_FUNC(zairy,ZAIRY)(CADDR(z), &id, &kode, F2C_CST(ai), &nz, &ierr);
DO_MTHERR("airy:", ai);
nz = 0;
F_FUNC(zbiry,ZBIRY)(CADDR(z), &id, &kode, F2C_CST(bi), &ierr);
DO_MTHERR("airy:", bi);
id = 1;
F_FUNC(zairy,ZAIRY)(CADDR(z), &id, &kode, F2C_CST(aip), &nz, &ierr);
DO_MTHERR("airy:", aip);
nz = 0;
F_FUNC(zbiry,ZBIRY)(CADDR(z), &id, &kode, F2C_CST(bip), &ierr);
DO_MTHERR("airy:", bip);
return 0;
}
Py_complex cbesj_wrap_e( double v, Py_complex z) {
int n = 1;
int kode = 2;
int nz, ierr;
int sign = 1;
Py_complex cy_j, cy_y, cwork;
if (v < 0) {
v = -v;
sign = -1;
}
F_FUNC(zbesj,ZBESJ)(CADDR(z), &v, &kode, &n, CADDR(cy_j), &nz, &ierr);
DO_MTHERR("jve:", &cy_j);
if (sign == -1) {
if (!reflect_jy(&cy_j, v)) {
F_FUNC(zbesy,ZBESY)(CADDR(z), &v, &kode, &n, CADDR(cy_y), &nz, CADDR(cwork), &ierr);
DO_MTHERR("jve(yve):", &cy_y);
cy_j = rotate_jy(cy_j, cy_y, v);
}
}
return cy_j;
}
Py_complex cbesi_wrap( double v, Py_complex z) {
int n = 1;
int kode = 1;
int sign = 1;
int nz, ierr;
Py_complex cy, cy_k;
if (v < 0) {
v = -v;
sign = -1;
}
F_FUNC(zbesi,ZBESI)(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("iv:", &cy);
if (ierr == 2) {
/* overflow */
if (z.imag == 0 && (z.real >= 0 || v == floor(v))) {
if (z.real < 0 && v/2 != floor(v/2))
cy.real = -NPY_INFINITY;
else
cy.real = NPY_INFINITY;
cy.imag = 0;
} else {
cy = cbesi_wrap_e(v*sign, z);
cy.real *= NPY_INFINITY;
cy.imag *= NPY_INFINITY;
}
}
if (sign == -1) {
if (!reflect_i(&cy, v)) {
F_FUNC(zbesk,ZBESK)(CADDR(z), &v, &kode, &n, CADDR(cy_k), &nz, &ierr);
DO_MTHERR("iv(kv):", &cy_k);
cy = rotate_i(cy, cy_k, v);
}
}
return cy;
}
/**
* Complex Hankel function of the second kind
* multiplied by Cexp( I * z)
*
* @param z a complex number
* @param v a real number, the order of the Bessel function
*
*/
dcomplex pnl_complex_bessel_h2_scaled( double v, dcomplex z )
{
int nz, ierr;
dcomplex cy;
int n = 1, kode = 2, m = 2;
if (v >= 0)
{
pnl_zbesh(CADDR(z), &v, &kode, &m, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("hankel2e:");
}
else
{
cy = pnl_complex_bessel_h2_scaled (-v, z );
cy = Cmul (cy, CIexp (M_PI * v) );
}
return cy;
}
Py_complex cbesh_wrap2_e( double v, Py_complex z) {
int n = 1;
int kode = 2;
int m = 2;
int nz, ierr;
int sign = 1;
Py_complex cy;
if (v < 0) {
v = -v;
sign = -1;
}
F_FUNC(zbesh,ZBESH)(CADDR(z), &v, &kode, &m, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("hankel2e:", &cy);
if (sign == -1) {
cy = rotate(cy, -v);
}
return cy;
}
/**
* Hankel function of the second kind
* multiplied by Cexp( I * x)
*
* @param x a real number
* @param v a real number, the order of the Bessel function
*
*/
dcomplex pnl_bessel_h2_scaled( double v, double x )
{
int nz, ierr;
dcomplex cy, z = Complex (x, 0.);
int n = 1;
int kode = 2;
int m = 2;
if (v >= 0)
{
pnl_zbesh(CADDR(z), &v, &kode, &m, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("hankel2:");
}
else
{
cy = pnl_bessel_h2_scaled (-v, x );
cy = Cmul (cy, CIexp (M_PI * v) );
}
return cy;
}
/**
* Bessel function of the first kind
* same as pnl_bessel_j
*
* @param x a real number
* @param v a real number, the order of the Bessel function
*
*/
double pnl_bessel_j_scaled ( double v, double x )
{
int nz, ierr;
dcomplex cy, z = Complex (x, 0.);
int n = 1, kode = 2;
if (v >= 0)
{
pnl_zbesj(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("jv:");
return cy.r;
}
else
{
double aux1, aux2;
aux1 = cos (M_PI * v) * pnl_bessel_j_scaled (-v, x);
aux2 = sin (M_PI * v) * pnl_bessel_y_scaled (-v, x);
return aux1 +aux2;
}
}
/**
* Modified Bessel function of the first kind
* divided by exp(|x|)
*
* @param x a real number
* @param v a real number, the order of the Bessel function
*
*/
double pnl_bessel_i_scaled( double v, double x )
{
int nz, ierr;
dcomplex cy, z = Complex (x, 0.);
int n = 1, kode = 2;
if (v >= 0)
{
pnl_zbesi(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("ive:");
return cy.r;
}
else
{
double aux1, aux2;
aux1 = pnl_bessel_i_scaled (-v, x);
aux2 = M_2_PI * sin (M_PI * -v) * pnl_bessel_k (-v, x) * exp(-fabs(x));
return aux1 + aux2;
}
}
/**
* Bessel function of the second kind
*
* @param x a real number
* @param v a real number, the order of the Bessel function
*
*/
double pnl_bessel_y( double v, double x )
{
int nz, ierr;
dcomplex cy, z, cwork;
int n = 1, kode = 1;
z = Complex (x, 0.);
if (v >= 0)
{
pnl_zbesy(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, CADDR(cwork), &ierr);
DO_MTHERR("yv:");
return cy.r;
}
else
{
double aux1, aux2;
aux1 = cos (M_PI * v) * pnl_bessel_y (-v, x);
aux2 = sin (M_PI * -v) * pnl_bessel_j (-v, x);
return aux1 +aux2;
}
}
/**
* Complex Modified Bessel function of the first kind
* divided by exp(|Creal(z)|)
*
* @param z a complex number
* @param v a real number, the order of the Bessel function
*
*/
dcomplex pnl_complex_bessel_i_scaled( double v, dcomplex z )
{
int nz, ierr;
dcomplex cy;
int n = 1;
int kode = 2;
if (v >= 0)
{
pnl_zbesi(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("ive:");
}
else
{
dcomplex aux1, aux2;
aux1 = pnl_complex_bessel_i_scaled (-v, z);
aux2 = pnl_complex_bessel_k (-v, z);
aux2 = CRmul (aux2, M_2_PI * sin(M_PI * -v) * exp ( -fabs ( Creal(z) ) ));
cy = Cadd (aux1, aux2);
}
return cy;
}
Py_complex cbesk_wrap_e( double v, Py_complex z) {
int n = 1;
int kode = 2;
int nz, ierr;
Py_complex cy;
if (v < 0) {
/* K_v == K_{-v} even for non-integer v */
v = -v;
}
F_FUNC(zbesk,ZBESK)(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("kve:", &cy);
if (ierr == 2) {
if (z.real >= 0 && z.imag == 0) {
/* overflow */
cy.real = NPY_INFINITY;
cy.imag = 0;
}
}
return cy;
}
/**
* Complex Bessel function of the first kind
*
* @param z a complex number
* @param v a real number, the order of the Bessel function
*
*/
dcomplex pnl_complex_bessel_j( double v, dcomplex z )
{
int nz, ierr;
dcomplex cy;
int n = 1;
int kode = 1;
if (v >= 0)
{
pnl_zbesj(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, &ierr);
DO_MTHERR("jv:");
}
else
{
dcomplex aux1, aux2;
aux1 = pnl_complex_bessel_j (-v, z);
aux1 = CRmul (aux1, cos(M_PI * v));
aux2 = pnl_complex_bessel_y (-v, z);
aux2 = CRmul (aux2, sin(M_PI * v));
cy = Cadd (aux1, aux2);
}
return cy;
}
/**
* Complex Bessel function of the second kind
* divided by exp(|Imag(z)|)
*
* @param z a complex number
* @param v a real number, the order of the Bessel function
*
*/
dcomplex pnl_complex_bessel_y_scaled( double v, dcomplex z )
{
int nz, ierr;
dcomplex cy, cwork;
int n = 1;
int kode = 2;
if (v >= 0)
{
pnl_zbesy(CADDR(z), &v, &kode, &n, CADDR(cy), &nz, CADDR(cwork), &ierr);
DO_MTHERR("yve:");
}
else
{
dcomplex aux1, aux2;
aux1 = pnl_complex_bessel_y_scaled (-v, z);
aux1 = CRmul (aux1, cos(M_PI * v));
aux2 = pnl_complex_bessel_j_scaled (-v, z);
aux2 = CRmul (aux2, sin(M_PI * -v));
cy = Cadd (aux1, aux2);
}
return cy;
}
