f16 working

Author: tgross35

src/math/generic/scalbn.rs

@@ -36,6 +36,7 @@ where
     F::Int: CastFrom<i32>,
     F::Int: CastFrom<u32>,
 {
+    dbg!();
     let zero = IntTy::<F>::ZERO;
 
     // Bits including the implicit bit
@@ -78,146 +79,58 @@ where
             }
         }
     } else if n < exp_min {
-        // WIP: for `f16` can this scale by `exp_max` rather than `(max - 1) - sig_bits`?
-        // That scale is only 3.
-        //
+        if F::BITS > 16 {
+            // WIP: for `f16` can this scale by `exp_max` rather than `(max - 1) - sig_bits`?
+            // That scale is only 3.
+            //
 
-        let mul = f_exp_min * f_exp_subnorm;
-        let add = -exp_min - sig_total_bits as i32;
-        dbg!(Hexf(mul), add);
+            let mul = f_exp_min * f_exp_subnorm;
+            let add = -exp_min - sig_total_bits as i32;
+            dbg!(Hexf(mul), add);
 
-        if n < exp_min - sig_total_bits as i32 {
-            dbg!("block 1");
-            x *= f_exp_min;
-            n += -exp_min;
-            dbg!(Hexf(x), n);
-
-            if n < exp_min - sig_total_bits as i32 {
-                x *= f_exp_min;
-                n += -exp_min;
-                dbg!(Hexf(x), n);
-
-                // if n < exp_min + sig_total_bits as i32 {
-                //     x *= f_exp_min;
-                //     n += -exp_min;
-
-                // if n < exp_min + sig_total_bits as i32 {
-                //     x *= f_exp_min;
-                //     n += -exp_min;
-                // }
+            x *= mul;
+            n += add;
 
+            if n < exp_min {
+                x *= mul;
+                n += add;
                 if n < exp_min {
-                    n = exp_min;
-                    dbg!(Hexf(x), n);
+                    x *= mul;
+                    n += add;
+                    if n < exp_min {
+                        n = exp_min;
+                        dbg!(Hexf(x), n);
+                    }
                 }
-                // }
-            } else if n < exp_min {
-                // only for f16
+            }
+        } else {
+            let add = (n + sig_total_bits as i32).clamp(exp_min, sig_total_bits as i32);
+            let mul = F::from_parts(false, (F::EXP_BIAS as i32 + add) as u32, zero);
+            let add = -add;
+            dbg!(add, Hexf(mul));
+
+            x *= mul;
+            n += add;
+            dbg!(Hexf(x), n);
+
+            if n < exp_min {
+                let add = (n + sig_total_bits as i32).clamp(exp_min, sig_total_bits as i32);
+                let mul = F::from_parts(false, (F::EXP_BIAS as i32 + add) as u32, zero);
+                let add = -add;
+                dbg!(add, Hexf(mul));
 
                 x *= mul;
                 n += add;
-
                 dbg!(Hexf(x), n);
+
                 if n < exp_min {
                     n = exp_min;
                     dbg!(Hexf(x), n);
                 }
             }
-        } else if n < exp_min {
-            // dbg!("block 2");
-            // // only for f16
-
-            // x *= mul;
-            // n += add;
-
-            // dbg!(Hexf(x), n);
-            // if n < exp_min {
-            //     n = exp_min;
-            //     dbg!(Hexf(x), n);
-            // }
+            // f16
         }
-
-        // if n < exp_min {
-        //     x *= mul;
-        //     n += add;
-        //     if n < exp_min {
-        //         // x *= mul;
-        //         // n += add;
-        //     }
-        // }
-
-        // // n += sig_total_bits as i32;
-
-        // // let mul = f_exp_min;
-        // // let add = -exp_min;
-        // let mut b = false;
-
-        // x *= mul;
-        // n += add;
-        // dbg!(Hexf(x), n);
-        // if n < exp_min {
-        //     x *= mul;
-        //     n += add;
-        //     dbg!(Hexf(x), n);
-        //     if F::BITS < 32 && false {
-        //         if n < exp_min {
-        //             x *= mul;
-        //             n += add;
-
-        //             dbg!(Hexf(x), n);
-        //             if n < exp_min {
-        //                 x *= mul;
-        //                 n += add;
-
-        //                 dbg!(Hexf(x), n);
-        //                 if n < exp_min {
-        //                     x *= mul;
-        //                     n += add;
-
-        //                     dbg!(Hexf(x), n);
-        //                     if n < exp_min {
-        //                         x *= mul;
-        //                         n += add;
-
-        //                         dbg!(Hexf(x), n);
-        //                         if n < exp_min {
-        //                             x *= mul;
-        //                             n += add;
-
-        //                             dbg!(Hexf(x), n);
-        //                             if n < exp_min {
-        //                                 x *= mul;
-        //                                 n += add;
-
-        //                                 dbg!(Hexf(x), n);
-        //                                 if n < exp_min {
-        //                                     x *= mul;
-        //                                     n += add;
-
-        //                                     dbg!(Hexf(x), n);
-        //                                     if n < exp_min {
-        //                                         n = exp_min;
-        //                                         dbg!(Hexf(x), n);
-        //                                     }
-        //                                 }
-        //                             }
-        //                         }
-        //                     }
-        //                 }
-        //             }
-        //         }
-        //     } else if n < exp_min + sig_total_bits as i32 {
-        //         n = exp_min;
-        //         b = true;
-        //         dbg!(Hexf(x), n);
-        //     }
-        // }
-
-        // if !b {
-        //     n -= sig_total_bits as i32;
-        // }
     }
-
     dbg!(Hexf(x), n);
     let scale = F::from_parts(false, (F::EXP_BIAS as i32 + n) as u32, zero);
     let ret = x * scale;