Add math.frexp

youknowone · youknowone · commit d223af645b8b · 2019-05-17T01:12:43.000+09:00
diff --git a/tests/snippets/math_module.py b/tests/snippets/math_module.py
@@ -1,5 +1,5 @@
 import math
-from testutils import assertRaises
+from testutils import assertRaises, assert_raises
 
 # assert(math.exp(2) == math.exp(2.0))
 # assert(math.exp(True) == math.exp(1.0))
@@ -78,3 +78,12 @@ def __floor__(self):
     math.ceil(object())
 with assertRaises(TypeError):
     math.floor(object())
+
+assert str(math.frexp(0.0)) == str((+0.0, 0))
+assert str(math.frexp(-0.0)) == str((-0.0, 0))
+assert math.frexp(1) == (0.5, 1)
+assert math.frexp(1.5) == (0.75, 1)
+
+assert math.frexp(float('inf')) == (float('inf'), 0)
+assert str(math.frexp(float('nan'))) == str((float('nan'), 0))
+assert_raises(TypeError, lambda: math.frexp(None))
diff --git a/vm/src/obj/objfloat.rs b/vm/src/obj/objfloat.rs
@@ -298,6 +298,11 @@ impl PyFloat {
         )
     }
 
+    #[pymethod(name = "__pos__")]
+    fn pos(&self, _vm: &VirtualMachine) -> f64 {
+        self.value
+    }
+
     #[pymethod(name = "__neg__")]
     fn neg(&self, _vm: &VirtualMachine) -> f64 {
         -self.value
@@ -475,6 +480,17 @@ impl PyFloat {
     }
 }
 
+pub fn ufrexp(value: f64) -> (f64, i32) {
+    if 0.0 == value {
+        (0.0, 0i32)
+    } else {
+        let bits = value.to_bits();
+        let exponent: i32 = ((bits >> 52) & 0x7ff) as i32 - 1022;
+        let mantissa_bits = bits & (0x000fffffffffffff) | (1022 << 52);
+        (f64::from_bits(mantissa_bits), exponent)
+    }
+}
+
 pub type PyFloatRef = PyRef<PyFloat>;
 
 // Retrieve inner float value:
diff --git a/vm/src/pyhash.rs b/vm/src/pyhash.rs
@@ -1,5 +1,6 @@
 use std::hash::{Hash, Hasher};
 
+use crate::obj::objfloat;
 use crate::pyobject::PyObjectRef;
 use crate::pyobject::PyResult;
 use crate::vm::VirtualMachine;
@@ -28,14 +29,7 @@ pub fn hash_float(value: f64) -> PyHash {
         };
     }
 
-    let frexp = if 0.0 == value {
-        (value, 0i32)
-    } else {
-        let bits = value.to_bits();
-        let exponent: i32 = ((bits >> 52) & 0x7ff) as i32 - 1022;
-        let mantissa_bits = bits & (0x000fffffffffffff) | (1022 << 52);
-        (f64::from_bits(mantissa_bits), exponent)
-    };
+    let frexp = objfloat::ufrexp(value);
 
     // process 28 bits at a time;  this should work well both for binary
     // and hexadecimal floating point.
diff --git a/vm/src/stdlib/math.rs b/vm/src/stdlib/math.rs
@@ -209,6 +209,23 @@ fn math_floor(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
     }
 }
 
+fn math_frexp(value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    objfloat::try_float(&value, vm)?.map_or_else(
+        || Err(vm.new_type_error(format!("must be real number, not {}", value.class()))),
+        |value| {
+            let (m, e) = if value.is_finite() {
+                let (m, e) = objfloat::ufrexp(value);
+                (m * value.signum(), e)
+            } else {
+                (value, 0)
+            };
+            Ok(vm
+                .ctx
+                .new_tuple(vec![vm.ctx.new_float(m), vm.ctx.new_int(e)]))
+        },
+    )
+}
+
 pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     let ctx = &vm.ctx;
 
@@ -256,6 +273,8 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "gamma" => ctx.new_rustfunc(math_gamma),
         "lgamma" => ctx.new_rustfunc(math_lgamma),
 
+        "frexp" => ctx.new_rustfunc(math_frexp),
+
         // Rounding functions:
         "trunc" => ctx.new_rustfunc(math_trunc),
         "ceil" => ctx.new_rustfunc(math_ceil),
