Skip to content
Merged
Show file tree
Hide file tree
Changes from 9 commits
Commits
Show all changes
18 commits
Select commit Hold shift + click to select a range
c738c00
[FEA] Refactor operator functions
lamarrr Jun 10, 2026
09aa2dd
Update cpp/include/cudf/errc.hpp
lamarrr Jun 10, 2026
a9a6671
Refactor `if_else` and `coalesce` functions for improved type handling
lamarrr Jun 10, 2026
ebc30dc
Merge branch 'ansi-jit-2--1--operators-refactoring' of https://github…
lamarrr Jun 10, 2026
ec06bf7
Refactor `rescale` function to accept signed integer scale type and e…
lamarrr Jun 10, 2026
214205e
Merge branch 'main' into ansi-jit-2--1--operators-refactoring
lamarrr Jun 10, 2026
7c89aac
Merge branch 'main' into ansi-jit-2--1--operators-refactoring
lamarrr Jun 11, 2026
e60eef0
Refactor `rescale` function to enforce scale type size limit for impr…
lamarrr Jun 11, 2026
616762d
Merge branch 'ansi-jit-2--1--operators-refactoring' of https://github…
lamarrr Jun 11, 2026
83fd1cf
Refactor arithmetic functions to standardize naming conventions and i…
lamarrr Jun 12, 2026
20f9b4b
fix mod_overflow
lamarrr Jun 17, 2026
53bffc2
Updated documentation
lamarrr Jun 17, 2026
470c0cf
Merge branch 'main' into ansi-jit-2--1--operators-refactoring
lamarrr Jun 22, 2026
a9f84b0
Update copyright notices to include "AFFILIATES" in multiple header f…
lamarrr Jun 22, 2026
9110d09
Add checked arithmetic operations with overflow detection
lamarrr Jun 22, 2026
b7cc556
Merge branch 'main' into ansi-jit-2--1--operators-refactoring
lamarrr Jun 22, 2026
bb2b4c6
Merge branch 'main' into ansi-jit-2--1--operators-refactoring
lamarrr Jun 23, 2026
69c7854
Merge branch 'main' into ansi-jit-2--1--operators-refactoring
lamarrr Jun 23, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 7 additions & 7 deletions cpp/include/cudf/ast/detail/operator_functor.cuh
Original file line number Diff line number Diff line change
Expand Up @@ -45,9 +45,9 @@ CUDF_AST_OPERATOR_MAP(LESS, less, 2)
CUDF_AST_OPERATOR_MAP(GREATER, greater, 2)
CUDF_AST_OPERATOR_MAP(LESS_EQUAL, less_equal, 2)
CUDF_AST_OPERATOR_MAP(GREATER_EQUAL, greater_equal, 2)
CUDF_AST_OPERATOR_MAP(BITWISE_AND, bit_and, 2)
CUDF_AST_OPERATOR_MAP(BITWISE_OR, bit_or, 2)
CUDF_AST_OPERATOR_MAP(BITWISE_XOR, bit_xor, 2)
CUDF_AST_OPERATOR_MAP(BITWISE_AND, bitwise_and, 2)
CUDF_AST_OPERATOR_MAP(BITWISE_OR, bitwise_or, 2)
CUDF_AST_OPERATOR_MAP(BITWISE_XOR, bitwise_xor, 2)
CUDF_AST_OPERATOR_MAP(LOGICAL_AND, logical_and, 2)
CUDF_AST_OPERATOR_MAP(LOGICAL_OR, logical_or, 2)
CUDF_AST_OPERATOR_MAP(IDENTITY, identity, 1)
Expand All @@ -71,11 +71,11 @@ CUDF_AST_OPERATOR_MAP(CEIL, ceil, 1)
CUDF_AST_OPERATOR_MAP(FLOOR, floor, 1)
CUDF_AST_OPERATOR_MAP(ABS, abs, 1)
CUDF_AST_OPERATOR_MAP(RINT, rint, 1)
CUDF_AST_OPERATOR_MAP(BIT_INVERT, bit_invert, 1)
CUDF_AST_OPERATOR_MAP(BIT_INVERT, bitwise_invert, 1)
CUDF_AST_OPERATOR_MAP(NOT, logical_not, 1)
CUDF_AST_OPERATOR_MAP(CAST_TO_INT64, cast_to_i64, 1)
CUDF_AST_OPERATOR_MAP(CAST_TO_UINT64, cast_to_u64, 1)
CUDF_AST_OPERATOR_MAP(CAST_TO_FLOAT64, cast_to_f64, 1)
CUDF_AST_OPERATOR_MAP(CAST_TO_INT64, cast_to_int64, 1)
CUDF_AST_OPERATOR_MAP(CAST_TO_UINT64, cast_to_uint64, 1)
CUDF_AST_OPERATOR_MAP(CAST_TO_FLOAT64, cast_to_float64, 1)
CUDF_AST_OPERATOR_MAP(IS_NULL, is_null, 1)
CUDF_AST_OPERATOR_MAP(NULL_EQUAL, null_equal, 2)
CUDF_AST_OPERATOR_MAP(NULL_LOGICAL_AND, null_logical_and, 2)
Expand Down
136 changes: 76 additions & 60 deletions cpp/include/cudf/detail/operators/ansi_arithmetic.cuh
Original file line number Diff line number Diff line change
Expand Up @@ -5,8 +5,8 @@
#pragma once

#include <cudf/detail/operators/concepts.cuh>
#include <cudf/detail/operators/error.hpp>
#include <cudf/detail/operators/math.cuh>
#include <cudf/errc.hpp>
#include <cudf/fixed_point/fixed_point.hpp>
#include <cudf/utilities/export.hpp>

Expand All @@ -28,16 +28,18 @@ namespace ops {
* @param b Right operand.
* @return `errc::OVERFLOW` on overflow, else the result.
*/
template <integer T>
__device__ cuda::std::expected<T, errc> ansi_add(T a, T b)
template <integer A, integer B>
__device__ cuda::std::expected<A, errc> ansi_add(A a, B b)
requires(cuda::std::same_as<A, B>)
{
T r;
if (cuda::add_overflow(r, a, b).overflow) { return cuda::std::unexpected{errc::OVERFLOW}; }
Comment thread
PointKernel marked this conversation as resolved.
Resolved
A r;
if (cuda::add_overflow(r, a, b)) { return cuda::std::unexpected{errc::OVERFLOW}; }
return r;
}

template <floating_point T>
__device__ cuda::std::expected<T, errc> ansi_add(T a, T b)
template <floating_point A, floating_point B>
__device__ cuda::std::expected<A, errc> ansi_add(A a, B b)
requires(cuda::std::same_as<A, B>)
{
return a + b;
}
Expand All @@ -48,25 +50,27 @@ __device__ cuda::std::expected<T, errc> ansi_add(T a, T b)
* @tparam R Decimal representation type.
* @return `errc::OVERFLOW` on overflow, else the result.
*/
template <typename R>
__device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_add(numeric::decimal<R> a,
numeric::decimal<R> b)
template <typename A, typename B>
__device__ cuda::std::expected<numeric::decimal<A>, errc> ansi_add(numeric::decimal<A> a,
numeric::decimal<B> b)
requires(cuda::std::same_as<A, B>)
{
auto scale = cuda::std::min(a.scale(), b.scale());

if (numeric::addition_overflow<R>(a.rescaled(scale).value(), b.rescaled(scale).value())) {
if (numeric::addition_overflow<A>(a.rescaled(scale).value(), b.rescaled(scale).value())) {
return cuda::std::unexpected{errc::OVERFLOW};
}

return numeric::decimal<R>{numeric::scaled_integer<R>{
return numeric::decimal<A>{numeric::scaled_integer<A>{
a.rescaled(scale).value() + b.rescaled(scale).value(), numeric::scale_type{scale}}};
}

template <integer T>
__device__ cuda::std::expected<T, errc> ansi_sub(T a, T b)
template <integer A, integer B>
__device__ cuda::std::expected<A, errc> ansi_sub(A a, B b)
requires(cuda::std::same_as<A, B>)
{
T r;
if (cuda::sub_overflow(r, a, b).overflow) { return cuda::std::unexpected{errc::OVERFLOW}; }
A r;
if (cuda::sub_overflow(r, a, b)) { return cuda::std::unexpected{errc::OVERFLOW}; }
return r;
}

Expand All @@ -76,23 +80,25 @@ __device__ cuda::std::expected<T, errc> ansi_sub(T a, T b)
* @tparam T Value type.
* @return `errc::OVERFLOW` on overflow, else the result.
*/
template <floating_point T>
__device__ cuda::std::expected<T, errc> ansi_sub(T a, T b)
template <floating_point A, floating_point B>
__device__ cuda::std::expected<A, errc> ansi_sub(A a, B b)
requires(cuda::std::same_as<A, B>)
{
return a - b;
}

template <typename R>
__device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_sub(numeric::decimal<R> a,
numeric::decimal<R> b)
template <typename A, typename B>
__device__ cuda::std::expected<numeric::decimal<A>, errc> ansi_sub(numeric::decimal<A> a,
numeric::decimal<B> b)
requires(cuda::std::same_as<A, B>)
{
auto scale = cuda::std::min(a.scale(), b.scale());

if (numeric::subtraction_overflow<R>(a.rescaled(scale).value(), b.rescaled(scale).value())) {
if (numeric::subtraction_overflow<A>(a.rescaled(scale).value(), b.rescaled(scale).value())) {
return cuda::std::unexpected{errc::OVERFLOW};
}

return numeric::decimal<R>{numeric::scaled_integer<R>{
return numeric::decimal<A>{numeric::scaled_integer<A>{
a.rescaled(scale).value() - b.rescaled(scale).value(), numeric::scale_type{scale}}};
}

Expand All @@ -104,30 +110,33 @@ __device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_sub(numeric::deci
* @param b Right operand.
* @return `errc::OVERFLOW` on overflow, else the result.
*/
template <integer T>
__device__ cuda::std::expected<T, errc> ansi_mul(T a, T b)
template <integer A, integer B>
__device__ cuda::std::expected<A, errc> ansi_mul(A a, B b)
requires(cuda::std::same_as<A, B>)
{
T r;
if (cuda::mul_overflow(r, a, b).overflow) { return cuda::std::unexpected{errc::OVERFLOW}; }
A r;
if (cuda::mul_overflow(r, a, b)) { return cuda::std::unexpected{errc::OVERFLOW}; }
return r;
}

template <floating_point T>
__device__ cuda::std::expected<T, errc> ansi_mul(T a, T b)
template <floating_point A, floating_point B>
__device__ cuda::std::expected<A, errc> ansi_mul(A a, B b)
requires(cuda::std::same_as<A, B>)
{
return a * b;
}

template <typename R>
__device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_mul(numeric::decimal<R> a,
numeric::decimal<R> b)
template <typename A, typename B>
__device__ cuda::std::expected<numeric::decimal<A>, errc> ansi_mul(numeric::decimal<A> a,
numeric::decimal<B> b)
requires(cuda::std::same_as<A, B>)
{
if (numeric::multiplication_overflow<R>(a.value(), b.value())) {
if (numeric::multiplication_overflow<A>(a.value(), b.value())) {
return cuda::std::unexpected{errc::OVERFLOW};
}

return numeric::decimal<R>{
numeric::scaled_integer<R>{a.value() * b.value(), numeric::scale_type{a.scale() + b.scale()}}};
return numeric::decimal<A>{
numeric::scaled_integer<A>{a.value() * b.value(), numeric::scale_type{a.scale() + b.scale()}}};
}

/**
Expand All @@ -139,33 +148,36 @@ __device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_mul(numeric::deci
* @return `errc::DIVISION_BY_ZERO` on zero divisor, `errc::OVERFLOW` on overflow, else
* `errc::SUCCESS`.
*/
template <integer T>
__device__ cuda::std::expected<T, errc> ansi_div(T a, T b)
template <integer A, integer B>
__device__ cuda::std::expected<A, errc> ansi_div(A a, B b)
requires(cuda::std::same_as<A, B>)
{
if (b == 0) { return cuda::std::unexpected{errc::DIVISION_BY_ZERO}; }
T r;
if (cuda::div_overflow(r, a, b).overflow) { return cuda::std::unexpected{errc::OVERFLOW}; }
A r;
if (cuda::div_overflow(r, a, b)) { return cuda::std::unexpected{errc::OVERFLOW}; }
return r;
}

template <floating_point T>
__device__ cuda::std::expected<T, errc> ansi_div(T a, T b)
template <floating_point A, floating_point B>
__device__ cuda::std::expected<A, errc> ansi_div(A a, B b)
requires(cuda::std::same_as<A, B>)
{
return a / b;
}

template <typename R>
__device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_div(numeric::decimal<R> a,
numeric::decimal<R> b)
template <typename A, typename B>
__device__ cuda::std::expected<numeric::decimal<A>, errc> ansi_div(numeric::decimal<A> a,
numeric::decimal<B> b)
requires(cuda::std::same_as<A, B>)
{
if (b.value() == 0) { return cuda::std::unexpected{errc::DIVISION_BY_ZERO}; }

if (numeric::division_overflow<R>(a.value(), b.value())) {
if (numeric::division_overflow<A>(a.value(), b.value())) {
return cuda::std::unexpected{errc::OVERFLOW};
}

return numeric::decimal<R>{
numeric::scaled_integer<R>{a.value() / b.value(), numeric::scale_type{a.scale() - b.scale()}}};
return numeric::decimal<A>{
numeric::scaled_integer<A>{a.value() / b.value(), numeric::scale_type{a.scale() - b.scale()}}};
}

/**
Expand All @@ -176,37 +188,41 @@ __device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_div(numeric::deci
* @param b Divisor.
* @return `errc::DIVISION_BY_ZERO` on zero divisor, else the result.
*/
template <signed_integer T>
__device__ cuda::std::expected<T, errc> ansi_mod(T a, T b)
template <signed_integer A, signed_integer B>
__device__ cuda::std::expected<A, errc> ansi_mod(A a, B b)
requires(cuda::std::same_as<A, B>)
{
if (b == 0) { return cuda::std::unexpected{errc::DIVISION_BY_ZERO}; }

// avoid signed overflow UB / trap for minimum value divided by -1.
if (a == cuda::std::numeric_limits<T>::min() && b == T{-1}) { return T{0}; }
if (a == cuda::std::numeric_limits<A>::min() && b == A{-1}) { return A{0}; }

return a % b;
}

template <unsigned_integer T>
__device__ cuda::std::expected<T, errc> ansi_mod(T a, T b)
template <unsigned_integer A, unsigned_integer B>
__device__ cuda::std::expected<A, errc> ansi_mod(A a, B b)
requires(cuda::std::same_as<A, B>)
{
if (b == 0) { return cuda::std::unexpected{errc::DIVISION_BY_ZERO}; }
return a % b;
}

template <floating_point T>
__device__ cuda::std::expected<T, errc> ansi_mod(T a, T b)
template <floating_point A, floating_point B>
__device__ cuda::std::expected<A, errc> ansi_mod(A a, B b)
requires(cuda::std::same_as<A, B>)
{
if (b == 0) { return cuda::std::unexpected{errc::DIVISION_BY_ZERO}; }
return a - b * cuda::std::floor(a / b);
}

template <typename R>
__device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_mod(numeric::decimal<R> a,
numeric::decimal<R> b)
template <typename A, typename B>
__device__ cuda::std::expected<numeric::decimal<A>, errc> ansi_mod(numeric::decimal<A> a,
numeric::decimal<B> b)
requires(cuda::std::same_as<A, B>)
{
auto r = ansi_div(a, b);
if (r.has_error()) { return r.error(); }
if (!r.has_value()) { return cuda::std::unexpected{r.error()}; }
return a - b * floor(r.value());
}

Expand Down Expand Up @@ -284,9 +300,9 @@ __device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_neg(numeric::deci
* @param precision Maximum allowed precision.
* @return `errc::OVERFLOW` when precision is invalid or exceeded, else the result.
*/
template <typename R>
template <typename R, cuda::std::integral Precision>
__device__ cuda::std::expected<numeric::decimal<R>, errc> ansi_precision_check(
numeric::decimal<R> a, int32_t precision)
numeric::decimal<R> a, Precision precision)
{
if (precision <= 0) { return cuda::std::unexpected{errc::OVERFLOW}; }

Expand Down
12 changes: 6 additions & 6 deletions cpp/include/cudf/detail/operators/bitwise.cuh
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,7 @@ namespace ops {
* @param b Right operand.
*/
template <integer A, integer B>
__device__ auto bit_and(A a, B b) -> decltype(a & b)
__device__ auto bitwise_and(A a, B b) -> decltype(a & b)
{
return a & b;
}
Expand All @@ -32,7 +32,7 @@ __device__ auto bit_and(A a, B b) -> decltype(a & b)
* @param a Input value.
*/
template <integer T>
__device__ auto bit_invert(T a) -> decltype(~a)
__device__ auto bitwise_invert(T a) -> decltype(~a)
{
return ~a;
}
Expand All @@ -46,7 +46,7 @@ __device__ auto bit_invert(T a) -> decltype(~a)
* @param b Right operand.
*/
template <integer A, integer B>
__device__ auto bit_or(A a, B b) -> decltype(a | b)
__device__ auto bitwise_or(A a, B b) -> decltype(a | b)
{
return a | b;
}
Expand All @@ -60,7 +60,7 @@ __device__ auto bit_or(A a, B b) -> decltype(a | b)
* @param b Right operand.
*/
template <integer A, integer B>
__device__ auto bit_xor(A a, B b) -> decltype(a ^ b)
__device__ auto bitwise_xor(A a, B b) -> decltype(a ^ b)
{
return a ^ b;
}
Expand All @@ -74,7 +74,7 @@ __device__ auto bit_xor(A a, B b) -> decltype(a ^ b)
* @param b Shift count.
*/
template <integer A, integer B>
__device__ auto bit_shift_left(A a, B b) -> decltype(a << b)
__device__ auto bitwise_shift_left(A a, B b) -> decltype(a << b)
{
return a << b;
}
Expand All @@ -88,7 +88,7 @@ __device__ auto bit_shift_left(A a, B b) -> decltype(a << b)
* @param b Shift count.
*/
template <integer A, integer B>
__device__ auto bit_shift_right(A a, B b) -> decltype(a >> b)
__device__ auto bitwise_shift_right(A a, B b) -> decltype(a >> b)
{
return a >> b;
}
Expand Down
Loading
Loading