Replace unused macro with cl_unused.

[cln.git] / src / float / dfloat / cl_DF.h

diff --git a/src/float/dfloat/cl_DF.h b/src/float/dfloat/cl_DF.h
index 988553d9f3cd5481dfabc6951253b895fb00929e..6951bf23ea38f550322e243f72d7e8ecdbba1b0c 100644 (file)
--- a/src/float/dfloat/cl_DF.h
+++ b/src/float/dfloat/cl_DF.h
@@ -5,12 +5,12 @@
 
 #include "cln/number.h"
 #include "cln/malloc.h"
-#include "cl_low.h"
-#include "cl_F.h"
+#include "base/cl_low.h"
+#include "float/cl_F.h"
 
 #ifdef FAST_DOUBLE
-#include "cl_N.h"
-#include "cl_F.h"
+#include "base/cl_N.h"
+#include "float/cl_F.h"
 #endif
 
 namespace cln {
@@ -108,7 +108,7 @@ inline cl_heap_dfloat* allocate_dfloat (uint32 semhi, uint32 mlo)
 #if (cl_word_size==64)
 // DF_decode(obj, zero_statement, sign=,exp=,mant=);
 // zerlegt ein Double-Float obj.
-// Ist obj=0.0, wird zero_statement ausgeführt.
+// Ist obj=0.0, wird zero_statement ausgeführt.
 // Sonst: cl_signean sign = Vorzeichen (0 = +, -1 = -),
 //        sintL exp = Exponent (vorzeichenbehaftet),
 //        uintQ mant = Mantisse (>= 2^DF_mant_len, < 2^(DF_mant_len+1))
@@ -121,13 +121,13 @@ inline cl_heap_dfloat* allocate_dfloat (uint32 semhi, uint32 mlo)
         { zero_statement } /* e=0 -> Zahl 0.0 */                       \
         else                                                           \
         { exp_zuweisung (sintL)(uexp - DF_exp_mid); /* Exponent */     \
-          unused (sign_zuweisung ((sint64)_x >> 63)); /* Vorzeichen */ \
+          cl_unused (sign_zuweisung ((sint64)_x >> 63)); /* Vorzeichen */      \
           mant_zuweisung (bit(DF_mant_len) | (_x & (bit(DF_mant_len)-1))); \
     }   }
 #else
 // DF_decode2(obj, zero_statement, sign=,exp=,manthi=,mantlo=);
 // zerlegt ein Double-Float obj.
-// Ist obj=0.0, wird zero_statement ausgeführt.
+// Ist obj=0.0, wird zero_statement ausgeführt.
 // Sonst: cl_signean sign = Vorzeichen (0 = +, -1 = -),
 //        sintL exp = Exponent (vorzeichenbehaftet),
 //        uintL manthi,mantlo = Mantisse 2^32*manthi+mantlo
@@ -142,7 +142,7 @@ inline cl_heap_dfloat* allocate_dfloat (uint32 semhi, uint32 mlo)
         { zero_statement } /* e=0 -> Zahl 0.0 */                       \
         else                                                           \
         { exp_zuweisung (sintL)(uexp - DF_exp_mid); /* Exponent */     \
-          unused (sign_zuweisung sign_of((sint32)(semhi))); /* Vorzeichen */\
+          cl_unused (sign_zuweisung sign_of((sint32)(semhi))); /* Vorzeichen */\
           manthi_zuweisung (bit(DF_mant_len-32) | (semhi & (bit(DF_mant_len-32)-1))); \
           mantlo_zuweisung mlo;                                                \
     }   }
@@ -152,21 +152,21 @@ inline cl_heap_dfloat* allocate_dfloat (uint32 semhi, uint32 mlo)
 #if (cl_word_size==64)
 // encode_DF(sign,exp,mant)
 // liefert ein Double-Float.
-// > cl_signean sign: Vorzeichen, 0 für +, -1 für negativ.
-// > sintL exp: Exponent
+// > cl_signean sign: Vorzeichen, 0 für +, -1 für negativ.
+// > sintE exp: Exponent
 // > uintQ mant: Mantisse, sollte >= 2^DF_mant_len und < 2^(DF_mant_len+1) sein.
 // < cl_DF ergebnis: ein Double-Float
-// Der Exponent wird auf Überlauf/Unterlauf getestet.
-inline const cl_DF encode_DF (cl_signean sign, sintL exp, uintQ mant)
+// Der Exponent wird auf Überlauf/Unterlauf getestet.
+inline const cl_DF encode_DF (cl_signean sign, sintE exp, uintQ mant)
 {
-      if (exp < (sintL)(DF_exp_low-DF_exp_mid))
+      if (exp < (sintE)(DF_exp_low-DF_exp_mid))
         { if (underflow_allowed())
             { throw floating_point_underflow_exception(); }
             else
             { return cl_DF_0; }
         }
       else
-      if (exp > (sintL)(DF_exp_high-DF_exp_mid))
+      if (exp > (sintE)(DF_exp_high-DF_exp_mid))
         { throw floating_point_overflow_exception(); }
       else
       return allocate_dfloat
@@ -178,22 +178,22 @@ inline const cl_DF encode_DF (cl_signean sign, sintL exp, uintQ mant)
 #else
 // encode_DF(sign,exp,manthi,mantlo)
 // liefert ein Double-Float.
-// > cl_signean sign: Vorzeichen, 0 für +, -1 für negativ.
-// > sintL exp: Exponent
+// > cl_signean sign: Vorzeichen, 0 für +, -1 für negativ.
+// > sintE exp: Exponent
 // > uintL manthi,mantlo: Mantisse 2^32*manthi+mantlo,
 //                        sollte >= 2^DF_mant_len und < 2^(DF_mant_len+1) sein.
 // < cl_DF ergebnis: ein Double-Float
-// Der Exponent wird auf Überlauf/Unterlauf getestet.
-inline const cl_DF encode_DF (cl_signean sign, sintL exp, uintL manthi, uintL mantlo)
+// Der Exponent wird auf Überlauf/Unterlauf getestet.
+inline const cl_DF encode_DF (cl_signean sign, sintE exp, uintL manthi, uintL mantlo)
 {
-      if (exp < (sintL)(DF_exp_low-DF_exp_mid))
+      if (exp < (sintE)(DF_exp_low-DF_exp_mid))
         { if (underflow_allowed())
             { throw floating_point_underflow_exception(); }
             else
             { return cl_DF_0; }
         }
       else
-      if (exp > (sintL)(DF_exp_high-DF_exp_mid))
+      if (exp > (sintE)(DF_exp_high-DF_exp_mid))
         { throw floating_point_overflow_exception(); }
       else
       return allocate_dfloat
@@ -211,7 +211,7 @@ inline double DF_to_double (const cl_DF& obj)
 {
        return TheDfloat(obj)->representation.machine_double;
 }
-// Überprüfen und Einpacken eines von den 'double'-Routinen gelieferten
+// Überprüfen und Einpacken eines von den 'double'-Routinen gelieferten
 // IEEE-Floats.
 // Klassifikation:
 //   1 <= e <= 2046 : normalisierte Zahl
@@ -219,8 +219,8 @@ inline double DF_to_double (const cl_DF& obj)
 //   e=0, m=0: vorzeichenbehaftete 0.0
 //   e=2047, m=0: vorzeichenbehaftete Infinity
 //   e=2047, m/=0: NaN
-// Angabe der möglicherweise auftretenden Sonderfälle:
-//   maybe_overflow: Operation läuft über, liefert IEEE-Infinity
+// Angabe der möglicherweise auftretenden Sonderfälle:
+//   maybe_overflow: Operation läuft über, liefert IEEE-Infinity
 //   maybe_subnormal: Ergebnis sehr klein, liefert IEEE-subnormale Zahl
 //   maybe_underflow: Ergebnis sehr klein und /=0, liefert IEEE-Null
 //   maybe_divide_0: Ergebnis unbestimmt, liefert IEEE-Infinity
@@ -242,7 +242,7 @@ inline double DF_to_double (const cl_DF& obj)
             && (((~_erg.eksplicit) & ((uint64)bit(DF_exp_len+DF_mant_len)-bit(DF_mant_len))) == 0) /* e=2047 ? */\
            )                                                           \
         { if (maybe_nan && !((_erg.eksplicit<<(64-DF_mant_len)) == 0)) \
-            { throw division_by_0_exception(); } /* NaN, also Singularität -> "Division durch 0" */\
+            { throw division_by_0_exception(); } /* NaN, also Singularität -> "Division durch 0" */\
           else /* Infinity */                                          \
           if (!maybe_overflow || maybe_divide_0)                       \
             { throw division_by_0_exception(); } /* Infinity, Division durch 0 */\
@@ -270,7 +270,7 @@ inline double DF_to_double (const cl_DF& obj)
             && (((~_erg.eksplicit.semhi) & ((uint32)bit(DF_exp_len+DF_mant_len-32)-bit(DF_mant_len-32))) == 0) /* e=2047 ?  */\
            )                                                              \
         { if (maybe_nan && !(((_erg.eksplicit.semhi<<(64-DF_mant_len)) == 0) && (_erg.eksplicit.mlo==0))) \
-            { throw division_by_0_exception(); } /* NaN, also Singularität -> "Division durch 0"  */\
+            { throw division_by_0_exception(); } /* NaN, also Singularität -> "Division durch 0"  */\
           else /* Infinity                                              */\
           if (!maybe_overflow || maybe_divide_0)                          \
             { throw division_by_0_exception(); } /* Infinity, Division durch 0 */\
@@ -284,7 +284,7 @@ inline double DF_to_double (const cl_DF& obj)
 #endif
 
 // Liefert zu einem Double-Float x : (futruncate x), ein DF.
-// x wird von der 0 weg zur nächsten ganzen Zahl gerundet.
+// x wird von der 0 weg zur nächsten ganzen Zahl gerundet.
 extern const cl_DF futruncate (const cl_DF& x);
 
 // DF_to_I(x) wandelt ein Double-Float x, das eine ganze Zahl darstellt,
@@ -309,10 +309,8 @@ extern const cl_DF cl_RA_to_DF (const cl_RA& x);
 //   e=2047, m=0: vorzeichenbehaftete Infinity
 //   e=2047, m/=0: NaN
 
-// cl_double_to_DF(val) wandelt ein IEEE-Double-Float val in ein Double-Float um.
-extern cl_heap_dfloat* cl_double_to_DF_pointer (const dfloatjanus& val);
-inline const cl_DF cl_double_to_DF (const dfloatjanus& val)
-       { return cl_double_to_DF_pointer(val); }
+// cl_double_to_DF_pointer(val) wandelt ein IEEE-Double-Float val in ein Double-Float um.
+extern cl_heap_dfloat* cl_double_to_DF_pointer (const double val);
 
 // cl_DF_to_double(obj,&val);
 // wandelt ein Double-Float obj in ein IEEE-Double-Float val um.