Remove "and" keywords that crept in during Cython translations

Author: steppi

include/xsf/binom.h

@@ -54,7 +54,7 @@ XSF_HOST_DEVICE inline double binom(double n, double k) {
     }
 
     // general case
-    if (n >= 1E10 * k and k > 0) {
+    if (n >= 1E10 * k && k > 0) {
         // avoid under/overflows intermediate results
         return std::exp(-cephes::lbeta(1 + n - k, 1 + k) - std::log(n + 1));
     }

include/xsf/digamma.h

@@ -163,7 +163,7 @@ XSF_HOST_DEVICE inline std::complex<double> digamma(std::complex<double> z) {
         return detail::digamma_zeta_series(z, detail::digamma_negroot, detail::digamma_negrootval);
     }
 
-    if (z.real() < 0 and std::abs(z.imag()) < smallabsz) {
+    if (z.real() < 0 && std::abs(z.imag()) < smallabsz) {
         /* Reflection formula for digamma. See
          *
          *https://dlmf.nist.gov/5.5#E4

include/xsf/hyp2f1.h

@@ -151,38 +151,38 @@ namespace detail {
 
         if (std::abs(u) >= std::abs(w)) {
             // u has greatest absolute value. Absorb ugh into the others.
-            if (std::abs((v_prime - u_prime) * (v - 0.5)) < 100 * ugh and v > 100) {
+            if (std::abs((v_prime - u_prime) * (v - 0.5)) < 100 * ugh && v > 100) {
                 /* Special case where base is close to 1. Condition taken from
                  * Boost's beta function implementation. */
                 result *= std::exp((v - 0.5) * std::log1p((v_prime - u_prime) / ugh));
             } else {
                 result *= std::pow(vgh / ugh, v - 0.5);
             }
 
-            if (std::abs((u_prime - w_prime) * (w - 0.5)) < 100 * wgh and u > 100) {
+            if (std::abs((u_prime - w_prime) * (w - 0.5)) < 100 * wgh && u > 100) {
                 result *= std::exp((w - 0.5) * std::log1p((u_prime - w_prime) / wgh));
             } else {
                 result *= std::pow(ugh / wgh, w - 0.5);
             }
 
-            if (std::abs((u_prime - x_prime) * (x - 0.5)) < 100 * xgh and u > 100) {
+            if (std::abs((u_prime - x_prime) * (x - 0.5)) < 100 * xgh && u > 100) {
                 result *= std::exp((x - 0.5) * std::log1p((u_prime - x_prime) / xgh));
             } else {
                 result *= std::pow(ugh / xgh, x - 0.5);
             }
         } else {
             // w has greatest absolute value. Absorb wgh into the others.
-            if (std::abs((u_prime - w_prime) * (u - 0.5)) < 100 * wgh and u > 100) {
+            if (std::abs((u_prime - w_prime) * (u - 0.5)) < 100 * wgh && u > 100) {
                 result *= std::exp((u - 0.5) * std::log1p((u_prime - w_prime) / wgh));
             } else {
                 result *= pow(ugh / wgh, u - 0.5);
             }
-            if (std::abs((v_prime - w_prime) * (v - 0.5)) < 100 * wgh and v > 100) {
+            if (std::abs((v_prime - w_prime) * (v - 0.5)) < 100 * wgh && v > 100) {
                 result *= std::exp((v - 0.5) * std::log1p((v_prime - w_prime) / wgh));
             } else {
                 result *= std::pow(vgh / wgh, v - 0.5);
             }
-            if (std::abs((w_prime - x_prime) * (x - 0.5)) < 100 * xgh and x > 100) {
+            if (std::abs((w_prime - x_prime) * (x - 0.5)) < 100 * xgh && x > 100) {
                 result *= std::exp((x - 0.5) * std::log1p((w_prime - x_prime) / xgh));
             } else {
                 result *= std::pow(wgh / xgh, x - 0.5);
@@ -539,7 +539,7 @@ XSF_HOST_DEVICE inline std::complex<double> hyp2f1(double a, double b, double c,
     }
     bool a_neg_int = a == std::trunc(a) && a < 0;
     bool b_neg_int = b == std::trunc(b) && b < 0;
-    bool c_non_pos_int = c == std::trunc(c) and c <= 0;
+    bool c_non_pos_int = c == std::trunc(c) && c <= 0;
     /* Diverges when c is a non-positive integer unless a is an integer with
      * c <= a <= 0 or b is an integer with c <= b <= 0, (or z equals 0 with
      * c != 0) Cases z = 0, a = 0, or b = 0 have already been handled. We follow

include/xsf/loggamma.h

@@ -113,7 +113,7 @@ XSF_HOST_DEVICE inline std::complex<double> loggamma(std::complex<double> z) {
     if (std::isnan(z.real()) || std::isnan(z.imag())) {
         return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
     }
-    if (z.real() <= 0 and z == std::floor(z.real())) {
+    if (z.real() <= 0 && z == std::floor(z.real())) {
         set_error("loggamma", SF_ERROR_SINGULAR, NULL);
         return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
     }