@@@ mostly bench docs

[mLib] / struct / buf-float.c

/* -*-c-*-
 *
 * Encoding and decoding floating-point values
 *
 * (c) 2023 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 <float.h>
#include <math.h>

#include "bits.h"
#include "buf.h"
#include "fltfmt.h"
#include "macros.h"

/*----- Constants ---------------------------------------------------------*/

/* Tolerable errors.  These aren't great, and all of them imply a failure to
 * faithfully pass the value on, but they're also the inevitable consequence
 * of having different floating-point systems.
 */
#define IGNERR (FLTERR_INEXACT | FLTERR_OFLOW | FLTERR_UFLOW)

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

#define FORMATS(_)							\
  _(flt, float, f32, 4)							\
  _(dbl, double, f64, 8)

/* --- @buf_getf{32,64}{,l,b} --- *
 *
 * Arguments:	@buf *b@ = a buffer to read from
 *		@float *x_out@, @double *x_out@ = where to put the result
 *
 * Returns:	Zero on success, %$-1$% on failure (and the buffer is
 *		broken).
 *
 * Use:		Get an IEEE Binary32 or Binary64 value from the buffer.
 *		Conversion is performed using the `fltfmt' machinery, with
 *		the usual round-to-nearest/ties-to-even rounding mode.
 */

#define DEFGET1(ty, cty, fty, e, xe, w)					\
  int GLUE3(buf_get, fty, xe)(buf *b, cty *x_out)			\
  {									\
    const octet *p;							\
    unsigned err;							\
									\
    p = buf_get(b, w); if (!p) return (-1);				\
    err = fltfmt_##fty##e##to##ty(x_out, p, FLTRND_NEAREVEN);		\
      if (err&~IGNERR) { BBREAK(b); return (-1); }			\
    return (0);								\
  }									\
  int (GLUE3(dbuf_get, fty, xe))(dbuf *db, cty *x_out)			\
    { return (GLUE3(dbuf_get, fty, xe)(db, x_out)); }

#define DEFGET(ty, cty, fty, w)						\
  DEFGET1(ty, cty, fty, b, EMPTY, w)					\
  DEFGET1(ty, cty, fty, l, l, w)					\
  DEFGET1(ty, cty, fty, b, b, w)

FORMATS(DEFGET)

#undef DEFGET1
#undef DEFGET

/* --- @buf_putf{32,64}{,l,b} --- *
 *
 * Arguments:	@buf *b@ = a buffer to write to
 *		@double x@ = a number to write
 *
 * Returns:	Zero on success, %$-1$% on failure (and the buffer is
 *		broken).
 *
 * Use:		Get an IEEE Binary32 or Binary64 value from the buffer.
 *		Conversion is performed using the `fltfmt' machinery, with
 *		the usual round-to-nearest/ties-to-even rounding mode.
 */

#define DEFPUT1(ty, cty, fty, e, xe, w)					\
  int GLUE3(buf_put, fty, xe)(buf *b, cty x)				\
  {									\
    octet *p;								\
    unsigned err;							\
									\
    p = buf_get(b, w); if (!p) return (-1);				\
    err = fltfmt_##ty##to##fty##e(p, x, FLTRND_NEAREVEN);		\
      if (err&~IGNERR) { BBREAK(b); return (-1); }			\
    return (0);								\
  }									\
  int (GLUE3(dbuf_put, fty, xe))(dbuf *db, cty x)			\
    { return (GLUE3(dbuf_put, fty, xe)(db, x)); }

#define DEFPUT(ty, cty, fty, w)						\
  DEFPUT1(ty, cty, fty, b, EMPTY, w)					\
  DEFPUT1(ty, cty, fty, l, l, w)					\
  DEFPUT1(ty, cty, fty, b, b, w)

FORMATS(DEFPUT)

#undef DEFPUT1
#undef DEFPUT

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