To ensure hash function works properly, use Zarith instead

Author: LdBeth

stdlib/Files

@@ -1,7 +1,6 @@
 STDLIB_FILES[] =
     lm_debug
     lm_nocompare
-    lm_big_int
     lm_num
     lm_rformat
     lm_rformat_raw

stdlib/OMakefile

@@ -3,6 +3,8 @@
 #
 OMakeVersion(0.9.8)
 
+OCAMLINCLUDES += $(CAMLLIB)/zarith
+
 #
 # Threads are optional
 #

stdlib/lm_num.ml

@@ -1,6 +1,5 @@
 (*
- * Our slow implementation of numbers
- * without using C libraries.
+ * Compatibility layer to Zarith library.
  *
  * ----------------------------------------------------------------
  *
@@ -37,29 +36,14 @@
  * Modified by: Yegor Bryukhov <[email protected]>
  * Modified by: Aleksey Nogin <[email protected]>
  *)
-open Lm_big_int
+
+(* Uses Zarith *)
 
 (************************************************************************
  * TYPES                                                                *
  ************************************************************************)
 
-(*
- * Have simple ints and big ints.
- *)
-type num =
-   Int of int
- | Big_int of big_int
-
-(*
- * This is the max value represented in an int.
- *)
-let shift_int = 30
-let max_int = pred (1 lsl shift_int)
-let min_int = -max_int
-
-let shift_mult_int = 15
-let max_mult_int = pred (1 lsl shift_mult_int)
-let min_mult_int = -max_mult_int
+type num = Z.t
 
 (************************************************************************
  * IMPLEMENTATIONS                                                      *
@@ -68,193 +52,56 @@ let min_mult_int = -max_mult_int
 (*
  * Catch overflows in addition.
  *)
-let add_num i j =
-   match i, j with
-      Int i, Int j ->
-         let sum = i + j in
-            if (i>0) && (j>0) then
-               if max_int - i < j then
-                  Big_int (add_big_int (big_int_of_int i) (big_int_of_int j))
-               else
-                  Int sum
-            else if (i<0) && (j<0) then
-               if min_int - i > j then
-                  Big_int (add_big_int (big_int_of_int i) (big_int_of_int j))
-               else
-                  Int sum
-            else
-               Int sum
-    | Int i, Big_int j ->
-         Big_int (add_big_int (big_int_of_int i) j)
-    | Big_int i, Int j ->
-         Big_int (add_big_int i (big_int_of_int j))
-    | Big_int i, Big_int j ->
-         Big_int (add_big_int i j)
+let add_num = Z.add
 
-let sub_num i j =
-   match i, j with
-      Int i, Int j ->
-         let diff = i - j in
-            if (i>0) && (j<0) then
-               if i > max_int + j then
-                  Big_int (sub_big_int (big_int_of_int i) (big_int_of_int j))
-               else
-                  Int diff
-            else if (i<0) && (j>0) then
-               if i < min_int + j then
-                  Big_int (sub_big_int (big_int_of_int i) (big_int_of_int j))
-               else
-                  Int diff
-            else
-               Int diff
-    | Int i, Big_int j ->
-         Big_int (sub_big_int (big_int_of_int i) j)
-    | Big_int i, Int j ->
-         Big_int (sub_big_int i (big_int_of_int j))
-    | Big_int i, Big_int j ->
-         Big_int (sub_big_int i j)
+let sub_num = Z.sub
 
-let succ_num i =
-   add_num i (Int 1)
+let succ_num = Z.succ
 
-let pred_num i =
-   sub_num i (Int 1)
-
-(*
- * Catch overflows in multiplication.
- *)
-let mult_int i j =
-   if (i >= min_mult_int) &&
-      (i <= max_mult_int) &&
-      (j >= min_mult_int) &&
-      (j <= max_mult_int)
-   then
-      Int (i * j)
-   else
-      Big_int (mult_big_int (big_int_of_int i) (big_int_of_int j))
+let pred_num = Z.pred
 
-let mult_num i j =
-   match i, j with
-      Int i, Int j ->
-         mult_int i j
-    | Int i, Big_int j ->
-         Big_int (mult_big_int (big_int_of_int i) j)
-    | Big_int i, Int j ->
-         Big_int (mult_big_int i (big_int_of_int j))
-    | Big_int i, Big_int j ->
-         Big_int (mult_big_int i j)
+let mult_num = Z.mul
 
-let div_num i j =
-   match i, j with
-      _ , Int 0 ->
-         raise (Invalid_argument "Lm_num.div_num: division by zero")
-    | Int i, Int j ->
-         Int (i / j)
-    | Int i, Big_int j ->
-         Big_int (div_big_int (big_int_of_int i) j)
-    | Big_int i, Int j ->
-         Big_int (div_big_int i (big_int_of_int j))
-    | Big_int i, Big_int j ->
-         Big_int (div_big_int i j)
+let div_num = Z.div
 
-let mod_num i j =
-   match i, j with
-      _ , Int 0 ->
-         raise (Invalid_argument "Lm_num.mod_num: division by zero")
-    | Int i, Int j ->
-         Int (i mod j)
-    | Int i, Big_int j ->
-         Big_int (mod_big_int (big_int_of_int i) j)
-    | Big_int i, Int j ->
-         Big_int (mod_big_int i (big_int_of_int j))
-    | Big_int i, Big_int j ->
-         Big_int (mod_big_int i j)
+let mod_num = Z.rem
 
 let quo_num = div_num
 let rem_num = mod_num
 
 (*
- * Power.  We stop large powers here--they will just take
- * forever.
+ * Power.
  *)
-let power_aux i j =
-   if j = 0 then
-      Int 1
-   else
-      let rec collect total j =
-         if j = 0 then
-            total
-         else
-            collect (mult_num total i) (pred j)
-      in
-         collect i (pred j)
 
 let power_num i j =
-   match j with
-      Int j ->
-         power_aux i j
-    | Big_int j ->
-         if is_integer_big_int j then
-            power_aux i (integer_big_int j)
-         else
-            raise (Invalid_argument "power_num: argument is too big")
+   if Z.fits_int j then
+      Z.pow i (Z.to_int j)
+   else
+      raise (Invalid_argument "power_num: argument is too big")
 
 (*
  * Absolute value.
  *)
-let abs_num = function
-   Int i ->
-      Int (abs i)
- | Big_int i ->
-      Big_int (abs_big_int i)
+let abs_num = Z.abs
 
-let neg_num = function
-   Int i ->
-      Int (-i)
- | Big_int i ->
-      Big_int (neg_big_int i)
+let neg_num = Z.neg
 
 (*
  * Equality.
  *)
-let eq_num i j =
-   match i, j with
-      Int i, Int j ->
-         i = j
-    | Int i, Big_int j ->
-         eq_big_int (big_int_of_int i) j
-    | Big_int i, Int j ->
-         eq_big_int i (big_int_of_int j)
-    | Big_int i, Big_int j ->
-         eq_big_int i j
+let eq_num = Z.equal
 
-let compare_num i j =
-   match i, j with
-      Int i, Int j ->
-         Pervasives.compare i j
-    | Int i, Big_int j ->
-         compare_big_int (big_int_of_int i) j
-    | Big_int i, Int j ->
-         compare_big_int i (big_int_of_int j)
-    | Big_int i, Big_int j ->
-         compare_big_int i j
+let compare_num = Z.compare
 
-let lt_num i j =
-   compare_num i j < 0
+let lt_num = Z.lt
 
-let le_num i j =
-   compare_num i j <= 0
+let le_num = Z.leq
 
-let gt_num i j =
-   compare_num i j > 0
+let gt_num = Z.gt
 
-let ge_num i j =
-   compare_num i j >= 0
+let ge_num = Z.geq
 
-let is_zero = function
-   Int 0 -> true
- | Int _ -> false
- | Big_int i -> is_zero_big_int i
+let is_zero n = Z.equal Z.zero n
 
 (************************************************************************
  * CONVERSION                                                           *
@@ -263,53 +110,22 @@ let is_zero = function
 (*
  * Integer conversions.
  *)
-let is_integer_num = function
-   Int _ ->
-      true
- | Big_int i ->
-      is_integer_big_int i
+let is_integer_num = Z.fits_int
 
-let integer_num = function
-   Int i ->
-      i
- | Big_int i ->
-      integer_big_int i
+let integer_num = Z.to_int
 
-let num_of_int i =
-   Int i
+let num_of_int = Z.of_int
 
 let int_of_num = integer_num
 
 (*
  * String conversions.
  *)
-let string_of_num = function
-   Int i ->
-      string_of_int i
- | Big_int i ->
-      string_of_big_int i
-
-let num_of_string s =
-   let i = big_int_of_string s in
-      if is_integer_big_int i then
-         Int (integer_big_int i)
-      else
-         Big_int i
-
-let to_string = string_of_num
-let of_string = num_of_string
-
-(*
- * Int32 conversions.
- *)
-let to_int32 = function
-   Int i ->
-      Int32.of_int i
- | Big_int i ->
-      Lm_big_int.to_int32 i
+let to_string = Z.to_string
+let of_string = Z.of_string
 
-let of_int32 i =
-   Big_int (Lm_big_int.of_int32 i)
+let string_of_num = to_string
+let num_of_string = of_string
 
 (*
  * -*-

stdlib/lm_num.mli

@@ -74,12 +74,10 @@ val integer_num : num -> int
 val num_of_int : int -> num
 val int_of_num : num -> int
 
-val string_of_num : num -> string
-val num_of_string : string -> num
 val to_string : num -> string
 val of_string : string -> num
-val to_int32 : num -> Int32.t
-val of_int32 : Int32.t -> num
+val string_of_num : num -> string
+val num_of_string : string -> num
 
 (*
  * -*-