pub fn saturating_add(
    lhs: &PrimitiveArray<i128>,
    rhs: &PrimitiveArray<i128>,
) -> PrimitiveArray<i128> {
    let (precision, _) = get_parameters(lhs.data_type(), rhs.data_type()).unwrap();

    let max = max_value(precision);
    let op = move |a, b| {
        let res: i128 = a + b;

        if res.abs() > max {
            if res > 0 {
                max
            } else {
                -max
            }
        } else {
            res
        }
    };

    binary(lhs, rhs, lhs.data_type().clone(), op)
}
/// Saturated addition of two decimal primitive arrays with the same precision
/// and scale. If the precision and scale is different, then an
/// InvalidArgumentError is returned. If the result from the sum is larger than
/// the possible number with the selected precision then the resulted number in
/// the arrow array is the maximum number for the selected precision.
///
/// # Examples
/// ```
/// use arrow2::compute::arithmetics::decimal::saturating_add;
/// use arrow2::array::PrimitiveArray;
/// use arrow2::datatypes::DataType;
///
/// let a = PrimitiveArray::from([Some(99000i128), Some(11100i128), None, Some(22200i128)]).to(DataType::Decimal(5, 2));
/// let b = PrimitiveArray::from([Some(01000i128), Some(22200i128), None, Some(11100i128)]).to(DataType::Decimal(5, 2));
///
/// let result = saturating_add(&a, &b);
/// let expected = PrimitiveArray::from([Some(99999i128), Some(33300i128), None, Some(33300i128)]).to(DataType::Decimal(5, 2));
///
/// assert_eq!(result, expected);
/// ```
Saturated addition of two decimal primitive arrays with the same precision
and scale. If the precision and scale is different, then an
InvalidArgumentError is returned. If the result from the sum is larger than
the possible number with the selected precision then the resulted number in
the arrow array is the maximum number for the selected precision.
Saturated addition of two decimal primitive arrays with the same precision and scale . If the precision and scale is different then an InvalidArgumentError is returned . If the result from the sum is larger than the possible number with the selected precision then the resulted number in the arrow array is the maximum number for the selected precision .
pub fn saturating_add(
    lhs: &PrimitiveArray<i128>,
    rhs: &PrimitiveArray<i128>,
) -> PrimitiveArray<i128> {
    let (precision, _) = get_parameters(lhs.data_type(), rhs.data_type()).unwrap();
    let max = max_value(precision);
    let op = move |a, b| {
        let res: i128 = a + b;
        if res.abs() > max {
            if res > 0 {
                max
            } else {
                -max
            }
        } else {
            res
        }
    };
    binary(lhs, rhs, lhs.data_type().clone(), op)
}
pub fn saturating_add ( lhs : & PrimitiveArray < i128 > , rhs : & PrimitiveArray < i128 > , ) -> PrimitiveArray < i128 > { let ( precision , _ ) = get_parameters ( lhs . data_type ( ) , rhs . data_type ( ) ) . unwrap ( ) ; let max = max_value ( precision ) ; let op = move | a , b | { let res : i128 = a + b ; if res . abs ( ) > max { if res > 0 { max } else { - max } } else { res } } ; binary ( lhs , rhs , lhs . data_type ( ) . clone ( ) , op ) }
Saturated addition of two decimal primitive arrays with the same precision
and scale.
Saturated addition of two decimal primitive arrays with the same precision and scale .
lhs
&PrimitiveArray<i128>
rhs
&PrimitiveArray<i128>
lhs
&PrimitiveArray<i128>
rhs
&PrimitiveArray<i128>
examples
```
use arrow2::compute::arithmetics::decimal::saturating_add;
use arrow2::array::PrimitiveArray;
use arrow2::datatypes::DataType.





assert_eq!(result, expected);
```
` ` ` use arrow2 :: compute :: arithmetics :: decimal :: saturating_add ; use arrow2 :: array :: PrimitiveArray ; use arrow2 :: datatypes :: DataType . assert_eq! ( result expected ) ; ` ` `