Add Double::to_uint and Double::to_uint64

builtin/builtin.mbti

@@ -644,6 +644,7 @@ impl Double {
   to_int(Double) -> Int
   to_int64(Double) -> Int64
   to_json(Double) -> Json
+  to_uint64(Double) -> UInt64
   until(Double, Double, step~ : Double = .., inclusive~ : Bool = ..) -> Iter[Double]
   upto(Double, Double, inclusive~ : Bool = ..) -> Iter[Double] //deprecated
 }

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()
+}

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()
+  }
+}

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")
+}

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"

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)

double/double.mbti

@@ -40,6 +40,7 @@ impl Double {
   to_be_bytes(Double) -> Bytes
   to_le_bytes(Double) -> Bytes
   to_string(Double) -> String
+  to_uint(Double) -> UInt
   trunc(Double) -> Double
 }
 

double/moon.pkg.json

@@ -14,7 +14,9 @@
     "pow_nonjs.mbt": ["not", "js"],
     "round_js.mbt": ["js"],
     "round_wasm.mbt": ["wasm", "wasm-gc"],
-    "round.mbt": ["not", "js", "wasm", "wasm-gc"]
+    "round.mbt": ["not", "js", "wasm", "wasm-gc"],
+    "to_uint_wasm.mbt": ["wasm", "wasm-gc"],
+    "to_uint.mbt": ["not", "wasm", "wasm-gc"]
   },
   "test-import": [
     "moonbitlang/core/test"

double/to_uint.mbt

@@ -0,0 +1,54 @@
+// Copyright 2024 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+/// Converts a double-precision floating-point number to a 32-bit unsigned
+/// integer. Handles special cases including NaN and numbers outside the valid
+/// `UInt` range.
+///
+/// Parameters:
+///
+/// * `self` : The double-precision floating-point number to be converted.
+///
+/// Returns an 32-bit unsigned integer value according to the following rules:
+///
+/// * Returns 0 if the input is NaN
+/// * Returns `@uint.max_value` (4294967295U) if the input is greater than or
+///   equal to `@uint.max_value`
+/// * Returns `@uint.min_value` (0U) if the input is less than or equal
+///   to `@uint.min_value`
+/// * Otherwise returns the integer part of the input by truncating towards zero
+///
+/// Example:
+///
+/// ```moonbit
+/// test "Double::to_uint/normal" {
+///   inspect!(42.0.to_uint(), content="42")
+///   inspect!((-42.5).to_uint(), content="0")
+///   inspect!((0.0 / 0.0).to_uint(), content="0") // NaN
+///   inspect!((1.0 / 0.0).to_uint(), content="4294967295") // Infinity
+///   inspect!((-1.0 / 0.0).to_uint(), content="0") // -Infinity
+/// }
+/// ```
+pub fn Double::to_uint(self : Double) -> UInt {
+  if self != self {
+    0
+  } else if self >= 4294967295.0 {
+    4294967295U
+  } else if self <= 0 {
+    0
+  } else {
+    UInt::trunc_double(self)
+  }
+}

double/to_uint_test.mbt

@@ -0,0 +1,35 @@
+// Copyright 2024 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+test "Double::to_uint" {
+  inspect!(0.0.to_uint(), content="0")
+  inspect!(1.0.to_uint(), content="1")
+  inspect!(1.5.to_uint(), content="1")
+  inspect!(1.9.to_uint(), content="1")
+  inspect!(2.0.to_uint(), content="2")
+  inspect!(2.5.to_uint(), content="2")
+  inspect!(2.9.to_uint(), content="2")
+  inspect!((-1.0).to_uint(), content="0")
+  inspect!((-1.5).to_uint(), content="0")
+  inspect!((-1.9).to_uint(), content="0")
+  inspect!((-2.0).to_uint(), content="0")
+  inspect!((-2.5).to_uint(), content="0")
+  inspect!((-2.9).to_uint(), content="0")
+  inspect!((0.0 / 0.0).to_uint(), content="0")
+  inspect!((1.0 / 0.0).to_uint(), content="4294967295")
+  inspect!((-1.0 / 0.0).to_uint(), content="0")
+  inspect!(4294967295.0.to_uint(), content="4294967295")
+  inspect!((-4294967296.0).to_uint(), content="0")
+  inspect!(4294967296.0.to_uint(), content="4294967295")
+}