feat: enable the nightly feature for gamma/ln_gamma function

Signed-off-by: Alan Tang <[email protected]>

Author: Standing-Man

Cargo.lock

@@ -35,6 +35,7 @@
 #![feature(register_tool)]
 #![feature(btree_cursors)]
 #![feature(assert_matches)]
+#![feature(float_gamma)]
 #![feature(anonymous_lifetime_in_impl_trait)]
 #![feature(vec_into_raw_parts)]
 #![feature(exact_div)]

src/common/src/lib.rs

@@ -578,6 +578,17 @@ impl<T: One> One for OrderedFloat<T> {
     }
 }
 
+impl OrderedFloat<f64> {
+    pub fn gamma(self) -> Self {
+        OrderedFloat(self.0.gamma())
+    }
+
+    pub fn ln_gamma(self) -> (Self, i32) {
+        let (result, sign) = self.0.ln_gamma();
+        (OrderedFloat(result), sign)
+    }
+}
+
 /// Similar to [`num_traits::Float`], but without requiring `NumCast` and `ToPrimitive`.
 #[easy_ext::ext(FloatExt)]
 pub impl<T: Float> OrderedFloat<T>

src/common/src/types/ordered_float.rs

@@ -59,7 +59,6 @@ serde_json = "1"
 sha1 = "0.10"
 sha2 = "0.10"
 smallvec = { workspace = true }
-special = "0.11.4"
 sql-json-path = { version = "0.1.1", features = ["jsonbb"] }
 thiserror = { workspace = true }
 thiserror-ext = { workspace = true }

src/expr/impl/Cargo.toml

@@ -21,7 +21,6 @@ use risingwave_common::types::{
 };
 use risingwave_expr::{ExprError, Result, function};
 use rust_decimal::MathematicalOps;
-use special::{Gamma, Primitive};
 
 #[function("add(*int, *int) -> auto")]
 #[function("add(decimal, decimal) -> auto")]
@@ -448,13 +447,13 @@ pub fn decimal_trim_scale(d: Decimal) -> Decimal {
 /// ----
 /// NaN
 ///
-/// statement error
+/// statement error overflow
 /// SELECT gamma('-inf'::float8);
 ///
 /// query R
 /// SELECT gamma('0.5'::float8);
 /// ----
-/// 1.7724538509055159
+/// 1.772453850905516
 ///
 /// query R
 /// SELECT gamma('1'::float8);
@@ -481,16 +480,16 @@ pub fn decimal_trim_scale(d: Decimal) -> Decimal {
 /// ----
 /// 24
 ///
-/// statement error
+/// statement error overflow
 /// SELECT gamma('-1'::float8);
 ///
-/// statement error
+/// statement error underflow
 /// SELECT gamma('-1000.5'::float8);
 ///
-/// statement error
+/// statement error overflow
 /// SELECT gamma('0'::float8);
 ///
-/// statement error
+/// statement error overflow
 /// SELECT gamma('1000'::float8);
 /// ```
 #[function("gamma(float8) -> float8")]
@@ -500,30 +499,18 @@ pub fn gamma_f64(input: F64) -> Result<F64> {
         return Ok(result);
     } else if input.is_infinite() {
         if input.is_negative() {
-            return Err(ExprError::InvalidParam {
-                name: "gamma",
-                reason: "value out of range: overflow".into(),
-            });
+            return Err(ExprError::NumericOverflow);
         }
     } else {
-        result = F64::from(Gamma::gamma(input.0));
+        result = input.gamma();
         if result.is_nan() || result.is_infinite() {
             if !result.is_zero() {
-                return Err(ExprError::InvalidParam {
-                    name: "gamma",
-                    reason: "value out of range: overflow".into(),
-                });
+                return Err(ExprError::NumericOverflow);
             } else {
-                return Err(ExprError::InvalidParam {
-                    name: "gamma",
-                    reason: "value out of range: underflow".into(),
-                });
+                return Err(ExprError::NumericUnderflow);
             }
         } else if result.is_zero() {
-            return Err(ExprError::InvalidParam {
-                name: "gamma",
-                reason: "value out of range: underflow".into(),
-            });
+            return Err(ExprError::NumericUnderflow);
         }
     }
     Ok(result)
@@ -575,33 +562,30 @@ pub fn gamma_f64(input: F64) -> Result<F64> {
 /// ----
 /// 3.1780538303479458
 ///
-/// statement error
+/// statement error overflow
 /// SELECT lgamma('-1'::float8);
 ///
 /// query R
 /// SELECT lgamma('-1000.5'::float8);
 /// ----
 /// -5914.437701116853
 ///
-/// statement error
+/// statement error overflow
 /// SELECT gamma('0'::float8);
 ///
 /// query R
 /// SELECT lgamma('1000'::float8);
 /// ----
 /// 5905.220423209181
 ///
-/// statement error
+/// statement error overflow
 /// SELECT gamma('1e308'::float8);
 /// ```
 #[function("lgamma(float8) -> float8")]
 pub fn lgamma_f64(input: F64) -> Result<F64> {
-    let (result, _sign) = input.0.lgamma();
+    let (result, _sign) = input.ln_gamma();
     if result.is_infinite() && input.is_finite() {
-        return Err(ExprError::InvalidParam {
-            name: "lgamma",
-            reason: "value out of range: overflow".into(),
-        });
+        return Err(ExprError::NumericOverflow);
     }
     Ok(F64::from(result))
 }