xref: /titanic_51/usr/src/lib/libm/common/R/rintf.c (revision ddc0e0b53c661f6e439e3b7072b3ef353eadb4af)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma weak __rintf = rintf

/* INDENT OFF */
/*
 * aintf(x)	return x chopped to integral value
 * anintf(x)	return sign(x)*(|x|+0.5) chopped to integral value
 * irintf(x)	return rint(x) in integer format
 * nintf(x)	return anint(x) in integer format
 * rintf(x)	return x rounded to integral according to the rounding direction
 *
 * NOTE: rintf(x), aintf(x) and anintf(x) return results with the same sign as
 * x's,  including 0.0.
 */

#include "libm.h"

static const float xf[] = {
/* ZEROF */	0.0f,
/* TWO_23F */	8.3886080000e6f,
/* MTWO_23F */	-8.3886080000e6f,
/* ONEF */	1.0f,
/* MONEF */	-1.0f,
/* HALFF */	0.5f,
/* MHALFF */	-0.5f,
/* HUGEF */	1.0e30f,
};

#define	ZEROF		xf[0]
#define	TWO_23F		xf[1]
#define	MTWO_23F	xf[2]
#define	ONEF		xf[3]
#define	MONEF		xf[4]
#define	HALFF		xf[5]
#define	MHALFF		xf[6]
#define	HUGEF		xf[7]
/* INDENT ON */

float
aintf(float x) {
	int hx, k;
	float y;

	hx = *(int *) &x;
	k = (hx & ~0x80000000) >> 23;
	if (k < 150) {
		y = (float) ((int) x);
		/*
		 * make sure y has the same sign of x when |x|<0.5
		 * (i.e., y=0.0)
		 */
		return (((k - 127) & hx) < 0 ? -y : y);
	} else
		/* signal invalid if x is a SNaN */
		return (x * ONEF);		/* +0 -> *1 for Cheetah */
}

float
anintf(float x) {
	volatile float dummy;
	int hx, k, j, ix;

	hx = *(int *) &x;
	ix = hx & ~0x80000000;
	k = ix >> 23;
	if (((k - 127) ^ (k - 150)) < 0) {
		j = 1 << (149 - k);
		k = j + j - 1;
		if ((k & hx) != 0)
			dummy = HUGEF + x;	/* raise inexact */
		*(int *) &x = (hx + j) & ~k;
		return (x);
	} else if (k <= 126) {
		dummy = HUGEF + x;
		*(int *) &x = (0x3f800000 & ((125 - k) >> 31)) |
			(0x80000000 & hx);
		return (x);
	} else
		/* signal invalid if x is a SNaN */
		return (x * ONEF);		/* +0 -> *1 for Cheetah */
}

int
irintf(float x) {
	float v;
	int hx, k;

	hx = *(int *) &x;
	k = (hx & ~0x80000000) >> 23;
	v = xf[((k - 150) >> 31) & (1 - (hx >> 31))];
	return ((int) ((float) (x + v) - v));
}

int
nintf(float x) {
	int hx, ix, k, j, m;
	volatile float dummy;

	hx = *(int *) &x;
	k = (hx & ~0x80000000) >> 23;
	if (((k - 126) ^ (k - 150)) < 0) {
		ix = (hx & 0x00ffffff) | 0x800000;
		m = 149 - k;
		j = 1 << m;
		if ((ix & (j + j - 1)) != 0)
			dummy = HUGEF + x;
		hx = hx >> 31;
		return ((((ix + j) >> (m + 1)) ^ hx) - hx);
	} else
		return ((int) x);
}

float
rintf(float x) {
	float w, v;
	int hx, k;

	hx = *(int *) &x;
	k = (hx & ~0x80000000) >> 23;
#if defined(FPADD_TRAPS_INCOMPLETE_ON_NAN)
	if (k >= 150)
		return (x * ONEF);
	v = xf[1 - (hx >> 31)];
#else
	v = xf[((k - 150) >> 31) & (1 - (hx >> 31))];
#endif
	w = (float) (x + v);
	if (k < 127 && w == v)
		return (ZEROF * x);
	else
		return (w - v);
}