lib: add Float::is_approx to compare floats

[nit.git] / lib / standard / kernel.nit

diff --git a/lib/standard/kernel.nit b/lib/standard/kernel.nit
index e62cbea..2f2df4b 100644 (file)
--- a/lib/standard/kernel.nit
+++ b/lib/standard/kernel.nit
@@ -69,12 +69,6 @@ interface Object
        # only and can be removed without any notice
        fun output_class_name is intern 
 
-       # Quit the program with a specific return code
-       protected fun exit(exit_value: Int) is intern
-
-       # Return the global sys object, the only instance of the `Sys` class.
-       protected fun sys: Sys is intern
-
        # The hash code of the object.
        # Assuming that a == b -> a.hash == b.hash
        ##
@@ -89,12 +83,24 @@ class Sys
        # Instructions outside classes implicitly redefine this method.
        fun main do end
 
+       # The entry point for the execution of the whole program.
+       # Its job is to call `main` but some modules may want to refine it
+       # and inject specific work before or after the main part.
+       fun run do main
+
        # Number of the last error
        fun errno: Int is extern `{
                return errno;
        `}
 end
 
+# Quit the program with a specific return code
+fun exit(exit_value: Int) is intern
+
+# Return the global sys object, the only instance of the `Sys` class.
+fun sys: Sys is intern
+
+
 ###############################################################################
 # Abstract Classes                                                            #
 ###############################################################################
@@ -239,6 +245,14 @@ interface Numeric
 
        # The value of zero in the domain of `self`
        fun zero: OTHER is abstract
+
+       # The value of `val` in the domain of `self`
+       #
+       #     assert 1.0.value_of(2) == 2.0
+       #     assert 1.0.value_of(2.0) == 2.0
+       #     assert 1.value_of(2) == 2
+       #     assert 1.value_of(2.0) == 2
+       fun value_of(val: Numeric): OTHER is abstract
 end
 
 ###############################################################################
@@ -276,6 +290,8 @@ universal Float
        redef type OTHER: Float
 
        redef fun object_id is intern
+       redef fun ==(i) is intern
+       redef fun !=(i) is intern
        redef fun output is intern
 
        redef fun <=(i): Bool is intern
@@ -293,6 +309,60 @@ universal Float
        redef fun to_f do return self
 
        redef fun zero do return 0.0
+       redef fun value_of(val) do return val.to_f
+
+       redef fun <=>(other)
+       do
+               if self < other then
+                       return -1
+               else if other < self then
+                       return 1
+               else
+                       return 0
+               end
+       end
+
+       redef fun is_between(c, d)
+       do
+               if self < c or d < self then
+                       return false
+               else
+                       return true
+               end
+       end
+
+       # Compare float numbers with a given precision.
+       #
+       # Because of the loss of precision in floating numbers,
+       # the `==` method is often not the best way to compare them.
+       #
+       # ~~~
+       # assert 0.01.is_approx(0.02, 0.1)   == true
+       # assert 0.01.is_approx(0.02, 0.001) == false
+       # ~~~
+       fun is_approx(other, precision: Float): Bool
+       do
+               assert precision >= 0.0
+               return self <= other + precision and self >= other - precision
+       end
+
+       redef fun max(other)
+       do
+               if self < other then
+                       return other
+               else
+                       return self
+               end
+       end
+
+       redef fun min(c)
+       do
+               if c < self then
+                       return c
+               else
+                       return self
+               end
+       end
 end
 
 # Native integer numbers.
@@ -325,6 +395,7 @@ universal Int
        fun %(i: Int): Int is intern
 
        redef fun zero do return 0
+       redef fun value_of(val) do return val.to_i
 
        # `i` bits shift fo the left (aka <<)
        #