Replace CL_REQUIRE/CL_PROVIDE(cl_prin_globals) with portable code.

[cln.git] / include / cln / real.h

diff --git a/include/cln/real.h b/include/cln/real.h
index f29465f970c917f8cc442a7ee93a5e34138ca969..cfcc631f0706b24d29425812a12ed4d9364e683b 100644 (file)
--- a/include/cln/real.h
+++ b/include/cln/real.h
@@ -17,13 +17,13 @@ CL_DEFINE_AS_CONVERSION(cl_R)
 
 
 // zerop(x) testet, ob (= x 0).
-extern cl_boolean zerop (const cl_R& x);
+extern bool zerop (const cl_R& x);
 
 // minusp(x) testet, ob (< x 0).
-extern cl_boolean minusp (const cl_R& x);
+extern bool minusp (const cl_R& x);
 
 // plusp(x) testet, ob (> x 0).
-extern cl_boolean plusp (const cl_R& x);
+extern bool plusp (const cl_R& x);
 
 
 // R_to_SF(x) wandelt eine reelle Zahl x in ein Short-Float um.
@@ -39,29 +39,29 @@ extern const cl_FF cl_R_to_FF (const cl_R& x);
 extern const cl_DF cl_R_to_DF (const cl_R& x);
 
 // R_to_LF(x,len) wandelt eine reelle Zahl x in ein Long-Float mit len Digits um.
-// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
+// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
 // < ergebnis: (coerce x `(long-float ,len))
 extern const cl_LF cl_R_to_LF (const cl_R& x, uintC len);
 
 // cl_float(x,y) wandelt eine reelle Zahl x in das Float-Format des
-// Floats y um und rundet dabei nötigenfalls.
+// Floats y um und rundet dabei nötigenfalls.
 // > x: eine reelle Zahl
 // > y: ein Float
 // < ergebnis: (float x y)
 extern const cl_F cl_float (const cl_R& x, const cl_F& y);
 
 // cl_float(x,f) wandelt eine reelle Zahl x in das Float-Format f um
-// und rundet dabei nötigenfalls.
+// und rundet dabei nötigenfalls.
 // > x: eine reelle Zahl
 // > f: eine Float-Format-Spezifikation
 // < ergebnis: (float x f)
 extern const cl_F cl_float (const cl_R& x, float_format_t f);
 
 // cl_float(x) wandelt eine reelle Zahl x in ein Float um
-// und rundet dabei nötigenfalls.
+// und rundet dabei nötigenfalls.
 // > x: eine reelle Zahl
 // < ergebnis: (float x)
-// Abhängig von default_float_format.
+// Abhängig von default_float_format.
 extern const cl_F cl_float (const cl_R& x);
 
 
@@ -75,7 +75,7 @@ inline const cl_F operator+ (const cl_R& x, const cl_F& y)
        { return The(cl_F)(x + The(cl_R)(y)); }
 inline const cl_F operator+ (const cl_F& x, const cl_R& y)
        { return The(cl_F)(The(cl_R)(x) + y); }
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R operator+ (const int x, const cl_R& y)
        { return cl_I(x) + y; }
 inline const cl_R operator+ (const unsigned int x, const cl_R& y)
@@ -84,6 +84,16 @@ inline const cl_R operator+ (const long x, const cl_R& y)
        { return cl_I(x) + y; }
 inline const cl_R operator+ (const unsigned long x, const cl_R& y)
        { return cl_I(x) + y; }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator+ (const long long x, const cl_R& y)
+       { return cl_I(x) + y; }
+inline const cl_R operator+ (const unsigned long long x, const cl_R& y)
+       { return cl_I(x) + y; }
+#endif
+inline const cl_F operator+ (const float x, const cl_R& y)
+       { return The(cl_F)(cl_R(x) + y); }
+inline const cl_F operator+ (const double x, const cl_R& y)
+       { return The(cl_F)(cl_R(x) + y); }
 inline const cl_R operator+ (const cl_R& x, const int y)
        { return x + cl_I(y); }
 inline const cl_R operator+ (const cl_R& x, const unsigned int y)
@@ -92,6 +102,16 @@ inline const cl_R operator+ (const cl_R& x, const long y)
        { return x + cl_I(y); }
 inline const cl_R operator+ (const cl_R& x, const unsigned long y)
        { return x + cl_I(y); }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator+ (const cl_R& x, const long long y)
+       { return x + cl_I(y); }
+inline const cl_R operator+ (const cl_R& x, const unsigned long long y)
+       { return x + cl_I(y); }
+#endif
+inline const cl_F operator+ (const cl_R& x, const float y)
+       { return The(cl_F)(x + cl_R(y)); }
+inline const cl_F operator+ (const cl_R& x, const double y)
+       { return The(cl_F)(x + cl_R(y)); }
 
 // Liefert (- x y), wo x und y reelle Zahlen sind.
 extern const cl_R operator- (const cl_R& x, const cl_R& y);
@@ -100,7 +120,7 @@ inline const cl_F operator- (const cl_R& x, const cl_F& y)
        { return The(cl_F)(x - The(cl_R)(y)); }
 inline const cl_F operator- (const cl_F& x, const cl_R& y)
        { return The(cl_F)(The(cl_R)(x) - y); }
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R operator- (const int x, const cl_R& y)
        { return cl_I(x) - y; }
 inline const cl_R operator- (const unsigned int x, const cl_R& y)
@@ -109,6 +129,16 @@ inline const cl_R operator- (const long x, const cl_R& y)
        { return cl_I(x) - y; }
 inline const cl_R operator- (const unsigned long x, const cl_R& y)
        { return cl_I(x) - y; }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator- (const long long x, const cl_R& y)
+       { return cl_I(x) - y; }
+inline const cl_R operator- (const unsigned long long x, const cl_R& y)
+       { return cl_I(x) - y; }
+#endif
+inline const cl_F operator- (const float x, const cl_R& y)
+       { return The(cl_F)(cl_R(x) - y); }
+inline const cl_F operator- (const double x, const cl_R& y)
+       { return The(cl_F)(cl_R(x) - y); }
 inline const cl_R operator- (const cl_R& x, const int y)
        { return x - cl_I(y); }
 inline const cl_R operator- (const cl_R& x, const unsigned int y)
@@ -117,10 +147,20 @@ inline const cl_R operator- (const cl_R& x, const long y)
        { return x - cl_I(y); }
 inline const cl_R operator- (const cl_R& x, const unsigned long y)
        { return x - cl_I(y); }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator- (const cl_R& x, const long long y)
+       { return x - cl_I(y); }
+inline const cl_R operator- (const cl_R& x, const unsigned long long y)
+       { return x - cl_I(y); }
+#endif
+inline const cl_F operator- (const cl_R& x, const float y)
+       { return The(cl_F)(x - cl_R(y)); }
+inline const cl_F operator- (const cl_R& x, const double y)
+       { return The(cl_F)(x - cl_R(y)); }
 
 // Liefert (* x y), wo x und y reelle Zahlen sind.
 extern const cl_R operator* (const cl_R& x, const cl_R& y);
-// Dem C++-Compiler muß man auch das Folgende sagen (wg. `int * cl_F' u.ä.):
+// Dem C++-Compiler muß man auch das Folgende sagen (wg. `int * cl_F' u.ä.):
 inline const cl_R operator* (const int x, const cl_R& y)
        { return cl_I(x) * y; }
 inline const cl_R operator* (const unsigned int x, const cl_R& y)
@@ -129,6 +169,16 @@ inline const cl_R operator* (const long x, const cl_R& y)
        { return cl_I(x) * y; }
 inline const cl_R operator* (const unsigned long x, const cl_R& y)
        { return cl_I(x) * y; }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator* (const long long x, const cl_R& y)
+       { return cl_I(x) * y; }
+inline const cl_R operator* (const unsigned long long x, const cl_R& y)
+       { return cl_I(x) * y; }
+#endif
+inline const cl_R operator* (const float x, const cl_R& y)
+       { return cl_R(x) * y; }
+inline const cl_R operator* (const double x, const cl_R& y)
+       { return cl_R(x) * y; }
 inline const cl_R operator* (const cl_R& x, const int y)
        { return x * cl_I(y); }
 inline const cl_R operator* (const cl_R& x, const unsigned int y)
@@ -137,16 +187,26 @@ inline const cl_R operator* (const cl_R& x, const long y)
        { return x * cl_I(y); }
 inline const cl_R operator* (const cl_R& x, const unsigned long y)
        { return x * cl_I(y); }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator* (const cl_R& x, const long long y)
+       { return x * cl_I(y); }
+inline const cl_R operator* (const cl_R& x, const unsigned long long y)
+       { return x * cl_I(y); }
+#endif
+inline const cl_R operator* (const cl_R& x, const float y)
+       { return x * cl_R(y); }
+inline const cl_R operator* (const cl_R& x, const double y)
+       { return x * cl_R(y); }
 
 // Liefert (* x x), wo x eine reelle Zahl ist.
 extern const cl_R square (const cl_R& x);
 
 // Liefert (/ x y), wo x und y reelle Zahlen sind.
 extern const cl_R operator/ (const cl_R& x, const cl_R& y);
-// Spezialfall: x oder y Float -> Ergebnis Float
+// Spezialfall: x Float -> Ergebnis Float
 inline const cl_F operator/ (const cl_F& x, const cl_R& y)
        { return The(cl_F)(The(cl_R)(x) / y); }
-// Dem C++-Compiler muß man auch das Folgende sagen (wg. `int / cl_F' u.ä.):
+// Dem C++-Compiler muß man auch das Folgende sagen (wg. `int / cl_F' u.ä.):
 inline const cl_R operator/ (const int x, const cl_R& y)
        { return cl_I(x) / y; }
 inline const cl_R operator/ (const unsigned int x, const cl_R& y)
@@ -155,6 +215,16 @@ inline const cl_R operator/ (const long x, const cl_R& y)
        { return cl_I(x) / y; }
 inline const cl_R operator/ (const unsigned long x, const cl_R& y)
        { return cl_I(x) / y; }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator/ (const long long x, const cl_R& y)
+       { return cl_I(x) / y; }
+inline const cl_R operator/ (const unsigned long long x, const cl_R& y)
+       { return cl_I(x) / y; }
+#endif
+inline const cl_F operator/ (const float x, const cl_R& y)
+       { return The(cl_F)(cl_R(x) / y); }
+inline const cl_F operator/ (const double x, const cl_R& y)
+       { return The(cl_F)(cl_R(x) / y); }
 inline const cl_R operator/ (const cl_R& x, const int y)
        { return x / cl_I(y); }
 inline const cl_R operator/ (const cl_R& x, const unsigned int y)
@@ -163,6 +233,16 @@ inline const cl_R operator/ (const cl_R& x, const long y)
        { return x / cl_I(y); }
 inline const cl_R operator/ (const cl_R& x, const unsigned long y)
        { return x / cl_I(y); }
+#ifdef HAVE_LONGLONG
+inline const cl_R operator/ (const cl_R& x, const long long y)
+       { return x / cl_I(y); }
+inline const cl_R operator/ (const cl_R& x, const unsigned long long y)
+       { return x / cl_I(y); }
+#endif
+inline const cl_R operator/ (const cl_R& x, const float y)
+       { return x / cl_R(y); }
+inline const cl_R operator/ (const cl_R& x, const double y)
+       { return x / cl_R(y); }
 
 // Liefert (abs x), wo x eine reelle Zahl ist.
 extern const cl_R abs (const cl_R& x);
@@ -281,8 +361,8 @@ inline const cl_RA rational (const cl_RA& x) { return x; }
 
 
 // equal(x,y) vergleicht zwei reelle Zahlen x und y auf Gleichheit.
-extern cl_boolean equal (const cl_R& x, const cl_R& y);
-// equal_hashcode(x) liefert einen equal-invarianten Hashcode für x.
+extern bool equal (const cl_R& x, const cl_R& y);
+// equal_hashcode(x) liefert einen equal-invarianten Hashcode für x.
 extern uint32 equal_hashcode (const cl_R& x);
 
 // compare(x,y) vergleicht zwei reelle Zahlen x und y.
@@ -340,7 +420,7 @@ extern const cl_R atan (const cl_R& x, const cl_R& y);
 // Spezialfall: y Float -> Ergebnis Float
 inline const cl_F atan (const cl_R& x, const cl_F& y)
        { return The(cl_F)(atan(x,The(cl_R)(y))); }
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R atan (const cl_R& x, const int y)
        { return atan(x,cl_I(y)); }
 inline const cl_R atan (const cl_R& x, const unsigned int y)
@@ -355,7 +435,7 @@ inline const cl_R atan (const cl_R& x, const unsigned long y)
 extern const cl_R atan (const cl_R& x);
 // Spezialfall: x Float -> Ergebnis Float
 inline const cl_F atan (const cl_F& x) { return The(cl_F)(atan(The(cl_R)(x))); }
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R atan (const int x) { return atan(cl_I(x)); }
 inline const cl_R atan (const unsigned int x) { return atan(cl_I(x)); }
 inline const cl_R atan (const long x) { return atan(cl_I(x)); }
@@ -363,7 +443,7 @@ inline const cl_R atan (const unsigned long x) { return atan(cl_I(x)); }
 
 // sin(x) liefert den Sinus (sin x) einer reellen Zahl x.
 extern const cl_R sin (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R sin (const int x) { return sin(cl_I(x)); }
 inline const cl_R sin (const unsigned int x) { return sin(cl_I(x)); }
 inline const cl_R sin (const long x) { return sin(cl_I(x)); }
@@ -371,7 +451,7 @@ inline const cl_R sin (const unsigned long x) { return sin(cl_I(x)); }
 
 // cos(x) liefert den Cosinus (cos x) einer reellen Zahl x.
 extern const cl_R cos (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R cos (const int x) { return cos(cl_I(x)); }
 inline const cl_R cos (const unsigned int x) { return cos(cl_I(x)); }
 inline const cl_R cos (const long x) { return cos(cl_I(x)); }
@@ -382,7 +462,7 @@ extern const cos_sin_t cos_sin (const cl_R& x);
 
 // tan(x) liefert den Tangens (tan x) einer reellen Zahl x.
 extern const cl_R tan (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R tan (const int x) { return tan(cl_I(x)); }
 inline const cl_R tan (const unsigned int x) { return tan(cl_I(x)); }
 inline const cl_R tan (const long x) { return tan(cl_I(x)); }
@@ -390,7 +470,7 @@ inline const cl_R tan (const unsigned long x) { return tan(cl_I(x)); }
 
 // ln(x) liefert zu einer reellen Zahl x>0 die Zahl ln(x).
 extern const cl_R ln (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R ln (const int x) { return ln(cl_I(x)); }
 inline const cl_R ln (const unsigned int x) { return ln(cl_I(x)); }
 inline const cl_R ln (const long x) { return ln(cl_I(x)); }
@@ -403,7 +483,7 @@ extern const cl_R log (const cl_R& a, const cl_R& b);
 
 // exp(x) liefert zu einer reellen Zahl x die Zahl exp(x).
 extern const cl_R exp (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R exp (const int x) { return exp(cl_I(x)); }
 inline const cl_R exp (const unsigned int x) { return exp(cl_I(x)); }
 inline const cl_R exp (const long x) { return exp(cl_I(x)); }
@@ -411,7 +491,7 @@ inline const cl_R exp (const unsigned long x) { return exp(cl_I(x)); }
 
 // sinh(x) liefert zu einer reellen Zahl x die Zahl sinh(x).
 extern const cl_R sinh (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R sinh (const int x) { return sinh(cl_I(x)); }
 inline const cl_R sinh (const unsigned int x) { return sinh(cl_I(x)); }
 inline const cl_R sinh (const long x) { return sinh(cl_I(x)); }
@@ -419,7 +499,7 @@ inline const cl_R sinh (const unsigned long x) { return sinh(cl_I(x)); }
 
 // cosh(x) liefert zu einer reellen Zahl x die Zahl cosh(x).
 extern const cl_R cosh (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R cosh (const int x) { return cosh(cl_I(x)); }
 inline const cl_R cosh (const unsigned int x) { return cosh(cl_I(x)); }
 inline const cl_R cosh (const long x) { return cosh(cl_I(x)); }
@@ -430,7 +510,7 @@ extern const cosh_sinh_t cosh_sinh (const cl_R& x);
 
 // tanh(x) liefert zu einer reellen Zahl x die Zahl tanh(x).
 extern const cl_R tanh (const cl_R& x);
-// Dem C++-Compiler muß man nun auch das Folgende sagen:
+// Dem C++-Compiler muß man nun auch das Folgende sagen:
 inline const cl_R tanh (const int x) { return tanh(cl_I(x)); }
 inline const cl_R tanh (const unsigned int x) { return tanh(cl_I(x)); }
 inline const cl_R tanh (const long x) { return tanh(cl_I(x)); }
@@ -445,7 +525,6 @@ inline const cl_R random_R (const cl_R& n)
        { return random_R(default_random_state,n); }
 
 
-#ifdef WANT_OBFUSCATING_OPERATORS
 // This could be optimized to use in-place operations.
 inline cl_R& operator+= (cl_R& x, const cl_R& y) { return x = x + y; }
 inline cl_F& operator+= (cl_F& x, const cl_R& y) { return x = x + y; }
@@ -455,10 +534,20 @@ inline cl_R& operator+= (cl_R& x, const int y) { return x = x + y; }
 inline cl_R& operator+= (cl_R& x, const unsigned int y) { return x = x + y; }
 inline cl_R& operator+= (cl_R& x, const long y) { return x = x + y; }
 inline cl_R& operator+= (cl_R& x, const unsigned long y) { return x = x + y; }
+#ifdef HAVE_LONGLONG
+inline cl_R& operator+= (cl_R& x, const long long y) { return x = x + y; }
+inline cl_R& operator+= (cl_R& x, const unsigned long long y) { return x = x + y; }
+#endif
+inline cl_F& operator+= (cl_R& x, const float y) { return static_cast<cl_F&>(x = x + y); }
+inline cl_F& operator+= (cl_R& x, const double y) { return static_cast<cl_F&>(x = x + y); }
 inline cl_F& operator+= (cl_F& x, const int y) { return x = x + y; }
 inline cl_F& operator+= (cl_F& x, const unsigned int y) { return x = x + y; }
 inline cl_F& operator+= (cl_F& x, const long y) { return x = x + y; }
 inline cl_F& operator+= (cl_F& x, const unsigned long y) { return x = x + y; }
+#ifdef HAVE_LONGLONG
+inline cl_F& operator+= (cl_F& x, const long long y) { return x = x + y; }
+inline cl_F& operator+= (cl_F& x, const unsigned long long y) { return x = x + y; }
+#endif
 inline cl_R& operator++ /* prefix */ (cl_R& x) { return x = plus1(x); }
 inline void operator++ /* postfix */ (cl_R& x, int dummy) { (void)dummy; x = plus1(x); }
 inline cl_R& operator-= (cl_R& x, const cl_R& y) { return x = x - y; }
@@ -469,13 +558,33 @@ inline cl_R& operator-= (cl_R& x, const int y) { return x = x - y; }
 inline cl_R& operator-= (cl_R& x, const unsigned int y) { return x = x - y; }
 inline cl_R& operator-= (cl_R& x, const long y) { return x = x - y; }
 inline cl_R& operator-= (cl_R& x, const unsigned long y) { return x = x - y; }
+#ifdef HAVE_LONGLONG
+inline cl_R& operator-= (cl_R& x, const long long y) { return x = x - y; }
+inline cl_R& operator-= (cl_R& x, const unsigned long long y) { return x = x - y; }
+#endif
+inline cl_F& operator-= (cl_R& x, const float y) { return static_cast<cl_F&>(x = x - y); }
+inline cl_F& operator-= (cl_R& x, const double y) { return static_cast<cl_F&>(x = x - y); }
 inline cl_F& operator-= (cl_F& x, const int y) { return x = x - y; }
 inline cl_F& operator-= (cl_F& x, const unsigned int y) { return x = x - y; }
 inline cl_F& operator-= (cl_F& x, const long y) { return x = x - y; }
 inline cl_F& operator-= (cl_F& x, const unsigned long y) { return x = x - y; }
+#ifdef HAVE_LONGLONG
+inline cl_F& operator-= (cl_F& x, const long long y) { return x = x - y; }
+inline cl_F& operator-= (cl_F& x, const unsigned long long y) { return x = x - y; }
+#endif
 inline cl_R& operator-- /* prefix */ (cl_R& x) { return x = minus1(x); }
 inline void operator-- /* postfix */ (cl_R& x, int dummy) { (void)dummy; x = minus1(x); }
 inline cl_R& operator*= (cl_R& x, const cl_R& y) { return x = x * y; }
+inline cl_R& operator*= (cl_R& x, const int y) { return x = x * y; }
+inline cl_R& operator*= (cl_R& x, const unsigned int y) { return x = x * y; }
+inline cl_R& operator*= (cl_R& x, const long y) { return x = x * y; }
+inline cl_R& operator*= (cl_R& x, const unsigned long y) { return x = x * y; }
+#ifdef HAVE_LONGLONG
+inline cl_R& operator*= (cl_R& x, const long long y) { return x = x * y; }
+inline cl_R& operator*= (cl_R& x, const unsigned long long y) { return x = x * y; }
+#endif
+inline cl_R& operator*= (cl_R& x, const float y) { return x = x * y; }
+inline cl_R& operator*= (cl_R& x, const double y) { return x = x * y; }
 inline cl_R& operator/= (cl_R& x, const cl_R& y) { return x = x / y; }
 inline cl_F& operator/= (cl_F& x, const cl_R& y) { return x = x / y; }
 inline cl_F& operator/= (cl_F& x, const cl_RA& y) { return x = x / y; }
@@ -484,10 +593,19 @@ inline cl_R& operator/= (cl_R& x, const int y) { return x = x / y; }
 inline cl_R& operator/= (cl_R& x, const unsigned int y) { return x = x / y; }
 inline cl_R& operator/= (cl_R& x, const long y) { return x = x / y; }
 inline cl_R& operator/= (cl_R& x, const unsigned long y) { return x = x / y; }
+#ifdef HAVE_LONGLONG
+inline cl_R& operator/= (cl_R& x, const long long y) { return x = x / y; }
+inline cl_R& operator/= (cl_R& x, const unsigned long long y) { return x = x / y; }
+#endif
+inline cl_R& operator/= (cl_R& x, const float y) { return x = x / y; }
+inline cl_R& operator/= (cl_R& x, const double y) { return x = x / y; }
 inline cl_F& operator/= (cl_F& x, const int y) { return x = x / y; }
 inline cl_F& operator/= (cl_F& x, const unsigned int y) { return x = x / y; }
 inline cl_F& operator/= (cl_F& x, const long y) { return x = x / y; }
 inline cl_F& operator/= (cl_F& x, const unsigned long y) { return x = x / y; }
+#ifdef HAVE_LONGLONG
+inline cl_F& operator/= (cl_F& x, const long long y) { return x = x / y; }
+inline cl_F& operator/= (cl_F& x, const unsigned long long y) { return x = x / y; }
 #endif