add Double::to_uint64()

moonbitlang · Jan 8, 2025 · 4766e84 · 4766e84
1 parent 8cf93bc
commit 4766e84
Show file tree

Hide file tree

Showing 5 changed files with 174 additions and 36 deletions.
diff --git a/builtin/double_to_int64_js.mbt b/builtin/double_to_int64_js.mbt
@@ -12,6 +12,36 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+///|
+extern "js" fn MyInt64::from_double(value : Double) -> MyInt64 =
+  #|(a) => {
+  #|  if (isNaN(a)) {
+  #|    return { hi: 0, lo: 0 };
+  #|  }
+  #|  if (a >= 9223372036854775807) {
+  #|    return { hi: 0x7fffffff, lo: 0xffffffff };
+  #|  }
+  #|  if (a <= -9223372036854775808) {
+  #|    return { hi: -2147483648, lo: 0 };
+  #|  }
+  #|  let neg = false;
+  #|  if (a < 0) {
+  #|    neg = true;
+  #|    a = -a;
+  #|  }
+  #|  let hi = (a * (1 / 0x100000000)) | 0;
+  #|  let lo = a >>> 0;
+  #|  if (neg) {
+  #|    if (lo === 0) {
+  #|      hi = ~hi + 1;
+  #|    } else {
+  #|      hi = ~hi;
+  #|      lo = ~lo + 1;
+  #|    }
+  #|  }
+  #|  return { hi, lo };
+  #|}
+
 ///|
 /// Converts a double-precision floating-point number to a 64-bit integer.
 /// Handles special cases including NaN and numbers outside the valid Int range.
@@ -43,3 +73,50 @@
 pub fn Double::to_int64(self : Double) -> Int64 {
   MyInt64::from_double(self).to_int64()
 }
+
+///|
+extern "js" fn MyInt64::from_double_unsigned(value : Double) -> MyInt64 =
+  #|(a) => {
+  #|  if (isNaN(a)) {
+  #|    return { hi: 0, lo: 0 };
+  #|  }
+  #|  if (a >= 18446744073709551615) {
+  #|    return { hi: 0xffffffff, lo: 0xffffffff };
+  #|  }
+  #|  if (a <= 0) {
+  #|    return { hi: 0, lo: 0 };
+  #|  }
+  #|  let hi = (a * (1 / 0x100000000)) | 0;
+  #|  let lo = a >>> 0;
+  #|  return { hi, lo };
+  #|}
+
+///|
+/// Converts a double-precision floating-point number to an unsigned 64-bit
+/// integer, handling special cases and value ranges.
+///
+/// Parameters:
+///
+/// * `value` : The double-precision floating-point number to be converted.
+///
+/// Returns an unsigned 64-bit integer value according to the following rules:
+///
+/// * Returns 0 if the input is NaN
+/// * Returns `UInt64::max_value` (18446744073709551615UL) if the input is
+/// greater than or equal to `UInt64::max_value`
+/// * Returns 0UL if the input is less than or equal to 0
+/// * Otherwise returns the integer part of the input by truncating towards zero
+///
+/// Example:
+///
+/// ```moonbit
+/// test "Double::to_uint64" {
+///   inspect!(42.0.to_uint64(), content="42")
+///   inspect!((-42.5).to_uint64(), content="0")
+///   inspect!((0.0 / 0.0).to_uint64(), content="0") // NaN
+///   inspect!((1.0 / 0.0).to_uint64(), content="18446744073709551615") // Infinity
+/// }
+/// ```
+pub fn Double::to_uint64(self : Double) -> UInt64 {
+  MyInt64::from_double_unsigned(self).to_uint64()
+}
diff --git a/builtin/double_to_int64_native.mbt b/builtin/double_to_int64_native.mbt
@@ -54,3 +54,46 @@ pub fn Double::to_int64(self : Double) -> Int64 {
     self.to_unchecked_int64()
   }
 }
+
+///|
+fn Double::to_unchecked_uint64(self : Double) -> UInt64 = "%f64_to_i64"
+
+///|
+/// Converts a double-precision floating-point number to a 64-bit integer.
+/// Handles special cases including NaN and numbers outside the valid Int range.
+///
+/// Parameters:
+///
+/// * `self` : The double-precision floating-point number to be converted.
+///
+/// Returns an 64-bit integer value according to the following rules:
+///
+/// * Returns 0 if the input is NaN
+/// * Returns `@int64.max_value` (9223372036854775807L) if the input is greater than or
+///   equal to `@int64.max_value`
+/// * Returns `@int64.min_value` (-9223372036854775808L) if the input is less than or equal
+///   to `@int64.min_value`
+/// * Otherwise returns the integer part of the input by truncating towards zero
+///
+/// Example:
+///
+/// ```moonbit
+/// test "Double::to_int64" {
+///   inspect!(42.0.to_int64(), content="42")
+///   inspect!((-42.5).to_int64(), content="-42")
+///   inspect!((0.0 / 0.0).to_int64(), content="0") // NaN
+///   inspect!((1.0 / 0.0).to_int64(), content="9223372036854775807") // Infinity
+///   inspect!((-1.0 / 0.0).to_int64(), content="-9223372036854775808") // -Infinity
+/// }
+/// ```
+pub fn Double::to_uint64(self : Double) -> UInt64 {
+  if self != self {
+    0
+  } else if self >= 9223372036854775807 {
+    18446744073709551615UL
+  } else if self <= 0 {
+    0UL
+  } else {
+    self.to_unchecked_uint64()
+  }
+}
diff --git a/builtin/double_to_int64_test.mbt b/builtin/double_to_int64_test.mbt
@@ -20,12 +20,12 @@ test "Double::to_int64" {
   inspect!(2.0.to_int64(), content="2")
   inspect!(2.5.to_int64(), content="2")
   inspect!(2.9.to_int64(), content="2")
-  inspect!(-1.0.to_int64(), content="-1")
-  inspect!(-1.5.to_int64(), content="-1")
-  inspect!(-1.9.to_int64(), content="-1")
-  inspect!(-2.0.to_int64(), content="-2")
-  inspect!(-2.5.to_int64(), content="-2")
-  inspect!(-2.9.to_int64(), content="-2")
+  inspect!((-1.0).to_int64(), content="-1")
+  inspect!((-1.5).to_int64(), content="-1")
+  inspect!((-1.9).to_int64(), content="-1")
+  inspect!((-2.0).to_int64(), content="-2")
+  inspect!((-2.5).to_int64(), content="-2")
+  inspect!((-2.9).to_int64(), content="-2")
   inspect!((0.0 / 0.0).to_int64(), content="0")
   inspect!((1.0 / 0.0).to_int64(), content="9223372036854775807")
   inspect!((-1.0 / 0.0).to_int64(), content="-9223372036854775808")
@@ -34,3 +34,23 @@ test "Double::to_int64" {
   inspect!(9223372036854775808.0.to_int64(), content="9223372036854775807")
   inspect!((-9223372036854775809.0).to_int64(), content="-9223372036854775808")
 }
+
+test "Double::to_uint64" {
+  inspect!(0.0.to_uint64(), content="0")
+  inspect!(1.0.to_uint64(), content="1")
+  inspect!(1.5.to_uint64(), content="1")
+  inspect!(1.9.to_uint64(), content="1")
+  inspect!(2.0.to_uint64(), content="2")
+  inspect!(2.5.to_uint64(), content="2")
+  inspect!(2.9.to_uint64(), content="2")
+  inspect!((-1.0).to_uint64(), content="0")
+  inspect!((-1.5).to_uint64(), content="0")
+  inspect!((-1.9).to_uint64(), content="0")
+  inspect!((-2.0).to_uint64(), content="0")
+  inspect!((-2.5).to_uint64(), content="0")
+  inspect!((-2.9).to_uint64(), content="0")
+  inspect!((0.0 / 0.0).to_uint64(), content="0")
+  inspect!((1.0 / 0.0).to_uint64(), content="18446744073709551615")
+  inspect!((-1.0 / 0.0).to_uint64(), content="0")
+  inspect!(18446744073709551615.0.to_uint64(), content="18446744073709551615")
+}
diff --git a/builtin/double_to_int64_wasm.mbt b/builtin/double_to_int64_wasm.mbt
@@ -41,3 +41,31 @@
 /// }
 /// ```
 pub fn Double::to_int64(self : Double) -> Int64 = "%f64_to_i64_saturate"
+
+///|
+/// Converts a double-precision floating-point number to an unsigned 64-bit
+/// integer, handling special cases and value ranges.
+///
+/// Parameters:
+///
+/// * `value` : The double-precision floating-point number to be converted.
+///
+/// Returns an unsigned 64-bit integer value according to the following rules:
+///
+/// * Returns 0 if the input is NaN
+/// * Returns `UInt64::max_value` (18446744073709551615UL) if the input is
+/// greater than or equal to `UInt64::max_value`
+/// * Returns 0UL if the input is less than or equal to 0
+/// * Otherwise returns the integer part of the input by truncating towards zero
+///
+/// Example:
+///
+/// ```moonbit
+/// test "Double::to_uint64" {
+///   inspect!(42.0.to_uint64(), content="42")
+///   inspect!((-42.5).to_uint64(), content="0")
+///   inspect!((0.0 / 0.0).to_uint64(), content="0") // NaN
+///   inspect!((1.0 / 0.0).to_uint64(), content="18446744073709551615") // Infinity
+/// }
+/// ```
+pub fn Double::to_uint64(self : Double) -> UInt64 = "%f64.to_u64_saturate"
diff --git a/builtin/int64_js.mbt b/builtin/int64_js.mbt
@@ -320,36 +320,6 @@ fn MyInt64::to_uint(self : MyInt64) -> UInt {
   self.lo.reinterpret_as_uint()
 }
 
-///|
-extern "js" fn MyInt64::from_double(value : Double) -> MyInt64 =
-  #|(a) => {
-  #|  if (isNaN(a)) {
-  #|    return { hi: 0, lo: 0 };
-  #|  }
-  #|  if (a >= 9223372036854775807) {
-  #|    return { hi: 0x7fffffff, lo: 0xffffffff };
-  #|  }
-  #|  if (a <= -9223372036854775808) {
-  #|    return { hi: -2147483648, lo: 0 };
-  #|  }
-  #|  let neg = false;
-  #|  if (a < 0) {
-  #|    neg = true;
-  #|    a = -a;
-  #|  }
-  #|  let hi = (a * (1 / 0x100000000)) | 0;
-  #|  let lo = a >>> 0;
-  #|  if (neg) {
-  #|    if (lo === 0) {
-  #|      hi = ~hi + 1;
-  #|    } else {
-  #|      hi = ~hi;
-  #|      lo = ~lo + 1;
-  #|    }
-  #|  }
-  #|  return { hi, lo };
-  #|}
-
 ///|
 extern "js" fn MyInt64::to_double(self : MyInt64) -> Double =
   #|(a) => a.hi * 4294967296.0 + (a.lo >>> 0)