@@@ fltfmt mess

[mLib] / utils / t / fltfmt-test.c

/* -*-c-*-
 *
 * Test for floating-point conversions
 *
 * (c) 2024 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * mLib is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with mLib.  If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <float.h>
#include <limits.h>
#include <math.h>

#include "fltfmt.h"
#include "maths.h"
#include "tvec.h"
#include "tvec-remote.h"
#include "tvec-types.h"

/*----- Register allocation -----------------------------------------------*/

enum {
  RERR_OUT,
  RF_OUT,	RZ_OUT = RF_OUT,
  RE_OUT,
  RM_OUT,
  NROUT,

  RF = NROUT,	RX = RF,
  RE,
  RM,

  RN,
  RROUND,
  RERRMASK,

  NREG
};

/*----- Type definitions --------------------------------------------------*/

static const struct tvec_flag flterr_flags[] = {
  { "OK",		FLTERR_ALLERRS,	FLTERR_OK },
  { "ALLERRS",		FLTERR_ALLERRS,	FLTERR_ALLERRS },
  { "INVAL",		FLTERR_INVAL,	FLTERR_INVAL },
  { "INEXACT",		FLTERR_INEXACT,	FLTERR_INEXACT },
  { "UFLOW",		FLTERR_UFLOW,	FLTERR_UFLOW },
  { "OFLOW",		FLTERR_OFLOW,	FLTERR_OFLOW },
  { "REPR",		FLTERR_REPR,	FLTERR_REPR },
  TVEC_ENDFLAGS
};
static const struct tvec_flaginfo flterr_flaginfo =
  { "flterr", flterr_flags, &tvrange_uint };
static const struct tvec_flaginfo flterrmask_flaginfo =
  { "flterrmask", flterr_flags + 1, &tvrange_uint };

static const struct tvec_flag fltrnd_flags[] = {

  /* Standard rounding modes. */
  { "zero",		0xffff,		FLTRND_ZERO },
  { "projinf",		0xffff,		FLTRND_PROJINF },
  { "posinf",		0xffff,		FLTRND_POSINF },
  { "neginf",		0xffff,		FLTRND_NEGINF },
  { "odd",		0xffff,		FLTRND_ODD },
  { "even",		0xffff,		FLTRND_EVEN },
  { "nearest-even",	0xffff,		FLTRND_NEAREVEN },
  { "nearest-odd",	0xffff,		FLTRND_NEARODD },
  { "nearest-zero",	0xffff,		FLTRND_NEARZERO },
  { "nearest-projinf",	0xffff,		FLTRND_NEARINF },
  { "nearest-neginf",	0xffff,		FLTRND_NEARNEG },
  { "nearest-posinf",	0xffff,		FLTRND_NEARPOS },

  /* Rounding mode bits: rounds away from zero in the listed conditions.
   * The notation corresponds to rounding predicates as follows.  The syntax
   * is `<s><u>.<h><r>' where
   *
   *	var	bit	clear	set
   *	<s>	@NEG@	%|+|%	%|-|%
   *	<u>	@ODD@	%|0|%	%|1|%
   *	<h>	@HALF@	%|0|%	%|1|%
   *	<r>	@LOW@	%|0|%	%|1|%
   */
  { "+0.00",		0x0001,		0x0001 },
  { "+0.01",		0x0002,		0x0002 },
  { "+0.10",		0x0004,		0x0004 },
  { "+0.11",		0x0008,		0x0008 },
  { "+1.00",		0x0010,		0x0010 },
  { "+1.01",		0x0020,		0x0020 },
  { "+1.10",		0x0040,		0x0040 },
  { "+1.11",		0x0080,		0x0080 },
  { "-0.00",		0x0100,		0x0100 },
  { "-0.01",		0x0200,		0x0200 },
  { "-0.10",		0x0400,		0x0400 },
  { "-0.11",		0x0800,		0x0800 },
  { "-1.00",		0x1000,		0x1000 },
  { "-1.01",		0x2000,		0x2000 },
  { "-1.10",		0x4000,		0x4000 },
  { "-1.11",		0x8000,		0x8000 },

  /* Phew! */
  TVEC_ENDFLAGS
};
static const struct tvec_flaginfo fltrnd_flaginfo =
  { "fltrnd", fltrnd_flags, &tvrange_u16 };

static const struct tvec_flag floatbits_flags[] = {
  { "NEG",		FLTF_NEG,	FLTF_NEG },
  { "INF",		FLTF_INF,	FLTF_INF },
  { "QNAN",		FLTF_QNAN,	FLTF_QNAN },
  { "SNAN",		FLTF_SNAN,	FLTF_SNAN },
  { "ZERO",		FLTF_ZERO,	FLTF_ZERO },
  TVEC_ENDFLAGS
};
static const struct tvec_flaginfo floatbits_flaginfo =
  { "floatbits-flags", floatbits_flags, &tvrange_uint };

static const struct tvec_urange frac_range = { 0, UINT_MAX, 4, 0 };

/*----- Test utilities ----------------------------------------------------*/

#define DEFAULT_REG(rix, set) do {					\
  unsigned _rix = (rix);						\
  struct tvec_reg *_inr = &tv->in[_rix], *_outr = &tv->out[_rix];	\
  union tvec_regval *rv = &_inr->v;					\
									\
  if (!(_inr->f&TVRF_LIVE)) {						\
    set; _inr->f |= TVRF_LIVE;						\
    if (_rix < NROUT) _outr->f |= TVRF_LIVE;				\
  }									\
} while (0)

static void get_floatbits(struct floatbits *z_out, const struct tvec_reg *in)
{
  const unsigned char *p;
  unsigned i, n;

  z_out->f = in[RF].v.u;
  if (in[RE].f&TVRF_LIVE) z_out->exp = in[RE].v.i;
  if (in[RM].f&TVRF_LIVE) {
    n = in[RM].v.bytes.sz/4; fltfmt_allocfrac(z_out, n);
    for (p = in[RM].v.bytes.p, i = 0; i < n; p += 4, i++)
      z_out->frac[i] = LOAD32(p);
  }
}

static void put_floatbits(struct tvec_reg *out, const struct floatbits *x)
{
  unsigned char *p;
  unsigned i;

  out[RF_OUT].v.u = x->f; out[RF_OUT].f |= TVRF_LIVE;
  out[RE_OUT].v.i = x->exp; out[RE_OUT].f |= TVRF_LIVE;
  if (x->n) {
    tvec_allocbytes(&out[RM_OUT].v, 4*x->n);
    for (p = out[RM_OUT].v.bytes.p, i = 0; i < x->n; p += 4, i++)
      STORE32(p, x->frac[i]);
  }
  out[RM_OUT].f |= TVRF_LIVE;
}

/*----- Utilities ---------------------------------------------------------*/

static const struct tvec_regdef round_regs[] = {
  { "round",	&tvty_flags,	RROUND, 0,	{ &fltrnd_flaginfo } },
  { "n",	&tvty_uint,	RN,	0,	{ &tvrange_uint } },
  { "f",	&tvty_flags,	RF,	0,	{ &floatbits_flaginfo } },
  { "e",	&tvty_int,	RE,	TVRF_OPT, { &tvrange_int } },
  { "m",	&tvty_bytes,	RM,	TVRF_OPT, { &frac_range } },
  { "ff",	&tvty_flags,	RF_OUT,	0,	{ &floatbits_flaginfo } },
  { "ee",	&tvty_int,	RE_OUT,	TVRF_OPT, { &tvrange_int } },
  { "mm",	&tvty_bytes,	RM_OUT,	TVRF_OPT, { &frac_range } },
  { "err",	&tvty_flags,	RERR_OUT, 0,	{ &flterr_flaginfo } },
  TVEC_ENDREGS
};

static void test_round(const struct tvec_reg *in, struct tvec_reg *out,
		       void *ctx)
{
  struct floatbits x = FLOATBITS_INIT, z = FLOATBITS_INIT;

  get_floatbits(&x, in);
  out[RERR_OUT].v.u = fltfmt_round(&z, &x, in[RROUND].v.u, in[RN].v.u);
  put_floatbits(out, &z); fltfmt_freebits(&x); fltfmt_freebits(&z);
}

static const struct tvec_test round_test =
  { "round", round_regs, 0, test_round };

/*----- IEEE format conversion --------------------------------------------*/

#define IEEE_FORMATS(_)							\
  _(mini, 1)								\
  _(bf16, 2)								\
  _(f16, 2)								\
  _(f32, 4)								\
  _(f64, 8)								\
  _(f128, 16)								\
  _(idblext80, 10)

#define DECLS_mini	octet y = 0
#define OUTSZ_mini	1
#define LOAD_mini	y = LOAD8(in[RX].v.bytes.p)
#define STORE_mini	STORE8(out[RZ_OUT].v.bytes.p, y)
#define ENCARGS_mini	&y
#define DECARGS_mini	y

#define DECLS_bf16	uint16 y = 0
#define OUTSZ_bf16	2
#define LOAD_bf16	y = LOAD16_B(in[RX].v.bytes.p)
#define STORE_bf16	STORE16_B(out[RZ_OUT].v.bytes.p, y)
#define ENCARGS_bf16	&y
#define DECARGS_bf16	y

#define DECLS_f16	uint16 y = 0
#define OUTSZ_f16	2
#define LOAD_f16	y = LOAD16_B(in[RX].v.bytes.p)
#define STORE_f16	STORE16_B(out[RZ_OUT].v.bytes.p, y)
#define ENCARGS_f16	&y
#define DECARGS_f16	y

#define DECLS_f32	uint32 y = 0
#define OUTSZ_f32	4
#define LOAD_f32	y = LOAD32_B(in[RX].v.bytes.p)
#define STORE_f32	STORE32_B(out[RZ_OUT].v.bytes.p, y)
#define ENCARGS_f32	&y
#define DECARGS_f32	y

#define DECLS_f64	kludge64 y = { 0 }
#define OUTSZ_f64	8
#define LOAD_f64	LOAD64_B_(y, in[RX].v.bytes.p)
#define STORE_f64	STORE64_B_(out[RZ_OUT].v.bytes.p, y)
#define ENCARGS_f64	&y
#define DECARGS_f64	y

#define DECLS_f128	uint32 yv[4] = { 0 }; unsigned i
#define OUTSZ_f128	16
#define LOAD_f128	for (i = 0; i < 4; i++)				\
			  yv[i] = LOAD32_B(in[RX].v.bytes.p + 4*i)
#define STORE_f128	for (i = 0; i < 4; i++)				\
			  STORE32_B(out[RZ_OUT].v.bytes.p + 4*i, yv[i])
#define ENCARGS_f128	yv
#define DECARGS_f128	yv

#define DECLS_idblext80	uint16 se = 0; kludge64 f = { 0 }
#define OUTSZ_idblext80	10
#define LOAD_idblext80	se = LOAD16_B(in[RX].v.bytes.p + 0);		\
			LOAD64_B_(f, in[RX].v.bytes.p + 2)
#define STORE_idblext80	STORE16_B(out[RZ_OUT].v.bytes.p + 0, se);	\
			STORE64_B_(out[RZ_OUT].v.bytes.p + 2, f)
#define ENCARGS_idblext80 &se, &f
#define DECARGS_idblext80 se, f

#define DEF_RANGE(ty, sz)						\
  static const struct tvec_urange ty##_range = { sz, sz, 0, 0 };
IEEE_FORMATS(DEF_RANGE)
#undef DEF_RANGE

static void before_encieee(struct tvec_state *tv, void *ctx)
{
  DEFAULT_REG(RROUND, rv->u = FLTRND_NEAREVEN);
  DEFAULT_REG(RERRMASK, rv->u = FLTERR_ALLERRS);
  DEFAULT_REG(RERR_OUT, rv->u = FLTERR_OK);
}
static struct tvec_env encieee_env = { 0, 0, 0, before_encieee, 0, 0, 0 };

static void before_decieee(struct tvec_state *tv, void *ctx)
  { DEFAULT_REG(RERR_OUT, rv->u = FLTERR_OK); }
static struct tvec_env decieee_env = { 0, 0, 0, before_decieee, 0, 0, 0 };

#define DEF_TEST(ty, sz)						\
									\
  static const struct tvec_regdef enc##ty##_regs[] = {			\
    { "round",	&tvty_flags,	RROUND,	TVRF_OPT, { &fltrnd_flaginfo } }, \
    { "errmask", &tvty_flags,	RERRMASK, TVRF_OPT,			\
					    { &flterrmask_flaginfo } }, \
    { "f",	&tvty_flags,	RF,    TVRF_OPT, { &floatbits_flaginfo } }, \
    { "e",	&tvty_int,	RE,	TVRF_OPT, { &tvrange_int } },	\
    { "m",	&tvty_bytes,	RM,	TVRF_OPT, { &frac_range } },	\
    { "z",	&tvty_bytes,	RZ_OUT,	0,	{ &ty##_range } },	\
    { "err",	&tvty_flags,	RERR_OUT, TVRF_OPT, { &flterr_flaginfo } }, \
    TVEC_ENDREGS							\
  };									\
									\
  static void test_enc##ty(const struct tvec_reg *in, struct tvec_reg *out, \
			   void *ctx)					\
  {									\
    struct floatbits x = FLOATBITS_INIT;				\
    DECLS_##ty;								\
									\
    get_floatbits(&x, in);						\
    out[RERR_OUT].v.u =							\
      fltfmt_enc##ty(ENCARGS_##ty, &x, in[RROUND].v.u, in[RERRMASK].v.u); \
    tvec_allocbytes(&out[RZ_OUT].v, OUTSZ_##ty); STORE_##ty;		\
    fltfmt_freebits(&x);						\
  }									\
									\
  static const struct tvec_test enc##ty##_test =			\
    { "enc" #ty, enc##ty##_regs, &encieee_env, test_enc##ty };		\
									\
  static const struct tvec_regdef dec##ty##_regs[] = {			\
    { "x",	&tvty_bytes,	RX,	0,	{ &ty##_range } },	\
    { "f",	&tvty_flags,	RF_OUT,	0,	{ &floatbits_flaginfo } }, \
    { "e",	&tvty_int,	RE_OUT,	TVRF_OPT, { &tvrange_int } },	\
    { "m",	&tvty_bytes,	RM_OUT,	TVRF_OPT, { &frac_range } },	\
    { "err",	&tvty_flags,	RERR_OUT, TVRF_OPT, { &flterr_flaginfo } }, \
    TVEC_ENDREGS							\
  };									\
									\
  static void test_dec##ty(const struct tvec_reg *in, struct tvec_reg *out, \
			   void *ctx)					\
  {									\
    struct floatbits z = FLOATBITS_INIT;				\
    DECLS_##ty;								\
									\
    LOAD_##ty; out[RERR_OUT].v.u = fltfmt_dec##ty(&z, DECARGS_##ty);	\
    put_floatbits(out, &z); fltfmt_freebits(&z);			\
  }									\
									\
  static const struct tvec_test dec##ty##_test =			\
    { "dec" #ty, dec##ty##_regs, &decieee_env, test_dec##ty };

IEEE_FORMATS(DEF_TEST)

#undef DEF_TEST

#define DEF_IEEE_TEST(ty, sz) &enc##ty##_test, &dec##ty##_test,
#define IEEE_TESTS IEEE_FORMATS(DEF_IEEE_TEST)

/*----- Native format conversion ------------------------------------------*/

#define NATIVE_FORMATS(_)						\
  _(flt, float, FLT)							\
  _(dbl, double, DBL)

enum {
#define DEF_ENUM(ty, cty, TY) NTV_##TY,
  NATIVE_FORMATS(DEF_ENUM)
#undef DEF_ENUM
  NTV_NFMT
};

static const struct ntvinfo {
  unsigned fmt;
  unsigned mant_dig;
} ntvinfo[] = {
#define DEF_INFO(ty, cty, TY) { TY##_FORMAT, TY##_MANT_DIG },
  NATIVE_FORMATS(DEF_INFO)
#undef DEF_INFO
};

#define AF_NEGZ 0x0001u
#define AF_INF 0x0002u
#define AF_STDCNAN 0x0004u
#define AF_IEEE 0x0008u
#define AF_PREC24 0x0010u
#define AF_PREC53 0x0020u
#define AF_PREC64 0x0040u
#define AF_PREC113 0x0080u

static const struct tvec_flag assume_flags[] = {
  { "negz",		AF_NEGZ,	AF_NEGZ },
  { "inf",		AF_INF,		AF_INF },
  { "stdc-nan",		AF_STDCNAN,	AF_STDCNAN },
  { "ieee",		AF_IEEE,	AF_IEEE },
  { "prec24",		AF_PREC24,	AF_PREC24 },
  { "prec53",		AF_PREC53,	AF_PREC53 },
  { "prec64",		AF_PREC64,	AF_PREC64 },
  { "prec113",		AF_PREC113,	AF_PREC113 },
  TVEC_ENDFLAGS
};
static const struct tvec_flaginfo assume_flaginfo =
  { "assume", assume_flags, &tvrange_uint };

struct nativeenv { struct tvec_env _env; unsigned ntv; };
struct nativectx { unsigned af, want; };

static void setup_native(struct tvec_state *tv, const struct tvec_env *env,
			 void *pctx, void *ctx)
{
  const struct nativeenv *nenv = (const struct nativeenv *)env;
  const struct ntvinfo *info = &ntvinfo[nenv->ntv];
  struct nativectx *nctx = ctx;
  double prec;

  switch (info->fmt&(FLTFMT_ORGMASK | FLTFMT_TYPEMASK)) {
    case FLTFMT_IEEE_F32:
      nctx->af = AF_NEGZ | AF_INF | AF_IEEE | AF_PREC24;
      break;
    case FLTFMT_IEEE_F64:
      nctx->af = AF_NEGZ | AF_INF | AF_IEEE | AF_PREC24 | AF_PREC53;
      break;
    case FLTFMT_IEEE_F128:
      nctx->af = AF_NEGZ | AF_INF | AF_IEEE |
		 AF_PREC24 | AF_PREC53 | AF_PREC64 | AF_PREC113;
      break;
    case FLTFMT_INTEL_F80:
      nctx->af = AF_NEGZ | AF_INF | AF_IEEE |
		 AF_PREC24 | AF_PREC53 | AF_PREC64;
      break;
    default:
      nctx->af = 0;
      if (NEGP(-0.0)) nctx->af |= AF_NEGZ;
#ifdef INF
      nctx->af |= AF_INF;
#endif
#ifdef NAN
      nctx->af |= AF_STDCNAN;
#endif
      prec = log(FLT_RADIX)/log(2.0)*info->mant_dig;
      if (prec >= 24) nctx->af |= AF_PREC24;
      if (prec >= 53) nctx->af |= AF_PREC53;
      if (prec >= 64) nctx->af |= AF_PREC64;
      if (prec >= 113) nctx->af |= AF_PREC113;
      break;
  }
  nctx->want = 0;
}

static int setvar_native(struct tvec_state *tv, const char *var,
			 const union tvec_regval *rv, void *ctx)
{
  struct nativectx *nctx = ctx;

  if (STRCMP(var, ==, "@assume")) nctx->want = rv->u;
  else return (tvec_unkregerr(tv, var));
  return (0);
}
static const struct tvec_vardef assume_vardef =
  { sizeof(struct tvec_reg), setvar_native,
    { "@assume", &tvty_flags, 0, 0, { &assume_flaginfo } }};
static const struct tvec_vardef *findvar_native
  (struct tvec_state *tv, const char *name, void **ctx_out, void *ctx)
{
  if (STRCMP(name, ==, "@assume"))
    { *ctx_out = ctx; return (&assume_vardef); }
  else
    return (0);
}

static void before_native(struct tvec_state *tv, void *ctx)
{
  struct nativectx *nctx = ctx;

  if (nctx->want&~nctx->af)
    tvec_skip(tv, "unsatisfied assumption");
  else {
    DEFAULT_REG(RROUND, rv->u = FLTRND_NEAREVEN);
    DEFAULT_REG(RERR_OUT, rv->u = FLTERR_OK);
  }
}

static void after_native(struct tvec_state *tv, void *ctx)
{
  struct nativectx *nctx = ctx;

  nctx->want = 0;
}

#define DEF_TEST(ty, cty, TY)						\
									\
  static struct nativeenv ty##_env =					\
    { { sizeof(struct nativectx),					\
	setup_native, findvar_native, before_native, 0, after_native, 0 }, \
      NTV_##TY };							\
									\
  static const struct tvec_regdef enc##ty##_regs[] = {			\
    { "round",	&tvty_flags,	RROUND, TVRF_OPT, { &fltrnd_flaginfo } }, \
    { "f",	&tvty_flags,	RF,	0,	{ &floatbits_flaginfo } }, \
    { "e",	&tvty_int,	RE,	TVRF_OPT, { &tvrange_int } },	\
    { "m",	&tvty_bytes,	RM,	TVRF_OPT, { &frac_range } },	\
    { "z",	&tvty_float,	RZ_OUT,	0,	{ &tvflt_##cty } },	\
    { "err",	&tvty_flags,	RERR_OUT, TVRF_OPT, { &flterr_flaginfo } }, \
    TVEC_ENDREGS							\
  };									\
									\
  static void test_enc##ty(const struct tvec_reg *in, struct tvec_reg *out, \
			   void *ctx)					\
  {									\
    struct floatbits x = FLOATBITS_INIT;				\
    cty z;								\
									\
    get_floatbits(&x, in);						\
    out[RERR_OUT].v.u = fltfmt_enc##ty(&z, &x, in[RROUND].v.u);		\
    out[RZ_OUT].v.f = z; fltfmt_freebits(&x);				\
  }									\
									\
  static const struct tvec_test enc##ty##_test =			\
    { "enc" #ty, enc##ty##_regs, &ty##_env._env, test_enc##ty };	\
									\
  static const struct tvec_regdef dec##ty##_regs[] = {			\
    { "x",	&tvty_float,	RX,	0,	{ &tvflt_##cty } },	\
    { "round",	&tvty_flags,	RROUND, TVRF_OPT, { &fltrnd_flaginfo } }, \
    { "f",	&tvty_flags,	RF_OUT,	0,	{ &floatbits_flaginfo } }, \
    { "e",	&tvty_int,	RE_OUT,	TVRF_OPT, { &tvrange_int } },	\
    { "m",	&tvty_bytes,	RM_OUT,	TVRF_OPT, { &frac_range } },	\
    { "err",	&tvty_flags,	RERR_OUT, TVRF_OPT, { &flterr_flaginfo } }, \
    TVEC_ENDREGS							\
  };									\
									\
  static void test_dec##ty(const struct tvec_reg *in, struct tvec_reg *out, \
			   void *ctx)					\
  {									\
    struct floatbits z = FLOATBITS_INIT;				\
									\
    out[RERR_OUT].v.u = fltfmt_dec##ty(&z, in[RX].v.f, in[RROUND].v.u);	\
    put_floatbits(out, &z); fltfmt_freebits(&z);			\
  }									\
									\
  static const struct tvec_test dec##ty##_test =			\
    { "dec" #ty, dec##ty##_regs, &ty##_env._env, test_dec##ty };

NATIVE_FORMATS(DEF_TEST)

#undef DEF_TEST

#define DEF_NATIVE_TEST(ty, cty, TY) &enc##ty##_test, &dec##ty##_test,
#define NATIVE_TESTS NATIVE_FORMATS(DEF_NATIVE_TEST)

/*----- Main code ---------------------------------------------------------*/

static const struct tvec_test *const tests[] = {
  &round_test,
  NATIVE_TESTS
  IEEE_TESTS
  0
};

static const struct tvec_config testconfig =
  { tests, NROUT, NREG, sizeof(struct tvec_reg) };

int main(int argc, char *argv[])
  { return (tvec_main(argc, argv, &testconfig, 0)); }

/*----- That's all, folks -------------------------------------------------*/