/* * 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); }
/* * 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_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); }