/*ARGSUSED*/ int dbl_fsqrt(dbl_floating_point *srcptr, dbl_floating_point *dstptr, unsigned int *status) { register unsigned int srcp1, srcp2, resultp1, resultp2; register unsigned int newbitp1, newbitp2, sump1, sump2; register int src_exponent; register int guardbit = false, even_exponent; Dbl_copyfromptr(srcptr,srcp1,srcp2); /* * check source operand for NaN or infinity */ if ((src_exponent = Dbl_exponent(srcp1)) == DBL_INFINITY_EXPONENT) { /* * is signaling NaN? */ if (Dbl_isone_signaling(srcp1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(srcp1); } /* * Return quiet NaN or positive infinity. * Fall thru to negative test if negative infinity. */ if (Dbl_iszero_sign(srcp1) || Dbl_isnotzero_mantissa(srcp1,srcp2)) { Dbl_copytoptr(srcp1,srcp2,dstptr); return(NOEXCEPTION); } } /* * check for zero source operand */ if (Dbl_iszero_exponentmantissa(srcp1,srcp2)) { Dbl_copytoptr(srcp1,srcp2,dstptr); return(NOEXCEPTION); } /* * check for negative source operand */ if (Dbl_isone_sign(srcp1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_makequietnan(srcp1,srcp2); Dbl_copytoptr(srcp1,srcp2,dstptr); return(NOEXCEPTION); } /* * Generate result */ if (src_exponent > 0) { even_exponent = Dbl_hidden(srcp1); Dbl_clear_signexponent_set_hidden(srcp1); } else { /* normalize operand */ Dbl_clear_signexponent(srcp1); src_exponent++; Dbl_normalize(srcp1,srcp2,src_exponent); even_exponent = src_exponent & 1; } if (even_exponent) { /* exponent is even */ /* Add comment here. Explain why odd exponent needs correction */ Dbl_leftshiftby1(srcp1,srcp2); } /* * Add comment here. Explain following algorithm. * * Trust me, it works. * */ Dbl_setzero(resultp1,resultp2); Dbl_allp1(newbitp1) = 1 << (DBL_P - 32); Dbl_setzero_mantissap2(newbitp2); while (Dbl_isnotzero(newbitp1,newbitp2) && Dbl_isnotzero(srcp1,srcp2)) { Dbl_addition(resultp1,resultp2,newbitp1,newbitp2,sump1,sump2); if(Dbl_isnotgreaterthan(sump1,sump2,srcp1,srcp2)) { Dbl_leftshiftby1(newbitp1,newbitp2); /* update result */ Dbl_addition(resultp1,resultp2,newbitp1,newbitp2, resultp1,resultp2); Dbl_subtract(srcp1,srcp2,sump1,sump2,srcp1,srcp2); Dbl_rightshiftby2(newbitp1,newbitp2); } else { Dbl_rightshiftby1(newbitp1,newbitp2); } Dbl_leftshiftby1(srcp1,srcp2); } /* correct exponent for pre-shift */ if (even_exponent) { Dbl_rightshiftby1(resultp1,resultp2); } /* check for inexact */ if (Dbl_isnotzero(srcp1,srcp2)) { if (!even_exponent && Dbl_islessthan(resultp1,resultp2,srcp1,srcp2)) { Dbl_increment(resultp1,resultp2); } guardbit = Dbl_lowmantissap2(resultp2); Dbl_rightshiftby1(resultp1,resultp2); /* now round result */ switch (Rounding_mode()) { case ROUNDPLUS: Dbl_increment(resultp1,resultp2); break; case ROUNDNEAREST: /* stickybit is always true, so guardbit * is enough to determine rounding */ if (guardbit) { Dbl_increment(resultp1,resultp2); } break; } /* increment result exponent by 1 if mantissa overflowed */ if (Dbl_isone_hiddenoverflow(resultp1)) src_exponent+=2; if (Is_inexacttrap_enabled()) { Dbl_set_exponent(resultp1, ((src_exponent-DBL_BIAS)>>1)+DBL_BIAS); Dbl_copytoptr(resultp1,resultp2,dstptr); return(INEXACTEXCEPTION); } else Set_inexactflag(); }
/* * Double Precision Floating-point Remainder */ int dbl_frem(dbl_floating_point *srcptr1, dbl_floating_point *srcptr2, dbl_floating_point *dstptr, unsigned int *status) { register unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2; register unsigned int resultp1, resultp2; register int opnd1_exponent, opnd2_exponent, dest_exponent, stepcount; register int roundup = false; Dbl_copyfromptr(srcptr1,opnd1p1,opnd1p2); Dbl_copyfromptr(srcptr2,opnd2p1,opnd2p2); /* * check first operand for NaN's or infinity */ if ((opnd1_exponent = Dbl_exponent(opnd1p1)) == DBL_INFINITY_EXPONENT) { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_isnotnan(opnd2p1,opnd2p2)) { /* invalid since first operand is infinity */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd1p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd1p1); } /* * is second operand a signaling NaN? */ else if (Dbl_is_signalingnan(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } } /* * check second operand for NaN's or infinity */ if ((opnd2_exponent = Dbl_exponent(opnd2p1)) == DBL_INFINITY_EXPONENT) { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { /* * return first operand */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); } /* * return quiet NaN */ Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * check second operand for zero */ if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { /* invalid since second operand is zero */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * get sign of result */ resultp1 = opnd1p1; /* * check for denormalized operands */ if (opnd1_exponent == 0) { /* check for zero */ if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } /* normalize, then continue */ opnd1_exponent = 1; Dbl_normalize(opnd1p1,opnd1p2,opnd1_exponent); } else { Dbl_clear_signexponent_set_hidden(opnd1p1); } if (opnd2_exponent == 0) { /* normalize, then continue */ opnd2_exponent = 1; Dbl_normalize(opnd2p1,opnd2p2,opnd2_exponent); } else { Dbl_clear_signexponent_set_hidden(opnd2p1); } /* find result exponent and divide step loop count */ dest_exponent = opnd2_exponent - 1; stepcount = opnd1_exponent - opnd2_exponent; /* * check for opnd1/opnd2 < 1 */ if (stepcount < 0) { /* * check for opnd1/opnd2 > 1/2 * * In this case n will round to 1, so * r = opnd1 - opnd2 */ if (stepcount == -1 && Dbl_isgreaterthan(opnd1p1,opnd1p2,opnd2p1,opnd2p2)) { /* set sign */ Dbl_allp1(resultp1) = ~Dbl_allp1(resultp1); /* align opnd2 with opnd1 */ Dbl_leftshiftby1(opnd2p1,opnd2p2); Dbl_subtract(opnd2p1,opnd2p2,opnd1p1,opnd1p2, opnd2p1,opnd2p2); /* now normalize */ while (Dbl_iszero_hidden(opnd2p1)) { Dbl_leftshiftby1(opnd2p1,opnd2p2); dest_exponent--; } Dbl_set_exponentmantissa(resultp1,resultp2,opnd2p1,opnd2p2); goto testforunderflow; } /* * opnd1/opnd2 <= 1/2 * * In this case n will round to zero, so * r = opnd1 */ Dbl_set_exponentmantissa(resultp1,resultp2,opnd1p1,opnd1p2); dest_exponent = opnd1_exponent; goto testforunderflow; } /* * Generate result * * Do iterative subtract until remainder is less than operand 2. */ while (stepcount-- > 0 && (Dbl_allp1(opnd1p1) || Dbl_allp2(opnd1p2))) { if (Dbl_isnotlessthan(opnd1p1,opnd1p2,opnd2p1,opnd2p2)) { Dbl_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2,opnd1p1,opnd1p2); } Dbl_leftshiftby1(opnd1p1,opnd1p2); } /* * Do last subtract, then determine which way to round if remainder * is exactly 1/2 of opnd2 */ if (Dbl_isnotlessthan(opnd1p1,opnd1p2,opnd2p1,opnd2p2)) { Dbl_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2,opnd1p1,opnd1p2); roundup = true; } if (stepcount > 0 || Dbl_iszero(opnd1p1,opnd1p2)) { /* division is exact, remainder is zero */ Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * Check for cases where opnd1/opnd2 < n * * In this case the result's sign will be opposite that of * opnd1. The mantissa also needs some correction. */ Dbl_leftshiftby1(opnd1p1,opnd1p2); if (Dbl_isgreaterthan(opnd1p1,opnd1p2,opnd2p1,opnd2p2)) { Dbl_invert_sign(resultp1); Dbl_leftshiftby1(opnd2p1,opnd2p2); Dbl_subtract(opnd2p1,opnd2p2,opnd1p1,opnd1p2,opnd1p1,opnd1p2); } /* check for remainder being exactly 1/2 of opnd2 */ else if (Dbl_isequal(opnd1p1,opnd1p2,opnd2p1,opnd2p2) && roundup) { Dbl_invert_sign(resultp1); } /* normalize result's mantissa */ while (Dbl_iszero_hidden(opnd1p1)) { dest_exponent--; Dbl_leftshiftby1(opnd1p1,opnd1p2); } Dbl_set_exponentmantissa(resultp1,resultp2,opnd1p1,opnd1p2); /* * Test for underflow */ testforunderflow: if (dest_exponent <= 0) { /* trap if UNDERFLOWTRAP enabled */ if (Is_underflowtrap_enabled()) { /* * Adjust bias of result */ Dbl_setwrapped_exponent(resultp1,dest_exponent,unfl); /* frem is always exact */ Dbl_copytoptr(resultp1,resultp2,dstptr); return(UNDERFLOWEXCEPTION); } /* * denormalize result or set to signed zero */ if (dest_exponent >= (1 - DBL_P)) { Dbl_rightshift_exponentmantissa(resultp1,resultp2, 1-dest_exponent); } else { Dbl_setzero_exponentmantissa(resultp1,resultp2); } } else Dbl_set_exponent(resultp1,dest_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); }
int dbl_fdiv (dbl_floating_point * srcptr1, dbl_floating_point * srcptr2, dbl_floating_point * dstptr, unsigned int *status) { register unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2; register unsigned int opnd3p1, opnd3p2, resultp1, resultp2; register int dest_exponent, count; register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; boolean is_tiny; Dbl_copyfromptr(srcptr1,opnd1p1,opnd1p2); Dbl_copyfromptr(srcptr2,opnd2p1,opnd2p2); /* * set sign bit of result */ if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setnegativezerop1(resultp1); else Dbl_setzerop1(resultp1); /* * check first operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd1p1)) { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_isnotnan(opnd2p1,opnd2p2)) { if (Dbl_isinfinity(opnd2p1,opnd2p2)) { /* * invalid since both operands * are infinity */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * return infinity */ Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd1p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd1p1); } /* * is second operand a signaling NaN? */ else if (Dbl_is_signalingnan(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * return quiet NaN */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } } /* * check second operand for NaN's or infinity */ if (Dbl_isinfinity_exponent(opnd2p1)) { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { /* * return zero */ Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * is NaN; signaling or quiet? */ if (Dbl_isone_signaling(opnd2p1)) { /* trap if INVALIDTRAP enabled */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* make NaN quiet */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); } /* * return quiet NaN */ Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* * check for division by zero */ if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { /* invalid since both operands are zero */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } if (Is_divisionbyzerotrap_enabled()) return(DIVISIONBYZEROEXCEPTION); Set_divisionbyzeroflag(); Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* * Generate exponent */ dest_exponent = Dbl_exponent(opnd1p1) - Dbl_exponent(opnd2p1) + DBL_BIAS; /* * Generate mantissa */ if (Dbl_isnotzero_exponent(opnd1p1)) { /* set hidden bit */ Dbl_clear_signexponent_set_hidden(opnd1p1); } else { /* check for zero */ if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* is denormalized, want to normalize */ Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,dest_exponent); } /* opnd2 needs to have hidden bit set with msb in hidden bit */ if (Dbl_isnotzero_exponent(opnd2p1)) { Dbl_clear_signexponent_set_hidden(opnd2p1); } else { /* is denormalized; want to normalize */ Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); while (Dbl_iszero_hiddenhigh7mantissa(opnd2p1)) { dest_exponent+=8; Dbl_leftshiftby8(opnd2p1,opnd2p2); } if (Dbl_iszero_hiddenhigh3mantissa(opnd2p1)) { dest_exponent+=4; Dbl_leftshiftby4(opnd2p1,opnd2p2); } while (Dbl_iszero_hidden(opnd2p1)) { dest_exponent++; Dbl_leftshiftby1(opnd2p1,opnd2p2); } } /* Divide the source mantissas */ /* * A non-restoring divide algorithm is used. */ Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); Dbl_setzero(opnd3p1,opnd3p2); for (count=1; count <= DBL_P && (opnd1p1 || opnd1p2); count++) { Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1, opnd1p2, opnd2p1, opnd2p2); } } if (count <= DBL_P) { Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_setone_lowmantissap2(opnd3p2); Dbl_leftshift(opnd3p1,opnd3p2,(DBL_P-count)); if (Dbl_iszero_hidden(opnd3p1)) { Dbl_leftshiftby1(opnd3p1,opnd3p2); dest_exponent--; } } else { if (Dbl_iszero_hidden(opnd3p1)) { /* need to get one more bit of result */ Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } dest_exponent--; } if (Dbl_iszero_sign(opnd1p1)) guardbit = TRUE; stickybit = Dbl_allp1(opnd1p1) || Dbl_allp2(opnd1p2); } inexact = guardbit | stickybit; /* * round result */ if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) { Dbl_clear_signexponent(opnd3p1); switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } } if (Dbl_isone_hidden(opnd3p1)) dest_exponent++; } Dbl_set_mantissa(resultp1,resultp2,opnd3p1,opnd3p2); /* * Test for overflow */ if (dest_exponent >= DBL_INFINITY_EXPONENT) { /* trap if OVERFLOWTRAP enabled */ if (Is_overflowtrap_enabled()) { /* * Adjust bias of result */ Dbl_setwrapped_exponent(resultp1,dest_exponent,ovfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(OVERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(OVERFLOWEXCEPTION); } Set_overflowflag(); /* set result to infinity or largest number */ Dbl_setoverflow(resultp1,resultp2); inexact = TRUE; } /* * Test for underflow */ else if (dest_exponent <= 0) { /* trap if UNDERFLOWTRAP enabled */ if (Is_underflowtrap_enabled()) { /* * Adjust bias of result */ Dbl_setwrapped_exponent(resultp1,dest_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(UNDERFLOWEXCEPTION); } /* Determine if should set underflow flag */ is_tiny = TRUE; if (dest_exponent == 0 && inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; } } /* * denormalize result or set to signed zero */ stickybit = inexact; Dbl_denormalize(opnd3p1,opnd3p2,dest_exponent,guardbit, stickybit,inexact); /* return rounded number */ if (inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } break; } if (is_tiny) Set_underflowflag(); } Dbl_set_exponentmantissa(resultp1,resultp2,opnd3p1,opnd3p2); } else Dbl_set_exponent(resultp1,dest_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); /* check for inexact */ if (inexact) { if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); else Set_inexactflag(); } return(NOEXCEPTION); }
/* * dbl_cmp: compare two values */ int dbl_fcmp (dbl_floating_point * leftptr, dbl_floating_point * rightptr, unsigned int cond, unsigned int *status) /* The predicate to be tested */ { register unsigned int leftp1, leftp2, rightp1, rightp2; register int xorresult; /* Create local copies of the numbers */ Dbl_copyfromptr(leftptr,leftp1,leftp2); Dbl_copyfromptr(rightptr,rightp1,rightp2); /* * Test for NaN */ if( (Dbl_exponent(leftp1) == DBL_INFINITY_EXPONENT) || (Dbl_exponent(rightp1) == DBL_INFINITY_EXPONENT) ) { /* Check if a NaN is involved. Signal an invalid exception when * comparing a signaling NaN or when comparing quiet NaNs and the * low bit of the condition is set */ if( ((Dbl_exponent(leftp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(leftp1,leftp2) && (Exception(cond) || Dbl_isone_signaling(leftp1))) || ((Dbl_exponent(rightp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(rightp1,rightp2) && (Exception(cond) || Dbl_isone_signaling(rightp1))) ) { if( Is_invalidtrap_enabled() ) { Set_status_cbit(Unordered(cond)); return(INVALIDEXCEPTION); } else Set_invalidflag(); Set_status_cbit(Unordered(cond)); return(NOEXCEPTION); } /* All the exceptional conditions are handled, now special case NaN compares */ else if( ((Dbl_exponent(leftp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(leftp1,leftp2)) || ((Dbl_exponent(rightp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(rightp1,rightp2)) ) { /* NaNs always compare unordered. */ Set_status_cbit(Unordered(cond)); return(NOEXCEPTION); } /* infinities will drop down to the normal compare mechanisms */ } /* First compare for unequal signs => less or greater or * special equal case */ Dbl_xortointp1(leftp1,rightp1,xorresult); if( xorresult < 0 ) { /* left negative => less, left positive => greater. * equal is possible if both operands are zeros. */ if( Dbl_iszero_exponentmantissa(leftp1,leftp2) && Dbl_iszero_exponentmantissa(rightp1,rightp2) ) { Set_status_cbit(Equal(cond)); } else if( Dbl_isone_sign(leftp1) ) { Set_status_cbit(Lessthan(cond)); } else { Set_status_cbit(Greaterthan(cond)); } } /* Signs are the same. Treat negative numbers separately * from the positives because of the reversed sense. */ else if(Dbl_isequal(leftp1,leftp2,rightp1,rightp2)) { Set_status_cbit(Equal(cond)); } else if( Dbl_iszero_sign(leftp1) ) { /* Positive compare */ if( Dbl_allp1(leftp1) < Dbl_allp1(rightp1) ) { Set_status_cbit(Lessthan(cond)); } else if( Dbl_allp1(leftp1) > Dbl_allp1(rightp1) ) { Set_status_cbit(Greaterthan(cond)); } else { /* Equal first parts. Now we must use unsigned compares to * resolve the two possibilities. */ if( Dbl_allp2(leftp2) < Dbl_allp2(rightp2) ) { Set_status_cbit(Lessthan(cond)); } else { Set_status_cbit(Greaterthan(cond)); } } } else { /* Negative compare. Signed or unsigned compares * both work the same. That distinction is only * important when the sign bits differ. */ if( Dbl_allp1(leftp1) > Dbl_allp1(rightp1) ) { Set_status_cbit(Lessthan(cond)); } else if( Dbl_allp1(leftp1) < Dbl_allp1(rightp1) ) { Set_status_cbit(Greaterthan(cond)); } else { /* Equal first parts. Now we must use unsigned compares to * resolve the two possibilities. */ if( Dbl_allp2(leftp2) > Dbl_allp2(rightp2) ) { Set_status_cbit(Lessthan(cond)); } else { Set_status_cbit(Greaterthan(cond)); } } } return(NOEXCEPTION); }
int dbl_fdiv (dbl_floating_point * srcptr1, dbl_floating_point * srcptr2, dbl_floating_point * dstptr, unsigned int *status) { register unsigned int opnd1p1, opnd1p2, opnd2p1, opnd2p2; register unsigned int opnd3p1, opnd3p2, resultp1, resultp2; register int dest_exponent, count; register boolean inexact = FALSE, guardbit = FALSE, stickybit = FALSE; boolean is_tiny; Dbl_copyfromptr(srcptr1,opnd1p1,opnd1p2); Dbl_copyfromptr(srcptr2,opnd2p1,opnd2p2); /* */ if (Dbl_sign(opnd1p1) ^ Dbl_sign(opnd2p1)) Dbl_setnegativezerop1(resultp1); else Dbl_setzerop1(resultp1); /* */ if (Dbl_isinfinity_exponent(opnd1p1)) { if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { if (Dbl_isnotnan(opnd2p1,opnd2p2)) { if (Dbl_isinfinity(opnd2p1,opnd2p2)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } } else { /* */ if (Dbl_isone_signaling(opnd1p1)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* */ Set_invalidflag(); Dbl_set_quiet(opnd1p1); } /* */ else if (Dbl_is_signalingnan(opnd2p1)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* */ Dbl_copytoptr(opnd1p1,opnd1p2,dstptr); return(NOEXCEPTION); } } /* */ if (Dbl_isinfinity_exponent(opnd2p1)) { if (Dbl_iszero_mantissa(opnd2p1,opnd2p2)) { /* */ Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ if (Dbl_isone_signaling(opnd2p1)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); /* */ Set_invalidflag(); Dbl_set_quiet(opnd2p1); } /* */ Dbl_copytoptr(opnd2p1,opnd2p2,dstptr); return(NOEXCEPTION); } /* */ if (Dbl_iszero_exponentmantissa(opnd2p1,opnd2p2)) { if (Dbl_iszero_exponentmantissa(opnd1p1,opnd1p2)) { /* */ if (Is_invalidtrap_enabled()) return(INVALIDEXCEPTION); Set_invalidflag(); Dbl_makequietnan(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } if (Is_divisionbyzerotrap_enabled()) return(DIVISIONBYZEROEXCEPTION); Set_divisionbyzeroflag(); Dbl_setinfinity_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ dest_exponent = Dbl_exponent(opnd1p1) - Dbl_exponent(opnd2p1) + DBL_BIAS; /* */ if (Dbl_isnotzero_exponent(opnd1p1)) { /* */ Dbl_clear_signexponent_set_hidden(opnd1p1); } else { /* */ if (Dbl_iszero_mantissa(opnd1p1,opnd1p2)) { Dbl_setzero_exponentmantissa(resultp1,resultp2); Dbl_copytoptr(resultp1,resultp2,dstptr); return(NOEXCEPTION); } /* */ Dbl_clear_signexponent(opnd1p1); Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_normalize(opnd1p1,opnd1p2,dest_exponent); } /* */ if (Dbl_isnotzero_exponent(opnd2p1)) { Dbl_clear_signexponent_set_hidden(opnd2p1); } else { /* */ Dbl_clear_signexponent(opnd2p1); Dbl_leftshiftby1(opnd2p1,opnd2p2); while (Dbl_iszero_hiddenhigh7mantissa(opnd2p1)) { dest_exponent+=8; Dbl_leftshiftby8(opnd2p1,opnd2p2); } if (Dbl_iszero_hiddenhigh3mantissa(opnd2p1)) { dest_exponent+=4; Dbl_leftshiftby4(opnd2p1,opnd2p2); } while (Dbl_iszero_hidden(opnd2p1)) { dest_exponent++; Dbl_leftshiftby1(opnd2p1,opnd2p2); } } /* */ /* */ Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); Dbl_setzero(opnd3p1,opnd3p2); for (count=1; count <= DBL_P && (opnd1p1 || opnd1p2); count++) { Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1, opnd1p2, opnd2p1, opnd2p2); } } if (count <= DBL_P) { Dbl_leftshiftby1(opnd3p1,opnd3p2); Dbl_setone_lowmantissap2(opnd3p2); Dbl_leftshift(opnd3p1,opnd3p2,(DBL_P-count)); if (Dbl_iszero_hidden(opnd3p1)) { Dbl_leftshiftby1(opnd3p1,opnd3p2); dest_exponent--; } } else { if (Dbl_iszero_hidden(opnd3p1)) { /* */ Dbl_leftshiftby1(opnd1p1,opnd1p2); Dbl_leftshiftby1(opnd3p1,opnd3p2); if (Dbl_iszero_sign(opnd1p1)) { Dbl_setone_lowmantissap2(opnd3p2); Twoword_subtract(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } else { Twoword_add(opnd1p1,opnd1p2,opnd2p1,opnd2p2); } dest_exponent--; } if (Dbl_iszero_sign(opnd1p1)) guardbit = TRUE; stickybit = Dbl_allp1(opnd1p1) || Dbl_allp2(opnd1p2); } inexact = guardbit | stickybit; /* */ if (inexact && (dest_exponent > 0 || Is_underflowtrap_enabled())) { Dbl_clear_signexponent(opnd3p1); switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) Dbl_increment(opnd3p1,opnd3p2); break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } } if (Dbl_isone_hidden(opnd3p1)) dest_exponent++; } Dbl_set_mantissa(resultp1,resultp2,opnd3p1,opnd3p2); /* */ if (dest_exponent >= DBL_INFINITY_EXPONENT) { /* */ if (Is_overflowtrap_enabled()) { /* */ Dbl_setwrapped_exponent(resultp1,dest_exponent,ovfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(OVERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(OVERFLOWEXCEPTION); } Set_overflowflag(); /* */ Dbl_setoverflow(resultp1,resultp2); inexact = TRUE; } /* */ else if (dest_exponent <= 0) { /* */ if (Is_underflowtrap_enabled()) { /* */ Dbl_setwrapped_exponent(resultp1,dest_exponent,unfl); Dbl_copytoptr(resultp1,resultp2,dstptr); if (inexact) if (Is_inexacttrap_enabled()) return(UNDERFLOWEXCEPTION | INEXACTEXCEPTION); else Set_inexactflag(); return(UNDERFLOWEXCEPTION); } /* */ is_tiny = TRUE; if (dest_exponent == 0 && inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); if (Dbl_isone_hiddenoverflow(opnd3p1)) is_tiny = FALSE; Dbl_decrement(opnd3p1,opnd3p2); } break; } } /* */ stickybit = inexact; Dbl_denormalize(opnd3p1,opnd3p2,dest_exponent,guardbit, stickybit,inexact); /* */ if (inexact) { switch (Rounding_mode()) { case ROUNDPLUS: if (Dbl_iszero_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDMINUS: if (Dbl_isone_sign(resultp1)) { Dbl_increment(opnd3p1,opnd3p2); } break; case ROUNDNEAREST: if (guardbit && (stickybit || Dbl_isone_lowmantissap2(opnd3p2))) { Dbl_increment(opnd3p1,opnd3p2); } break; } if (is_tiny) Set_underflowflag(); } Dbl_set_exponentmantissa(resultp1,resultp2,opnd3p1,opnd3p2); } else Dbl_set_exponent(resultp1,dest_exponent); Dbl_copytoptr(resultp1,resultp2,dstptr); /* */ if (inexact) { if (Is_inexacttrap_enabled()) return(INEXACTEXCEPTION); else Set_inexactflag(); } return(NOEXCEPTION); }
int dbl_fcmp (dbl_floating_point * leftptr, dbl_floating_point * rightptr, unsigned int cond, unsigned int *status) /* */ { register unsigned int leftp1, leftp2, rightp1, rightp2; register int xorresult; /* */ Dbl_copyfromptr(leftptr,leftp1,leftp2); Dbl_copyfromptr(rightptr,rightp1,rightp2); /* */ if( (Dbl_exponent(leftp1) == DBL_INFINITY_EXPONENT) || (Dbl_exponent(rightp1) == DBL_INFINITY_EXPONENT) ) { /* */ if( ((Dbl_exponent(leftp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(leftp1,leftp2) && (Exception(cond) || Dbl_isone_signaling(leftp1))) || ((Dbl_exponent(rightp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(rightp1,rightp2) && (Exception(cond) || Dbl_isone_signaling(rightp1))) ) { if( Is_invalidtrap_enabled() ) { Set_status_cbit(Unordered(cond)); return(INVALIDEXCEPTION); } else Set_invalidflag(); Set_status_cbit(Unordered(cond)); return(NOEXCEPTION); } /* */ else if( ((Dbl_exponent(leftp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(leftp1,leftp2)) || ((Dbl_exponent(rightp1) == DBL_INFINITY_EXPONENT) && Dbl_isnotzero_mantissa(rightp1,rightp2)) ) { /* */ Set_status_cbit(Unordered(cond)); return(NOEXCEPTION); } /* */ } /* */ Dbl_xortointp1(leftp1,rightp1,xorresult); if( xorresult < 0 ) { /* */ if( Dbl_iszero_exponentmantissa(leftp1,leftp2) && Dbl_iszero_exponentmantissa(rightp1,rightp2) ) { Set_status_cbit(Equal(cond)); } else if( Dbl_isone_sign(leftp1) ) { Set_status_cbit(Lessthan(cond)); } else { Set_status_cbit(Greaterthan(cond)); } } /* */ else if(Dbl_isequal(leftp1,leftp2,rightp1,rightp2)) { Set_status_cbit(Equal(cond)); } else if( Dbl_iszero_sign(leftp1) ) { /* */ if( Dbl_allp1(leftp1) < Dbl_allp1(rightp1) ) { Set_status_cbit(Lessthan(cond)); } else if( Dbl_allp1(leftp1) > Dbl_allp1(rightp1) ) { Set_status_cbit(Greaterthan(cond)); } else { /* */ if( Dbl_allp2(leftp2) < Dbl_allp2(rightp2) ) { Set_status_cbit(Lessthan(cond)); } else { Set_status_cbit(Greaterthan(cond)); } } } else { /* */ if( Dbl_allp1(leftp1) > Dbl_allp1(rightp1) ) { Set_status_cbit(Lessthan(cond)); } else if( Dbl_allp1(leftp1) < Dbl_allp1(rightp1) ) { Set_status_cbit(Greaterthan(cond)); } else { /* */ if( Dbl_allp2(leftp2) > Dbl_allp2(rightp2) ) { Set_status_cbit(Lessthan(cond)); } else { Set_status_cbit(Greaterthan(cond)); } } } return(NOEXCEPTION); }