@@@ fltfmt mess

[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"

/*----- External functions ------------------------------------------------*/

/* --- @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.
 */

int buf_getf32(buf *b, float *x_out)
{
  const octet *p;

  p = buf_get(b, 4); if (!p) return (-1);
  fltfmt_f32btoflt(x_out, p, FLTRND_NEAREVEN); return (0);
}

int buf_getf32l(buf *b, float *x_out)
{
  const octet *p;

  p = buf_get(b, 4); if (!p) return (-1);
  fltfmt_f32ltoflt(x_out, p, FLTRND_NEAREVEN); return (0);
}

int buf_getf32b(buf *b, float *x_out)
{
  const octet *p;

  p = buf_get(b, 4); if (!p) return (-1);
  fltfmt_f32ltoflt(x_out, p, FLTRND_NEAREVEN); return (0);
}

int (dbuf_getf32)(dbuf *db, float *x_out)
  { return (dbuf_getf32(db, x_out)); }
int (dbuf_getf32l)(dbuf *db, float *x_out)
  { return (dbuf_getf32l(db, x_out)); }
int (dbuf_getf32b)(dbuf *db, float *x_out)
  { return (dbuf_getf32b(db, x_out)); }

int buf_getf64(buf *b, double *x_out)
{
  const octet *p;

  p = buf_get(b, 8); if (!p) return (-1);
  fltfmt_f64btodbl(x_out, p, FLTRND_NEAREVEN); return (0);
}

int buf_getf64l(buf *b, double *x_out)
{
  const octet *p;

  p = buf_get(b, 8); if (!p) return (-1);
  fltfmt_f64ltodbl(x_out, p, FLTRND_NEAREVEN); return (0);
}

int buf_getf64b(buf *b, double *x_out)
{
  const octet *p;

  p = buf_get(b, 8); if (!p) return (-1);
  fltfmt_f64ltodbl(x_out, p, FLTRND_NEAREVEN); return (0);
}

int (dbuf_getf64)(dbuf *db, double *x_out)
  { return (dbuf_getf64(db, x_out)); }
int (dbuf_getf64l)(dbuf *db, double *x_out)
  { return (dbuf_getf64l(db, x_out)); }
int (dbuf_getf64b)(dbuf *db, double *x_out)
  { return (dbuf_getf64b(db, x_out)); }

/* --- @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.
 */

int buf_putf32(buf *b, float x)
{
  octet *p;

  p = buf_get(b, 4); if (!p) return (-1);
  fltfmt_flttof32b(p, x, FLTRND_NEAREVEN); return (0);
}

int buf_putf32l(buf *b, float x)
{
  octet *p;

  p = buf_get(b, 4); if (!p) return (-1);
  fltfmt_flttof32l(p, x, FLTRND_NEAREVEN); return (0);
}

int buf_putf32b(buf *b, float x)
{
  octet *p;

  p = buf_get(b, 4); if (!p) return (-1);
  fltfmt_flttof32b(p, x, FLTRND_NEAREVEN); return (0);
}

int (dbuf_putf32)(dbuf *db, float x)
  { return (dbuf_putf32(db, x)); }
int (dbuf_putf32l)(dbuf *db, float x)
  { return (dbuf_putf32l(db, x)); }
int (dbuf_putf32b)(dbuf *db, float x)
  { return (dbuf_putf32b(db, x)); }

int buf_putf64(buf *b, double x)
{
  octet *p;

  p = buf_get(b, 8); if (!p) return (-1);
  fltfmt_dbltof64b(p, x, FLTRND_NEAREVEN); return (0);
}

int buf_putf64l(buf *b, double x)
{
  octet *p;

  p = buf_get(b, 8); if (!p) return (-1);
  fltfmt_dbltof64l(p, x, FLTRND_NEAREVEN); return (0);
}

int buf_putf64b(buf *b, double x)
{
  octet *p;

  p = buf_get(b, 8); if (!p) return (-1);
  fltfmt_dbltof64b(p, x, FLTRND_NEAREVEN); return (0);
}

int (dbuf_putf64)(dbuf *db, double x)
  { return (dbuf_putf64(db, x)); }
int (dbuf_putf64l)(dbuf *db, double x)
  { return (dbuf_putf64l(db, x)); }
int (dbuf_putf64b)(dbuf *db, double x)
  { return (dbuf_putf64b(db, x)); }

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