mrubyedge · udzura · Mar 29, 2026 · Mar 29, 2026 · Mar 29, 2026 · Mar 29, 2026
diff --git a/mrubyedge/src/yamrb/prelude/float.rs b/mrubyedge/src/yamrb/prelude/float.rs
@@ -17,6 +17,19 @@ pub(crate) fn initialize_float(vm: &mut VM) {
     mrb_define_cmethod(vm, float_class.clone(), "-@", Box::new(mrb_float_negative));
     mrb_define_cmethod(vm, float_class.clone(), "**", Box::new(mrb_float_power));
     mrb_define_cmethod(vm, float_class.clone(), "abs", Box::new(mrb_float_abs));
+    mrb_define_cmethod(
+        vm,
+        float_class.clone(),
+        "finite?",
+        Box::new(mrb_float_finite),
+    );
+    mrb_define_cmethod(
+        vm,
+        float_class.clone(),
+        "infinite?",
+        Box::new(mrb_float_infinite),
+    );
+    mrb_define_cmethod(vm, float_class.clone(), "nan?", Box::new(mrb_float_nan));
     mrb_define_cmethod(
         vm,
         float_class.clone(),
@@ -25,6 +38,20 @@ pub(crate) fn initialize_float(vm: &mut VM) {
     );
     mrb_define_cmethod(vm, float_class.clone(), "to_s", Box::new(mrb_float_inspect));
     mrb_define_cmethod(vm, float_class.clone(), "clamp", Box::new(mrb_float_clamp));
+
+    let mut const_table = float_class.consts.borrow_mut();
+    const_table.insert(
+        "INFINITY".to_string(),
+        RObject::float(f64::INFINITY).to_refcount_assigned(),
+    );
+    const_table.insert(
+        "NAN".to_string(),
+        RObject::float(f64::NAN).to_refcount_assigned(),
+    );
+    const_table.insert(
+        "EPSILON".to_string(),
+        RObject::float(f64::EPSILON).to_refcount_assigned(),
+    );
 }
 
 pub fn mrb_float_to_i(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
@@ -50,6 +77,42 @@ pub fn mrb_float_to_f(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>,
     }
 }
 
+pub fn mrb_float_finite(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
+    let this = vm.getself()?;
+    match &this.value {
+        crate::yamrb::value::RValue::Float(f) => {
+            Ok(RObject::boolean(f.is_finite()).to_refcount_assigned())
+        }
+        _ => Err(Error::RuntimeError(
+            "Float#finite? must be called on a Float".to_string(),
+        )),
+    }
+}
+
+pub fn mrb_float_infinite(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
+    let this = vm.getself()?;
+    match &this.value {
+        crate::yamrb::value::RValue::Float(f) => {
+            Ok(RObject::boolean(f.is_infinite()).to_refcount_assigned())
+        }
+        _ => Err(Error::RuntimeError(
+            "Float#infinite? must be called on a Float".to_string(),
+        )),
+    }
+}
+
+pub fn mrb_float_nan(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
+    let this = vm.getself()?;
+    match &this.value {
+        crate::yamrb::value::RValue::Float(f) => {
+            Ok(RObject::boolean(f.is_nan()).to_refcount_assigned())
+        }
+        _ => Err(Error::RuntimeError(
+            "Float#nan? must be called on a Float".to_string(),
+        )),
+    }
+}
+
 pub fn mrb_float_inspect(vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
     let this = vm.getself()?;
     match &this.value {

diff --git a/mrubyedge/tests/float.rs b/mrubyedge/tests/float.rs
@@ -2,7 +2,10 @@ extern crate mec_mrbc_sys;
 extern crate mrubyedge;
 
 mod helpers;
+use std::rc::Rc;
+
 use helpers::*;
+use mrubyedge::RObject;
 
 #[test]
 fn float_clamp_test() {
@@ -95,3 +98,88 @@ fn float_add_integer_test() {
     let result_float: f64 = result.as_ref().try_into().unwrap();
     assert_eq!(result_float, 8.5);
 }
+
+#[test]
+fn float_infinite_test() {
+    let code = r#"
+    def test_infinite
+      value = 1.0 / 0.0
+      value.infinite?
+    end
+    "#;
+    let binary = mrbc_compile("float_infinite", code);
+    let mut rite = mrubyedge::rite::load(&binary).unwrap();
+    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
+    vm.run().unwrap();
+
+    let args = vec![];
+    let result = mrb_funcall(&mut vm, None, "test_infinite", &args).unwrap();
+    let infinite: bool = result.as_ref().try_into().unwrap();
+    assert!(infinite);
+}
+
+#[test]
+fn float_finite_test() {
+    let code = r#"
+    def test_finite
+      value = 1.0 / 1.0
+      value.finite?
+    end
+    "#;
+    let binary = mrbc_compile("float_finite", code);
+    let mut rite = mrubyedge::rite::load(&binary).unwrap();
+    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
+    vm.run().unwrap();
+
+    let args = vec![];
+    let result = mrb_funcall(&mut vm, None, "test_finite", &args).unwrap();
+    let finite: bool = result.as_ref().try_into().unwrap();
+    assert!(finite);
+}
+
+#[test]
+fn float_nan_test() {
+    let code = r#"
+    def test_nan
+      value = 0.0 / 0.0
+      value.nan?
+    end
+    "#;
+    let binary = mrbc_compile("float_nan", code);
+    let mut rite = mrubyedge::rite::load(&binary).unwrap();
+    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
+    vm.run().unwrap();
+
+    let args = vec![];
+    let result = mrb_funcall(&mut vm, None, "test_nan", &args).unwrap();
+    let nan: bool = result.as_ref().try_into().unwrap();
+    assert!(nan);
+}
+
+#[test]
+fn float_constants_test() {
+    let code = r#"
+    def test_constants
+      [
+       Float::INFINITY,
+       Float::NAN,
+       Float::EPSILON
+      ]
+    end
+    "#;
+    let binary = mrbc_compile("float_constants", code);
+    let mut rite = mrubyedge::rite::load(&binary).unwrap();
+    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
+    vm.run().unwrap();
+
+    let args = vec![];
+    let result = mrb_funcall(&mut vm, None, "test_constants", &args).unwrap();
+    let constants: Vec<Rc<RObject>> = result.as_ref().try_into().unwrap();
+    let floats: Vec<f64> = constants
+        .iter()
+        .map(|c| c.as_ref().try_into().unwrap())
+        .collect::<Vec<_>>();
+    assert_eq!(floats[0], f64::INFINITY);
+    assert!(floats[1].is_nan());
+    assert_eq!(floats[2], f64::EPSILON);
+}