From 0db08505bea8690218fefce408b27e83cc39cf55 Mon Sep 17 00:00:00 2001 From: Dennis Zhuang Date: Sat, 17 Oct 2026 22:54:32 +0800 Subject: [PATCH] refactor(promql): use the standard pow and atan2 in vector matching Results only need to agree with Prometheus within the relative tolerance promql-compat uses, so the ports of Go's math.Pow and math.Atan2 go; the Go results stay as a fixture compared within that tolerance. Signed-off-by: Dennis Zhuang --- src/promql/src/vector_match.rs | 5 +- src/promql/src/vector_match/go_math.rs | 256 ------------------------- src/promql/src/vector_match/tests.rs | 105 ++++++---- 3 files changed, 71 insertions(+), 295 deletions(-) delete mode 100644 src/promql/src/vector_match/go_math.rs diff --git a/src/promql/src/vector_match.rs b/src/promql/src/vector_match.rs index a01ab145014..02d829ec96b 100644 --- a/src/promql/src/vector_match.rs +++ b/src/promql/src/vector_match.rs @@ -31,7 +31,6 @@ use datatypes::series::time::{EvalGrid, TimeAxis}; use crate::grid_series::GridSeriesBuilder; -mod go_math; #[cfg(test)] mod tests; @@ -69,8 +68,8 @@ impl BinaryOp { Self::Mul => (lhs * rhs, true), Self::Div => (lhs / rhs, true), Self::Mod => (lhs % rhs, true), - Self::Pow => (go_math::pow(lhs, rhs), true), - Self::Atan2 => (go_math::atan2(lhs, rhs), true), + Self::Pow => (lhs.powf(rhs), true), + Self::Atan2 => (lhs.atan2(rhs), true), Self::Eq => (lhs, lhs == rhs), Self::Ne => (lhs, lhs != rhs), Self::Gt => (lhs, lhs > rhs), diff --git a/src/promql/src/vector_match/go_math.rs b/src/promql/src/vector_match/go_math.rs deleted file mode 100644 index 74dbe1cc381..00000000000 --- a/src/promql/src/vector_match/go_math.rs +++ /dev/null @@ -1,256 +0,0 @@ -// Copyright 2023 Greptime Team -// -// 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. - -//! Go's `math.Pow` and `math.Atan2`, which Prometheus' `^` and `atan2` use. They are not -//! correctly rounded, so the platform `powf`/`atan2` differ from them in the last bits. - -use std::f64::consts::PI; - -const MASK: u64 = 0x7FF; -const SHIFT: u32 = 64 - 11 - 1; -const BIAS: i64 = 1023; - -/// Go `math.Pow`. The integer part of the exponent is applied by repeated squaring, which is -/// exact on every platform; a fractional part goes through `exp(yf * ln(x))`, which Go itself -/// computes with platform-specific code. -pub(super) fn pow(x: f64, y: f64) -> f64 { - if y == 0.0 || x == 1.0 { - return 1.0; - } - if y == 1.0 { - return x; - } - if x.is_nan() || y.is_nan() { - return f64::NAN; - } - if x == 0.0 { - if y < 0.0 { - return if x.is_sign_negative() && is_odd_int(y) { - f64::NEG_INFINITY - } else { - f64::INFINITY - }; - } - return if x.is_sign_negative() && is_odd_int(y) { - x - } else { - 0.0 - }; - } - if y.is_infinite() { - return if x == -1.0 { - 1.0 - } else if (x.abs() < 1.0) == (y > 0.0) { - 0.0 - } else { - f64::INFINITY - }; - } - if x.is_infinite() { - if x < 0.0 { - return pow(1.0 / x, -y); - } - return if y < 0.0 { 0.0 } else { f64::INFINITY }; - } - if y == 0.5 { - return x.sqrt(); - } - if y == -0.5 { - return 1.0 / x.sqrt(); - } - - let (mut yi, mut yf) = (y.abs().trunc(), y.abs().fract()); - if yf != 0.0 && x < 0.0 { - return f64::NAN; - } - if yi >= (1u64 << 63) as f64 { - return if x == -1.0 { - 1.0 - } else if (x.abs() < 1.0) == (y > 0.0) { - 0.0 - } else { - f64::INFINITY - }; - } - - let mut a1 = 1.0; - let mut ae: i64 = 0; - if yf != 0.0 { - if yf > 0.5 { - yf -= 1.0; - yi += 1.0; - } - a1 = (yf * x.ln()).exp(); - } - - let (mut x1, mut xe) = frexp(x); - let mut i = yi as i64; - while i != 0 { - if !(-(1 << 12)..=(1 << 12)).contains(&xe) { - ae += xe; - break; - } - if i & 1 == 1 { - a1 *= x1; - ae += xe; - } - x1 *= x1; - xe <<= 1; - if x1 < 0.5 { - x1 += x1; - xe -= 1; - } - i >>= 1; - } - - if y < 0.0 { - a1 = 1.0 / a1; - ae = -ae; - } - ldexp(a1, ae) -} - -fn is_odd_int(x: f64) -> bool { - if x.abs() >= (1u64 << 53) as f64 { - return false; - } - x.fract() == 0.0 && (x.trunc() as i64) & 1 == 1 -} - -fn normalize(x: f64) -> (f64, i64) { - if x.abs() < f64::MIN_POSITIVE { - return (x * (1u64 << 52) as f64, -52); - } - (x, 0) -} - -fn frexp(f: f64) -> (f64, i64) { - if f == 0.0 || f.is_infinite() || f.is_nan() { - return (f, 0); - } - let (f, mut exp) = normalize(f); - let mut x = f.to_bits(); - exp += ((x >> SHIFT) & MASK) as i64 - BIAS + 1; - x &= !(MASK << SHIFT); - x |= ((-1 + BIAS) as u64) << SHIFT; - (f64::from_bits(x), exp) -} - -fn ldexp(frac: f64, exp: i64) -> f64 { - if frac == 0.0 || frac.is_infinite() || frac.is_nan() { - return frac; - } - let (frac, e) = normalize(frac); - let mut exp = exp + e; - let mut x = frac.to_bits(); - exp += ((x >> SHIFT) & MASK) as i64 - BIAS; - if exp < -1075 { - return 0.0_f64.copysign(frac); - } - if exp > 1023 { - return if frac < 0.0 { - f64::NEG_INFINITY - } else { - f64::INFINITY - }; - } - let mut m = 1.0; - if exp < -1022 { - exp += 53; - m = 1.0 / (1u64 << 53) as f64; - } - x &= !(MASK << SHIFT); - x |= ((exp + BIAS) as u64) << SHIFT; - m * f64::from_bits(x) -} - -/// Go `math.Atan2`. -pub(super) fn atan2(y: f64, x: f64) -> f64 { - if y.is_nan() || x.is_nan() { - return f64::NAN; - } - if y == 0.0 { - if x >= 0.0 && !x.is_sign_negative() { - return 0.0_f64.copysign(y); - } - return PI.copysign(y); - } - if x == 0.0 { - return (PI / 2.0).copysign(y); - } - if x.is_infinite() { - if x > 0.0 { - return if y.is_infinite() { - (PI / 4.0).copysign(y) - } else { - 0.0_f64.copysign(y) - }; - } - return if y.is_infinite() { - (3.0 * PI / 4.0).copysign(y) - } else { - PI.copysign(y) - }; - } - if y.is_infinite() { - return (PI / 2.0).copysign(y); - } - let q = atan(y / x); - if x < 0.0 { - if q <= 0.0 { - return q + PI; - } - return q - PI; - } - q -} - -fn atan(x: f64) -> f64 { - if x == 0.0 { - return x; - } - if x > 0.0 { satan(x) } else { -satan(-x) } -} - -// Constants are copied verbatim from Go's `math/atan.go`. -#[allow(clippy::excessive_precision)] -fn satan(x: f64) -> f64 { - const MOREBITS: f64 = 6.123233995736765886130e-17; - const TAN3PIO8: f64 = 2.41421356237309504880; - if x <= 0.66 { - return xatan(x); - } - if x > TAN3PIO8 { - return PI / 2.0 - xatan(1.0 / x) + MOREBITS; - } - PI / 4.0 + xatan((x - 1.0) / (x + 1.0)) + 0.5 * MOREBITS -} - -#[allow(clippy::excessive_precision)] -fn xatan(x: f64) -> f64 { - const P0: f64 = -8.750608600031904122785e-01; - const P1: f64 = -1.615753718733365076637e+01; - const P2: f64 = -7.500855792314704667340e+01; - const P3: f64 = -1.228866684490136173410e+02; - const P4: f64 = -6.485021904942025371773e+01; - const Q0: f64 = 2.485846490142306297962e+01; - const Q1: f64 = 1.650270098316988542046e+02; - const Q2: f64 = 4.328810604912902668951e+02; - const Q3: f64 = 4.853903996359136964868e+02; - const Q4: f64 = 1.945506571482613964425e+02; - let mut z = x * x; - z = z * ((((P0 * z + P1) * z + P2) * z + P3) * z + P4) - / (((((z + Q0) * z + Q1) * z + Q2) * z + Q3) * z + Q4); - x * z + x -} diff --git a/src/promql/src/vector_match/tests.rs b/src/promql/src/vector_match/tests.rs index 0170783a3b4..8399f08199c 100644 --- a/src/promql/src/vector_match/tests.rs +++ b/src/promql/src/vector_match/tests.rs @@ -703,7 +703,7 @@ fn vector_operations_match_prometheus() { .iter() .map(|series| (labels_of(&series.metric), points_of(series))) .collect(); - assert_eq!(actual, expected, "{case}"); + assert_close(&actual, &expected, case); matched += 1; } (Err(actual), Some(expected)) => { @@ -728,41 +728,6 @@ fn vector_operations_match_prometheus() { ); } -/// Prometheus' `^` and `atan2` are Go's `math.Pow` and `math.Atan2`. Integer exponents and -/// `atan2` are exact. A fractional exponent goes through Go's `math.Exp`/`math.Log`, which are -/// assembly on amd64; the port uses the Rust ones, within 2 ulps. -#[test] -fn pow_and_atan2_match_go() { - let mut checked = 0; - for line in include_str!("go_math_cases.txt").lines() { - if line.starts_with('#') { - continue; - } - let fields: Vec<&str> = line.split(' ').collect(); - let bits = |field: &str| u64::from_str_radix(field, 16).unwrap(); - let (a, b) = ( - f64::from_bits(bits(fields[1])), - f64::from_bits(bits(fields[2])), - ); - let expected = bits(fields[3]); - let (actual, tolerance) = match fields[0] { - "pow" => ( - BinaryOp::Pow.apply(a, b).0, - if b.fract() == 0.0 { 0 } else { 2 }, - ), - "atan2" => (BinaryOp::Atan2.apply(a, b).0, 0), - function => panic!("unknown function {function}"), - }; - assert!( - (actual.to_bits() as i64 - expected as i64).abs() <= tolerance, - "{line}: got {:x}", - actual.to_bits() - ); - checked += 1; - } - assert_eq!(checked, 452); -} - /// Results that share a label set once `__type__` is dropped fail as a grouping violation within /// one match group, and as duplicate label sets across match groups, which Prometheus detects /// only after the operator. @@ -812,3 +777,71 @@ fn colliding_results_fail_by_where_they_collide() { assert!(error.contains(expected), "{error}"); } } + +/// Prometheus `almost.Equal` with relative tolerance 1e-10, treating results below 1e-10 as +/// equal and any NaN as equal to NaN, as promql-compat compares engines. +fn close(a: f64, b: f64) -> bool { + const EPSILON: f64 = 1e-10; + if a.is_nan() || b.is_nan() { + return a.is_nan() && b.is_nan(); + } + if a == b { + return true; + } + let (diff, sum) = ((a - b).abs(), a.abs() + b.abs()); + let equal = if a == 0.0 || b == 0.0 || sum < f64::MIN_POSITIVE { + diff < EPSILON * f64::MIN_POSITIVE + } else { + diff / sum.min(f64::MAX) < EPSILON + }; + equal || (a.abs() < EPSILON && b.abs() < EPSILON) +} + +fn assert_close( + actual: &BTreeMap>, + expected: &BTreeMap>, + case: &str, +) { + let points = |series: &BTreeMap>| { + series + .iter() + .map(|(labels, points)| (labels.clone(), points.keys().copied().collect::>())) + .collect::>() + }; + assert_eq!(points(actual), points(expected), "{case}"); + for (labels, points) in actual { + for (point, &bits) in points { + let (got, want) = ( + f64::from_bits(bits), + f64::from_bits(expected[labels][point]), + ); + assert!( + close(got, want), + "{case}: {labels:?} at {point}: {got} vs {want}" + ); + } + } +} + +/// Prometheus' `^` and `atan2` are Go's `math.Pow` and `math.Atan2`; the standard library +/// agrees within the comparison tolerance, special cases included. +#[test] +fn pow_and_atan2_match_go() { + let mut checked = 0; + for line in include_str!("go_math_cases.txt").lines() { + if line.starts_with('#') { + continue; + } + let fields: Vec<&str> = line.split(' ').collect(); + let value = |field: &str| f64::from_bits(u64::from_str_radix(field, 16).unwrap()); + let (a, b, expected) = (value(fields[1]), value(fields[2]), value(fields[3])); + let actual = match fields[0] { + "pow" => BinaryOp::Pow.apply(a, b).0, + "atan2" => BinaryOp::Atan2.apply(a, b).0, + function => panic!("unknown function {function}"), + }; + assert!(close(actual, expected), "{line}: got {actual}"); + checked += 1; + } + assert_eq!(checked, 452); +}