From c4585d7cfd92a295e17500a0d3ddfedf95d92cdd Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Mon, 20 Oct 2025 00:36:29 -0400 Subject: Deduplicate Num code using the same templating technique as integers --- Makefile | 3 + src/stdlib/intX.h | 2 +- src/stdlib/num32.c | 4 + src/stdlib/num64.c | 4 + src/stdlib/numX.c.h | 195 +++++++++++++++++++++++++++++++++++++ src/stdlib/numX.h | 103 ++++++++++++++++++++ src/stdlib/nums.c | 269 ---------------------------------------------------- src/stdlib/nums.h | 134 ++------------------------ 8 files changed, 317 insertions(+), 397 deletions(-) create mode 100644 src/stdlib/num32.c create mode 100644 src/stdlib/num64.c create mode 100644 src/stdlib/numX.c.h create mode 100644 src/stdlib/numX.h delete mode 100644 src/stdlib/nums.c diff --git a/Makefile b/Makefile index c6cd808e..6b71a346 100644 --- a/Makefile +++ b/Makefile @@ -163,6 +163,9 @@ config.mk: configure.sh # Integer implementations depend on the shared header: src/stdlib/int64.o src/stdlib/int32.o src/stdlib/int16.o src/stdlib/int8.o: src/stdlib/intX.c.h +# Num implementations depend on the shared header: +src/stdlib/num32.o src/stdlib/num64.o: src/stdlib/numX.c.h + # Specifically src/tomo.c needs to recompile if CHANGES.md changes: src/tomo.o: src/tomo.c src/ast.h src/environment.h src/types.h config.mk src/changes.md.h @$(ECHO) $(CC) $(CFLAGS_PLACEHOLDER) -c $< -o $@ diff --git a/src/stdlib/intX.h b/src/stdlib/intX.h index 7b1f90d5..e0980923 100644 --- a/src/stdlib/intX.h +++ b/src/stdlib/intX.h @@ -1,5 +1,5 @@ // Integer type infos and methods -// This file expects `c_type` and `type_name` to be defined before including: +// This file expects `INTX_H__INT_BITS` to be defined before including: // // #define INTX_H__INT_BITS 64 // #include "intX.h" diff --git a/src/stdlib/num32.c b/src/stdlib/num32.c new file mode 100644 index 00000000..6d505f37 --- /dev/null +++ b/src/stdlib/num32.c @@ -0,0 +1,4 @@ +// Type infos and methods for Num32 (32-bit floating point) using a template file + +#define NUMX_C_H__BITS 32 +#include "numX.c.h" diff --git a/src/stdlib/num64.c b/src/stdlib/num64.c new file mode 100644 index 00000000..7fdc8f35 --- /dev/null +++ b/src/stdlib/num64.c @@ -0,0 +1,4 @@ +// Type infos and methods for Num (64-bit floating point) using a template file + +#define NUMX_C_H__BITS 64 +#include "numX.c.h" diff --git a/src/stdlib/numX.c.h b/src/stdlib/numX.c.h new file mode 100644 index 00000000..707af60b --- /dev/null +++ b/src/stdlib/numX.c.h @@ -0,0 +1,195 @@ +// Type infos and methods for Nums (floating point) +// This file is a template that expects `NUMSX_C_H__BITS` to be defined before including: +// +// #define NUMX_C_H__BITS 64 +// #include "numX.c.h" +// +#include +#include +#include +#include +#include +#include + +#include "fpconv.h" +#include "nums.h" +#include "string.h" +#include "text.h" +#include "types.h" + +#ifndef NUMX_C_H__BITS +#define NUMX_C_H__BITS 64 +#endif + +#if NUMX_C_H__BITS == 64 +#define NUM_T double +#define OPT_T double +#define NAMESPACED(x) Num$##x +#define TYPE_STR "Num" +#define SUFFIXED(x) x +#elif NUMX_C_H__BITS == 32 +#define NUM_T float +#define OPT_T float +#define NAMESPACED(x) Num32$##x +#define TYPE_STR "Num32" +#define SUFFIXED(x) x##f +#else +#error "Unsupported bit width for Num" +#endif + +#if NUMX_C_H__BITS == 64 +public +PUREFUNC Text_t NAMESPACED(value_as_text)(double x) { + char *str = GC_MALLOC_ATOMIC(24); + int len = fpconv_dtoa(x, str); + return Text$from_strn(str, (size_t)len); +} +public +PUREFUNC Text_t NAMESPACED(as_text)(const void *x, bool colorize, const TypeInfo_t *info) { + (void)info; + if (!x) return Text("Num"); + static const Text_t color_prefix = Text("\x1b[35m"), color_suffix = Text("\x1b[m"); + Text_t text = NAMESPACED(value_as_text)(*(double *)x); + return colorize ? Texts(color_prefix, text, color_suffix) : text; +} +#elif NUMX_C_H__BITS == 32 +public +PUREFUNC Text_t NAMESPACED(value_as_text)(float x) { return Num$value_as_text((double)x); } +PUREFUNC Text_t NAMESPACED(as_text)(const void *x, bool colorize, const TypeInfo_t *info) { + (void)info; + if (!x) return Text("Num32"); + static const Text_t color_prefix = Text("\x1b[35m"), color_suffix = Text("\x1b[m"); + Text_t text = Num$value_as_text(*(double *)x); + return colorize ? Texts(color_prefix, text, color_suffix) : text; +} +#endif + +public +PUREFUNC int32_t NAMESPACED(compare)(const void *x, const void *y, const TypeInfo_t *info) { + (void)info; + int64_t rx = *(int64_t *)x, ry = *(int64_t *)y; + + if (rx == ry) return 0; + + if (rx < 0) rx ^= INT64_MAX; + if (ry < 0) ry ^= INT64_MAX; + + return (rx > ry) - (rx < ry); +} + +public +PUREFUNC bool NAMESPACED(equal)(const void *x, const void *y, const TypeInfo_t *info) { + (void)info; + return *(NUM_T *)x == *(NUM_T *)y; +} + +public +CONSTFUNC bool NAMESPACED(near)(NUM_T a, NUM_T b, NUM_T ratio, NUM_T absolute) { + if (ratio < 0) ratio = 0; + else if (ratio > 1) ratio = 1; + + if (a == b) return true; + + NUM_T diff = SUFFIXED(fabs)(a - b); + if (diff < absolute) return true; + else if (SUFFIXED(isnan)(diff)) return false; + + NUM_T epsilon = SUFFIXED(fabs)(a * ratio) + SUFFIXED(fabs)(b * ratio); + if (SUFFIXED(isinf)(epsilon)) epsilon = DBL_MAX; + return (diff < epsilon); +} + +public +Text_t NAMESPACED(percent)(NUM_T x, NUM_T precision) { + NUM_T d = SUFFIXED(100.) * x; + d = NAMESPACED(with_precision)(d, precision); + return Texts(NAMESPACED(value_as_text)(d), Text("%")); +} + +public +CONSTFUNC NUM_T NAMESPACED(with_precision)(NUM_T num, NUM_T precision) { + if (precision == SUFFIXED(0.0)) return num; + // Precision will be, e.g. 0.01 or 100. + if (precision < SUFFIXED(1.)) { + NUM_T inv = SUFFIXED(round)(SUFFIXED(1.) / precision); // Necessary to make the math work + NUM_T k = num * inv; + return SUFFIXED(round)(k) / inv; + } else { + NUM_T k = num / precision; + return SUFFIXED(round)(k) * precision; + } +} + +public +CONSTFUNC NUM_T NAMESPACED(mod)(NUM_T num, NUM_T modulus) { + // Euclidean division, see: + // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf + NUM_T r = remainder(num, modulus); + r -= (r < 0) * (2 * (modulus < 0) - 1) * modulus; + return r; +} + +public +CONSTFUNC NUM_T NAMESPACED(mod1)(NUM_T num, NUM_T modulus) { + return SUFFIXED(1.0) + NAMESPACED(mod)(num - SUFFIXED(1.0), modulus); +} + +public +CONSTFUNC NUM_T NAMESPACED(mix)(NUM_T amount, NUM_T x, NUM_T y) { return (SUFFIXED(1.0) - amount) * x + amount * y; } + +public +CONSTFUNC bool NAMESPACED(is_between)(const NUM_T x, const NUM_T low, const NUM_T high) { + return low <= x && x <= high; +} +public +CONSTFUNC NUM_T NAMESPACED(clamped)(NUM_T x, NUM_T low, NUM_T high) { + return (x <= low) ? low : (x >= high ? high : x); +} + +public +OPT_T NAMESPACED(parse)(Text_t text, Text_t *remainder) { + const char *str = Text$as_c_string(text); + char *end = NULL; + NUM_T d = strtod(str, &end); + if (end > str) { + if (remainder) *remainder = Text$from_str(end); + else if (*end != '\0') return nan("none"); + return d; + } else { + if (remainder) *remainder = text; + return nan("none"); + } +} + +public +CONSTFUNC bool NAMESPACED(is_none)(const void *n, const TypeInfo_t *info) { + (void)info; + return SUFFIXED(isnan)(*(Num_t *)n); +} + +public +CONSTFUNC bool NAMESPACED(isinf)(NUM_T n) { return (fpclassify(n) == FP_INFINITE); } +public +CONSTFUNC bool NAMESPACED(finite)(NUM_T n) { return (fpclassify(n) != FP_INFINITE); } +public +CONSTFUNC bool NAMESPACED(isnan)(NUM_T n) { return (fpclassify(n) == FP_NAN); } + +public +const TypeInfo_t NAMESPACED(info) = { + .size = sizeof(NUM_T), + .align = __alignof__(NUM_T), + .metamethods = + { + .compare = NAMESPACED(compare), + .equal = NAMESPACED(equal), + .as_text = NAMESPACED(as_text), + .is_none = NAMESPACED(is_none), + }, +}; + +#undef NUM_T +#undef OPT_T +#undef NAMESPACED +#undef TYPE_STR +#undef SUFFIXED +#undef NUMX_C_H__BITS diff --git a/src/stdlib/numX.h b/src/stdlib/numX.h new file mode 100644 index 00000000..779c4e59 --- /dev/null +++ b/src/stdlib/numX.h @@ -0,0 +1,103 @@ +// Template header for 64 and 32 bit Nums +// This file expects `NUMX_H__BITS` to be defined before including: +// +// #define NUMX_H__BITS 64 +// #include "numX.h" +// + +#include +#include + +#include "datatypes.h" +#include "stdlib.h" +#include "types.h" +#include "util.h" + +#ifndef NUMX_H__BITS +#define NUMX_H__BITS 64 +#endif + +#if NUMX_H__BITS == 64 +#define NUM_T double +#define OPT_T double +#define NAMESPACED(x) Num$##x +#define TYPE_STR "Num" +#define SUFFIXED(x) x +#elif NUMX_H__BITS == 32 +#define NUM_T float +#define OPT_T float +#define NAMESPACED(x) Num32$##x +#define TYPE_STR "Num32" +#define SUFFIXED(x) x##f +#else +#error "Unsupported bit width for Num" +#endif + +Text_t NAMESPACED(as_text)(const void *x, bool colorize, const TypeInfo_t *type); +Text_t NAMESPACED(value_as_text)(NUM_T x); +PUREFUNC int32_t NAMESPACED(compare)(const void *x, const void *y, const TypeInfo_t *type); +PUREFUNC bool NAMESPACED(equal)(const void *x, const void *y, const TypeInfo_t *type); +CONSTFUNC bool NAMESPACED(near)(NUM_T a, NUM_T b, NUM_T ratio, NUM_T absolute); +Text_t NAMESPACED(percent)(NUM_T x, NUM_T precision); +NUM_T CONSTFUNC NAMESPACED(with_precision)(NUM_T num, NUM_T precision); +NUM_T NAMESPACED(mod)(NUM_T num, NUM_T modulus); +NUM_T NAMESPACED(mod1)(NUM_T num, NUM_T modulus); +CONSTFUNC bool NAMESPACED(isinf)(NUM_T n); +CONSTFUNC bool NAMESPACED(finite)(NUM_T n); +CONSTFUNC bool NAMESPACED(isnan)(NUM_T n); +bool NAMESPACED(is_none)(const void *n, const TypeInfo_t *info); +NUM_T NAMESPACED(nan)(Text_t tag); +CONSTFUNC NUM_T NAMESPACED(mix)(NUM_T amount, NUM_T x, NUM_T y); +OPT_T NAMESPACED(parse)(Text_t text, Text_t *remainder); +CONSTFUNC bool NAMESPACED(is_between)(const NUM_T x, const NUM_T low, const NUM_T high); +CONSTFUNC NUM_T NAMESPACED(clamped)(NUM_T x, NUM_T low, NUM_T high); + +#if NUMX_H__BITS == 64 +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_num32)(float n) { return (NUM_T)n; } +#elif NUMX_H__BITS == 32 +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_num64)(double n) { return (NUM_T)n; } +#endif + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wfloat-equal" +#endif +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_int)(Int_t i, bool truncate) { + if likely (i.small & 0x1) { + NUM_T ret = (NUM_T)(i.small >> 2); + if unlikely (!truncate && (int64_t)ret != (i.small >> 2)) + fail("Could not convert integer to " TYPE_STR " without losing precision: ", i.small >> 2); + return ret; + } else { + NUM_T 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 " TYPE_STR " without losing precision: ", i); + } + return ret; + } +} +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_int64)(Int64_t i, bool truncate) { + NUM_T n = (NUM_T)i; + if unlikely (!truncate && (Int64_t)n != i) + fail("Could not convert integer to " TYPE_STR " without losing precision: ", i); + return n; +} +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_int32)(Int32_t i) { return (NUM_T)i; } +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_int16)(Int16_t i) { return (NUM_T)i; } +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_int8)(Int8_t i) { return (NUM_T)i; } +MACROLIKE CONSTFUNC NUM_T NAMESPACED(from_byte)(Byte_t i) { return (NUM_T)i; } + +extern const TypeInfo_t NAMESPACED(info); + +#undef NUM_T +#undef OPT_T +#undef NAMESPACED +#undef TYPE_STR +#undef SUFFIXED +#undef NUMX_H__BITS diff --git a/src/stdlib/nums.c b/src/stdlib/nums.c deleted file mode 100644 index 4bbb1f6a..00000000 --- a/src/stdlib/nums.c +++ /dev/null @@ -1,269 +0,0 @@ -// Type infos and methods for Nums (floating point) - -#include -#include -#include -#include -#include -#include - -#include "fpconv.h" -#include "nums.h" -#include "string.h" -#include "text.h" -#include "types.h" - -public -PUREFUNC Text_t Num$value_as_text(double x) { - char *str = GC_MALLOC_ATOMIC(24); - int len = fpconv_dtoa(x, str); - return Text$from_strn(str, (size_t)len); -} - -public -PUREFUNC Text_t Num$as_text(const void *x, bool colorize, const TypeInfo_t *info) { - (void)info; - if (!x) return Text("Num"); - static const Text_t color_prefix = Text("\x1b[35m"), color_suffix = Text("\x1b[m"); - Text_t text = Num$value_as_text(*(double *)x); - return colorize ? Texts(color_prefix, text, color_suffix) : text; -} - -public -PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo_t *info) { - (void)info; - int64_t rx = *(int64_t *)x, ry = *(int64_t *)y; - - if (rx == ry) return 0; - - if (rx < 0) rx ^= INT64_MAX; - if (ry < 0) ry ^= INT64_MAX; - - return (rx > ry) - (rx < ry); -} - -public -PUREFUNC bool Num$equal(const void *x, const void *y, const TypeInfo_t *info) { - (void)info; - return *(double *)x == *(double *)y; -} - -public -CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute) { - if (ratio < 0) ratio = 0; - else if (ratio > 1) ratio = 1; - - if (a == b) return true; - - double diff = fabs(a - b); - if (diff < absolute) return true; - else if (isnan(diff)) return false; - - double epsilon = fabs(a * ratio) + fabs(b * ratio); - if (isinf(epsilon)) epsilon = DBL_MAX; - return (diff < epsilon); -} - -public -Text_t Num$percent(double x, double precision) { - double d = 100. * x; - d = Num$with_precision(d, precision); - return Texts(Num$value_as_text(d), Text("%")); -} - -public -CONSTFUNC double Num$with_precision(double num, double precision) { - if (precision == 0.0) return num; - // Precision will be, e.g. 0.01 or 100. - if (precision < 1.) { - double inv = round(1. / precision); // Necessary to make the math work - double k = num * inv; - return round(k) / inv; - } else { - double k = num / precision; - return round(k) * precision; - } -} - -public -CONSTFUNC double Num$mod(double num, double modulus) { - // Euclidean division, see: - // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf - double r = remainder(num, modulus); - r -= (r < 0) * (2 * (modulus < 0) - 1) * modulus; - return r; -} - -public -CONSTFUNC double Num$mod1(double num, double modulus) { return 1.0 + Num$mod(num - 1, modulus); } - -public -CONSTFUNC double Num$mix(double amount, double x, double y) { return (1.0 - amount) * x + amount * y; } - -public -CONSTFUNC bool Num$is_between(const double x, const double low, const double high) { return low <= x && x <= high; } -public -CONSTFUNC double Num$clamped(double x, double low, double high) { return (x <= low) ? low : (x >= high ? high : x); } - -public -OptionalNum_t Num$parse(Text_t text, Text_t *remainder) { - const char *str = Text$as_c_string(text); - char *end = NULL; - double d = strtod(str, &end); - if (end > str) { - if (remainder) *remainder = Text$from_str(end); - else if (*end != '\0') return nan("none"); - return d; - } else { - if (remainder) *remainder = text; - return nan("none"); - } -} - -public -CONSTFUNC bool Num$is_none(const void *n, const TypeInfo_t *info) { - (void)info; - return isnan(*(Num_t *)n); -} - -public -CONSTFUNC bool Num$isinf(double n) { return (fpclassify(n) == FP_INFINITE); } -public -CONSTFUNC bool Num$finite(double n) { return (fpclassify(n) != FP_INFINITE); } -public -CONSTFUNC bool Num$isnan(double n) { return (fpclassify(n) == FP_NAN); } - -public -const TypeInfo_t Num$info = { - .size = sizeof(double), - .align = __alignof__(double), - .metamethods = - { - .compare = Num$compare, - .equal = Num$equal, - .as_text = Num$as_text, - .is_none = Num$is_none, - }, -}; - -public -PUREFUNC Text_t Num32$value_as_text(float x) { return Num$value_as_text((double)x); } - -public -PUREFUNC Text_t Num32$as_text(const void *x, bool colorize, const TypeInfo_t *info) { - (void)info; - if (!x) return Text("Num32"); - double d = (double)(*(float *)x); - return Num$as_text(&d, colorize, &Num$info); -} - -public -PUREFUNC int32_t Num32$compare(const void *x, const void *y, const TypeInfo_t *info) { - (void)info; - return (*(float *)x > *(float *)y) - (*(float *)x < *(float *)y); -} - -public -PUREFUNC bool Num32$equal(const void *x, const void *y, const TypeInfo_t *info) { - (void)info; - return *(float *)x == *(float *)y; -} - -public -CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute) { - if (ratio < 0) ratio = 0; - else if (ratio > 1) ratio = 1; - - if (a == b) return true; - - float diff = fabsf(a - b); - if (diff < absolute) return true; - else if (isnan(diff)) return false; - - float epsilon = fabsf(a * ratio) + fabsf(b * ratio); - if (isinf(epsilon)) epsilon = FLT_MAX; - return (diff < epsilon); -} - -public -Text_t Num32$percent(float x, float precision) { - double d = 100. * (double)x; - d = Num$with_precision(d, (double)precision); - return Texts(Num$value_as_text(d), Text("%")); -} - -public -CONSTFUNC float Num32$with_precision(float num, float precision) { - if (precision == 0.0f) return num; - // Precision will be, e.g. 0.01 or 100. - if (precision < 1.f) { - float inv = roundf(1.f / precision); // Necessary to make the math work - float k = num * inv; - return roundf(k) / inv; - } else { - float k = num / precision; - return roundf(k) * precision; - } -} - -public -CONSTFUNC float Num32$mod(float num, float modulus) { - // Euclidean division, see: - // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf - float r = remainderf(num, modulus); - r -= (r < 0) * (2 * (modulus < 0) - 1) * modulus; - return r; -} - -public -CONSTFUNC float Num32$mod1(float num, float modulus) { return 1.0f + Num32$mod(num - 1, modulus); } - -public -CONSTFUNC float Num32$mix(float amount, float x, float y) { return (1.0f - amount) * x + amount * y; } - -public -CONSTFUNC bool Num32$is_between(const float x, const float low, const float high) { return low <= x && x <= high; } - -public -CONSTFUNC float Num32$clamped(float x, float low, float high) { return (x <= low) ? low : (x >= high ? high : x); } - -public -OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder) { - const char *str = Text$as_c_string(text); - char *end = NULL; - double d = strtod(str, &end); - if (end > str && end[0] == '\0') { - if (remainder) *remainder = Text$from_str(end); - else if (*end != '\0') return nan("none"); - return d; - } else { - if (remainder) *remainder = text; - return nan("none"); - } -} - -public -CONSTFUNC bool Num32$is_none(const void *n, const TypeInfo_t *info) { - (void)info; - return isnan(*(Num32_t *)n); -} - -public -CONSTFUNC bool Num32$isinf(float n) { return (fpclassify(n) == FP_INFINITE); } -public -CONSTFUNC bool Num32$finite(float n) { return (fpclassify(n) != FP_INFINITE); } -public -CONSTFUNC bool Num32$isnan(float n) { return (fpclassify(n) == FP_NAN); } - -public -const TypeInfo_t Num32$info = { - .size = sizeof(float), - .align = __alignof__(float), - .metamethods = - { - .compare = Num32$compare, - .equal = Num32$equal, - .as_text = Num32$as_text, - .is_none = Num32$is_none, - }, -}; diff --git a/src/stdlib/nums.h b/src/stdlib/nums.h index 303aa362..8cea9e84 100644 --- a/src/stdlib/nums.h +++ b/src/stdlib/nums.h @@ -2,132 +2,12 @@ #pragma once -#include -#include - -#include "datatypes.h" -#include "stdlib.h" -#include "types.h" -#include "util.h" - -#define OptionalNum_t double -#define OptionalNum32_t float -#define N32(n) ((float)(n)) #define N64(n) ((double)(n)) +#define OptionalNum_t double +#define NUMX_H__BITS 64 +#include "numX.h" -Text_t Num$as_text(const void *x, bool colorize, const TypeInfo_t *type); -Text_t Num$value_as_text(double x); -PUREFUNC int32_t Num$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Num$equal(const void *x, const void *y, const TypeInfo_t *type); -CONSTFUNC bool Num$near(double a, double b, double ratio, double absolute); -Text_t Num$percent(double x, double precision); -double CONSTFUNC Num$with_precision(double num, double precision); -double Num$mod(double num, double modulus); -double Num$mod1(double num, double modulus); -CONSTFUNC bool Num$isinf(double n); -CONSTFUNC bool Num$finite(double n); -CONSTFUNC bool Num$isnan(double n); -bool Num$is_none(const void *n, const TypeInfo_t *info); -double Num$nan(Text_t tag); -CONSTFUNC double Num$mix(double amount, double x, double y); -OptionalNum_t Num$parse(Text_t text, Text_t *remainder); -CONSTFUNC bool Num$is_between(const double x, const double low, const double high); -CONSTFUNC double Num$clamped(double x, double low, double high); -MACROLIKE CONSTFUNC double Num$from_num32(Num32_t n) { return (double)n; } -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wfloat-equal" -#endif -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: ", 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: ", i); - } - return ret; - } -} -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif -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: ", 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 *x, bool colorize, const TypeInfo_t *type); -Text_t Num32$value_as_text(float x); -PUREFUNC int32_t Num32$compare(const void *x, const void *y, const TypeInfo_t *type); -PUREFUNC bool Num32$equal(const void *x, const void *y, const TypeInfo_t *type); -CONSTFUNC bool Num32$near(float a, float b, float ratio, float absolute); -Text_t Num32$percent(float x, float precision); -float CONSTFUNC Num32$with_precision(float num, float precision); -float Num32$mod(float num, float modulus); -float Num32$mod1(float num, float modulus); -CONSTFUNC bool Num32$isinf(float n); -CONSTFUNC bool Num32$finite(float n); -CONSTFUNC bool Num32$isnan(float n); -CONSTFUNC bool Num32$is_none(const void *n, const TypeInfo_t *info); -CONSTFUNC float Num32$mix(float amount, float x, float y); -OptionalNum32_t Num32$parse(Text_t text, Text_t *remainder); -float Num32$nan(Text_t tag); -CONSTFUNC bool Num32$is_between(const float x, const float low, const float high); -CONSTFUNC float Num32$clamped(float x, float low, float high); -MACROLIKE CONSTFUNC float Num32$from_num(Num_t n) { return (float)n; } -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wfloat-equal" -#endif -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: ", i.small >> 2); - return ret; - } else { - float ret = (float)mpz_get_d(*i.big); - if (!truncate) { - mpz_t roundtrip; - mpz_init_set_d(roundtrip, (double)ret); - if unlikely (mpz_cmp(*i.big, roundtrip) != 0) - fail("Could not convert integer to 32-bit floating point without losing precision: ", i); - } - return ret; - } -} -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif -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: ", 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: ", 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; } - -extern const TypeInfo_t Num32$info; +#define N32(n) ((float)(n)) +#define OptionalNum32_t float +#define NUMX_H__BITS 32 +#include "numX.h" -- cgit v1.2.3