![[BACK]](/icons/back.gif){kind=icon}
Return to sfrem.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / spmath|
Return to sfrem.c CVS log | Up to [local] / sys / arch / hppa / spmath |
1.1 ! nbrk 1: /* $OpenBSD: sfrem.c,v 1.5 2002/05/07 22:19:30 mickey Exp $ */
! 2: /*
! 3: (c) Copyright 1986 HEWLETT-PACKARD COMPANY
! 4: To anyone who acknowledges that this file is provided "AS IS"
! 5: without any express or implied warranty:
! 6: permission to use, copy, modify, and distribute this file
! 7: for any purpose is hereby granted without fee, provided that
! 8: the above copyright notice and this notice appears in all
! 9: copies, and that the name of Hewlett-Packard Company not be
! 10: used in advertising or publicity pertaining to distribution
! 11: of the software without specific, written prior permission.
! 12: Hewlett-Packard Company makes no representations about the
! 13: suitability of this software for any purpose.
! 14: */
! 15: /* @(#)sfrem.c: Revision: 1.7.88.1 Date: 93/12/07 15:07:10 */
! 16:
! 17: #include "float.h"
! 18: #include "sgl_float.h"
! 19:
! 20: /*
! 21: * Single Precision Floating-point Remainder
! 22: */
! 23: int
! 24: sgl_frem(srcptr1,srcptr2,dstptr,status)
! 25: sgl_floating_point *srcptr1, *srcptr2, *dstptr;
! 26: unsigned int *status;
! 27: {
! 28: register unsigned int opnd1, opnd2, result;
! 29: register int opnd1_exponent, opnd2_exponent, dest_exponent, stepcount;
! 30: register int roundup = FALSE;
! 31:
! 32: opnd1 = *srcptr1;
! 33: opnd2 = *srcptr2;
! 34: /*
! 35: * check first operand for NaN's or infinity
! 36: */
! 37: if ((opnd1_exponent = Sgl_exponent(opnd1)) == SGL_INFINITY_EXPONENT) {
! 38: if (Sgl_iszero_mantissa(opnd1)) {
! 39: if (Sgl_isnotnan(opnd2)) {
! 40: /* invalid since first operand is infinity */
! 41: if (Is_invalidtrap_enabled())
! 42: return(INVALIDEXCEPTION);
! 43: Set_invalidflag();
! 44: Sgl_makequietnan(result);
! 45: *dstptr = result;
! 46: return(NOEXCEPTION);
! 47: }
! 48: }
! 49: else {
! 50: /*
! 51: * is NaN; signaling or quiet?
! 52: */
! 53: if (Sgl_isone_signaling(opnd1)) {
! 54: /* trap if INVALIDTRAP enabled */
! 55: if (Is_invalidtrap_enabled())
! 56: return(INVALIDEXCEPTION);
! 57: /* make NaN quiet */
! 58: Set_invalidflag();
! 59: Sgl_set_quiet(opnd1);
! 60: }
! 61: /*
! 62: * is second operand a signaling NaN?
! 63: */
! 64: else if (Sgl_is_signalingnan(opnd2)) {
! 65: /* trap if INVALIDTRAP enabled */
! 66: if (Is_invalidtrap_enabled())
! 67: return(INVALIDEXCEPTION);
! 68: /* make NaN quiet */
! 69: Set_invalidflag();
! 70: Sgl_set_quiet(opnd2);
! 71: *dstptr = opnd2;
! 72: return(NOEXCEPTION);
! 73: }
! 74: /*
! 75: * return quiet NaN
! 76: */
! 77: *dstptr = opnd1;
! 78: return(NOEXCEPTION);
! 79: }
! 80: }
! 81: /*
! 82: * check second operand for NaN's or infinity
! 83: */
! 84: if ((opnd2_exponent = Sgl_exponent(opnd2)) == SGL_INFINITY_EXPONENT) {
! 85: if (Sgl_iszero_mantissa(opnd2)) {
! 86: /*
! 87: * return first operand
! 88: */
! 89: *dstptr = opnd1;
! 90: return(NOEXCEPTION);
! 91: }
! 92: /*
! 93: * is NaN; signaling or quiet?
! 94: */
! 95: if (Sgl_isone_signaling(opnd2)) {
! 96: /* trap if INVALIDTRAP enabled */
! 97: if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
! 98: /* make NaN quiet */
! 99: Set_invalidflag();
! 100: Sgl_set_quiet(opnd2);
! 101: }
! 102: /*
! 103: * return quiet NaN
! 104: */
! 105: *dstptr = opnd2;
! 106: return(NOEXCEPTION);
! 107: }
! 108: /*
! 109: * check second operand for zero
! 110: */
! 111: if (Sgl_iszero_exponentmantissa(opnd2)) {
! 112: /* invalid since second operand is zero */
! 113: if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION);
! 114: Set_invalidflag();
! 115: Sgl_makequietnan(result);
! 116: *dstptr = result;
! 117: return(NOEXCEPTION);
! 118: }
! 119:
! 120: /*
! 121: * get sign of result
! 122: */
! 123: result = opnd1;
! 124:
! 125: /*
! 126: * check for denormalized operands
! 127: */
! 128: if (opnd1_exponent == 0) {
! 129: /* check for zero */
! 130: if (Sgl_iszero_mantissa(opnd1)) {
! 131: *dstptr = opnd1;
! 132: return(NOEXCEPTION);
! 133: }
! 134: /* normalize, then continue */
! 135: opnd1_exponent = 1;
! 136: Sgl_normalize(opnd1,opnd1_exponent);
! 137: }
! 138: else {
! 139: Sgl_clear_signexponent_set_hidden(opnd1);
! 140: }
! 141: if (opnd2_exponent == 0) {
! 142: /* normalize, then continue */
! 143: opnd2_exponent = 1;
! 144: Sgl_normalize(opnd2,opnd2_exponent);
! 145: }
! 146: else {
! 147: Sgl_clear_signexponent_set_hidden(opnd2);
! 148: }
! 149:
! 150: /* find result exponent and divide step loop count */
! 151: dest_exponent = opnd2_exponent - 1;
! 152: stepcount = opnd1_exponent - opnd2_exponent;
! 153:
! 154: /*
! 155: * check for opnd1/opnd2 < 1
! 156: */
! 157: if (stepcount < 0) {
! 158: /*
! 159: * check for opnd1/opnd2 > 1/2
! 160: *
! 161: * In this case n will round to 1, so
! 162: * r = opnd1 - opnd2
! 163: */
! 164: if (stepcount == -1 && Sgl_isgreaterthan(opnd1,opnd2)) {
! 165: Sgl_all(result) = ~Sgl_all(result); /* set sign */
! 166: /* align opnd2 with opnd1 */
! 167: Sgl_leftshiftby1(opnd2);
! 168: Sgl_subtract(opnd2,opnd1,opnd2);
! 169: /* now normalize */
! 170: while (Sgl_iszero_hidden(opnd2)) {
! 171: Sgl_leftshiftby1(opnd2);
! 172: dest_exponent--;
! 173: }
! 174: Sgl_set_exponentmantissa(result,opnd2);
! 175: goto testforunderflow;
! 176: }
! 177: /*
! 178: * opnd1/opnd2 <= 1/2
! 179: *
! 180: * In this case n will round to zero, so
! 181: * r = opnd1
! 182: */
! 183: Sgl_set_exponentmantissa(result,opnd1);
! 184: dest_exponent = opnd1_exponent;
! 185: goto testforunderflow;
! 186: }
! 187:
! 188: /*
! 189: * Generate result
! 190: *
! 191: * Do iterative subtract until remainder is less than operand 2.
! 192: */
! 193: while (stepcount-- > 0 && Sgl_all(opnd1)) {
! 194: if (Sgl_isnotlessthan(opnd1,opnd2))
! 195: Sgl_subtract(opnd1,opnd2,opnd1);
! 196: Sgl_leftshiftby1(opnd1);
! 197: }
! 198: /*
! 199: * Do last subtract, then determine which way to round if remainder
! 200: * is exactly 1/2 of opnd2
! 201: */
! 202: if (Sgl_isnotlessthan(opnd1,opnd2)) {
! 203: Sgl_subtract(opnd1,opnd2,opnd1);
! 204: roundup = TRUE;
! 205: }
! 206: if (stepcount > 0 || Sgl_iszero(opnd1)) {
! 207: /* division is exact, remainder is zero */
! 208: Sgl_setzero_exponentmantissa(result);
! 209: *dstptr = result;
! 210: return(NOEXCEPTION);
! 211: }
! 212:
! 213: /*
! 214: * Check for cases where opnd1/opnd2 < n
! 215: *
! 216: * In this case the result's sign will be opposite that of
! 217: * opnd1. The mantissa also needs some correction.
! 218: */
! 219: Sgl_leftshiftby1(opnd1);
! 220: if (Sgl_isgreaterthan(opnd1,opnd2)) {
! 221: Sgl_invert_sign(result);
! 222: Sgl_subtract((opnd2<<1),opnd1,opnd1);
! 223: }
! 224: /* check for remainder being exactly 1/2 of opnd2 */
! 225: else if (Sgl_isequal(opnd1,opnd2) && roundup) {
! 226: Sgl_invert_sign(result);
! 227: }
! 228:
! 229: /* normalize result's mantissa */
! 230: while (Sgl_iszero_hidden(opnd1)) {
! 231: dest_exponent--;
! 232: Sgl_leftshiftby1(opnd1);
! 233: }
! 234: Sgl_set_exponentmantissa(result,opnd1);
! 235:
! 236: /*
! 237: * Test for underflow
! 238: */
! 239: testforunderflow:
! 240: if (dest_exponent <= 0) {
! 241: /* trap if UNDERFLOWTRAP enabled */
! 242: if (Is_underflowtrap_enabled()) {
! 243: /*
! 244: * Adjust bias of result
! 245: */
! 246: Sgl_setwrapped_exponent(result,dest_exponent,unfl);
! 247: *dstptr = result;
! 248: /* frem is always exact */
! 249: return(UNDERFLOWEXCEPTION);
! 250: }
! 251: /*
! 252: * denormalize result or set to signed zero
! 253: */
! 254: if (dest_exponent >= (1 - SGL_P)) {
! 255: Sgl_rightshift_exponentmantissa(result,1-dest_exponent);
! 256: } else {
! 257: Sgl_setzero_exponentmantissa(result);
! 258: }
! 259: }
! 260: else Sgl_set_exponent(result,dest_exponent);
! 261: *dstptr = result;
! 262: return(NOEXCEPTION);
! 263: }