Overhaul of constructors, making it more consistent and correct. Also

changed T(), T, T_t, T_s type names to T(), T$$info, T$$type, T$$struct
for unambiguity

1 files changed, 74 insertions, 7 deletions

diff --git a/stdlib/nums.h b/stdlib/nums.h
index f000ca8b..0b4cdc1b 100644
--- a/stdlib/nums.h
+++ b/stdlib/nums.h
@@ -6,15 +6,16 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "datatypes.h"
+#include "integers.h"
+#include "stdlib.h"
 #include "types.h"
 #include "util.h"
 
-#define Num_t double
-#define Num32_t float
 #define OptionalNum_t double
 #define OptionalNum32_t float
-#define N32(n) ((float)n)
-#define N64(n) ((double)n)
+#define N32(n) ((float)(n))
+#define N64(n) ((double)(n))
 
 Text_t Num$as_text(const void *f, bool colorize, const TypeInfo_t *type);
 PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo_t *type);
@@ -32,6 +33,38 @@ OptionalNum_t Num$parse(Text_t text);
 MACROLIKE CONSTFUNC double Num$clamped(double x, double low, double high) {
     return (x <= low) ? low : (x >= high ? high : x);
 }
+MACROLIKE CONSTFUNC double Num$from_num32(Num32_t n) { return (double)n; }
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+MACROLIKE CONSTFUNC double Num$from_int(Int_t i, bool truncate) {
+    if likely (i.small & 0x1) {
+        double ret = (double)(i.small >> 2);
+        if unlikely (!truncate && (int64_t)ret != (i.small >> 2))
+            fail("Could not convert integer to 64-bit floating point without losing precision: %ld", i.small >> 2);
+        return ret;
+    } else {
+        double ret = mpz_get_d(*i.big);
+        if (!truncate) {
+            mpz_t roundtrip;
+            mpz_init_set_d(roundtrip, ret);
+            if unlikely (mpz_cmp(*i.big, roundtrip) != 0)
+                fail("Could not convert integer to 64-bit floating point without losing precision: %k", (Text_t[1]){Int$value_as_text(i)});
+        }
+        return ret;
+    }
+}
+#pragma GCC diagnostic pop
+MACROLIKE CONSTFUNC double Num$from_int64(Int64_t i, bool truncate) {
+    double n = (double)i;
+    if unlikely (!truncate && (Int64_t)n != i)
+        fail("Could not convert integer to 64-bit floating point without losing precision: %ld", i);
+    return n;
+}
+MACROLIKE CONSTFUNC double Num$from_int32(Int32_t i) { return (double)i; }
+MACROLIKE CONSTFUNC double Num$from_int16(Int16_t i) { return (double)i; }
+MACROLIKE CONSTFUNC double Num$from_int8(Int8_t i) { return (double)i; }
+MACROLIKE CONSTFUNC double Num$from_byte(Byte_t i) { return (double)i; }
+
 extern const TypeInfo_t Num$info;
 
 Text_t Num32$as_text(const void *f, bool colorize, const TypeInfo_t *type);
@@ -50,9 +83,43 @@ float Num32$nan(Text_t tag);
 MACROLIKE CONSTFUNC float Num32$clamped(float x, float low, float high) {
     return (x <= low) ? low : (x >= high ? high : x);
 }
-extern const TypeInfo_t Num32$info;
+MACROLIKE CONSTFUNC float Num32$from_num(Num_t n) { return (float)n; }
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+MACROLIKE CONSTFUNC float Num32$from_int(Int_t i, bool truncate) {
+    if likely (i.small & 0x1) {
+        float ret = (float)(i.small >> 2);
+        if unlikely (!truncate && (int64_t)ret != (i.small >> 2))
+            fail("Could not convert integer to 32-bit floating point without losing precision: %ld", i.small >> 2);
+        return ret;
+    } else {
+        float ret = (float)mpz_get_d(*i.big);
+        if (!truncate) {
+            mpz_t roundtrip;
+            mpz_init_set_d(roundtrip, ret);
+            if unlikely (mpz_cmp(*i.big, roundtrip) != 0)
+                fail("Could not convert integer to 32-bit floating point without losing precision: %k", (Text_t[1]){Int$value_as_text(i)});
+        }
+        return ret;
+    }
+}
+#pragma GCC diagnostic pop
+MACROLIKE CONSTFUNC float Num32$from_int64(Int64_t i, bool truncate) {
+    float n = (float)i;
+    if unlikely (!truncate && (Int64_t)n != i)
+        fail("Could not convert integer to 32-bit floating point without losing precision: %ld", i);
+    return n;
+}
+MACROLIKE CONSTFUNC float Num32$from_int32(Int32_t i, bool truncate) {
+    float n = (float)i;
+    if unlikely (!truncate && (Int32_t)n != i)
+        fail("Could not convert integer to 32-bit floating point without losing precision: %d", i);
+    return n;
+}
+MACROLIKE CONSTFUNC float Num32$from_int16(Int16_t i) { return (float)i; }
+MACROLIKE CONSTFUNC float Num32$from_int8(Int8_t i) { return (float)i; }
+MACROLIKE CONSTFUNC float Num32$from_byte(Byte_t i) { return (float)i; }
 
-#define Num_to_Num32(n) ((Num32_t)(n))
-#define Num32_to_Num(n) ((Num_t)(n))
+extern const TypeInfo_t Num32$info;
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0