/// $x / y$, ignoring signs of x and y for the division.  
/// x and y must have a non-empty mantissa and valid exponent.
$x / y$, ignoring signs of x and y for the division.
x and y must have a non-empty mantissa and valid exponent.
$x / y$ ignoring signs of x and y for the division . x and y must have a non - empty mantissa and valid exponent .
fn uquo(&mut self, y: &Float) {
        // mantissa length in words for desired result precision + 1
        // (at least one extra bit so we get the rounding bit after
        // the division)
        let n = (self.prec >> 5) as isize + 1;
        // compute adjusted x.mant such that we get enough result precision
        let d = n - (self.mant.as_vec().len() as isize) + (y.mant.as_vec().len() as isize);
        let xadj = if d > 0 {
            let tmp = self.mant.deep_clone();
            tmp.as_mut_vec().resize(((self.mant.as_vec().len() as isize) + d) as usize, 0);
            tmp
        } else {
            self.mant.clone()
        };
        // Compute d before division since there may be aliasing of x.mant
        // (via xadj) or y.mant with z.mant.
        let d = (xadj.as_vec().len() as isize) - (y.mant.as_vec().len() as isize);
        // divide
        let (quo, rem) = (xadj.clone() / y.mant.clone(), xadj.clone() % y.mant.clone());
        self.mant.clear();
        self.mant.as_mut_vec().extend(quo.iter());
        let e = self.exp - y.exp - ((d - (self.mant.as_vec().len() as isize)) << 5);
        // The result is long enough to include (at least) the rounding bit.
        // If there's a non-zero remainder, the corresponding fractional part
        // (if it were computed), would have a non-zero sticky bit (if it were
        // zero, it couldn't have a non-zero remainder).
        let sbit = if rem > 0u32 {
            1
        } else {
            0
        };
        let s = Self::fnorm(&mut self.mant) as isize;
        self.set_exp_and_round(e - s, sbit);
    }
fn uquo ( & mut self , y : & Float ) { // mantissa length in words for desired result precision + 1 // (at least one extra bit so we get the rounding bit after // the division) let n = ( self . prec >> 5 ) as isize + 1 ; // compute adjusted x.mant such that we get enough result precision let d = n - ( self . mant . as_vec ( ) . len ( ) as isize ) + ( y . mant . as_vec ( ) . len ( ) as isize ) ; let xadj = if d > 0 { let tmp = self . mant . deep_clone ( ) ; tmp . as_mut_vec ( ) . resize ( ( ( self . mant . as_vec ( ) . len ( ) as isize ) + d ) as usize , 0 ) ; tmp } else { self . mant . clone ( ) } ; // Compute d before division since there may be aliasing of x.mant // (via xadj) or y.mant with z.mant. let d = ( xadj . as_vec ( ) . len ( ) as isize ) - ( y . mant . as_vec ( ) . len ( ) as isize ) ; // divide let ( quo , rem ) = ( xadj . clone ( ) / y . mant . clone ( ) , xadj . clone ( ) % y . mant . clone ( ) ) ; self . mant . clear ( ) ; self . mant . as_mut_vec ( ) . extend ( quo . iter ( ) ) ; let e = self . exp - y . exp - ( ( d - ( self . mant . as_vec ( ) . len ( ) as isize ) ) << 5 ) ; // The result is long enough to include (at least) the rounding bit. // If there's a non-zero remainder, the corresponding fractional part // (if it were computed), would have a non-zero sticky bit (if it were // zero, it couldn't have a non-zero remainder). let sbit = if rem > 0u32 { 1 } else { 0 } ; let s = Self :: fnorm ( & mut self . mant ) as isize ; self . set_exp_and_round ( e - s , sbit ) ; }
$x / y$, ignoring signs of x and y for the division.
$x / y$ ignoring signs of x and y for the division .
&mut self
y
&Float