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

    let scale = 10i128.pow(scale as u32);
    let max = max_value(precision);

    let op = move |a: i128, b: i128| {
        let numeral: i128 = a * scale;

        match numeral.checked_div(b) {
            Some(res) => match res {
                res if res.abs() > max => None,
                _ => Some(res),
            },
            None => None,
        }
    };

    binary_checked(lhs, rhs, lhs.data_type().clone(), op)
}
/// Checked division 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 divisor is zero, then the
/// validity for that index is changed to None
///
/// # Examples
/// ```
/// use arrow2::compute::arithmetics::decimal::checked_div;
/// use arrow2::array::PrimitiveArray;
/// use arrow2::datatypes::DataType;
///
/// let a = PrimitiveArray::from([Some(1_00i128), Some(4_00i128), Some(6_00i128)]).to(DataType::Decimal(5, 2));
/// let b = PrimitiveArray::from([Some(000_00i128), None, Some(2_00i128)]).to(DataType::Decimal(5, 2));
///
/// let result = checked_div(&a, &b);
/// let expected = PrimitiveArray::from([None, None, Some(3_00i128)]).to(DataType::Decimal(5, 2));
///
/// assert_eq!(result, expected);
/// ```
Checked division 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 divisor is zero, then the
validity for that index is changed to None
Checked division 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 divisor is zero then the validity for that index is changed to None
pub fn checked_div(lhs: &PrimitiveArray<i128>, rhs: &PrimitiveArray<i128>) -> PrimitiveArray<i128> {
    let (precision, scale) = get_parameters(lhs.data_type(), rhs.data_type()).unwrap();
    let scale = 10i128.pow(scale as u32);
    let max = max_value(precision);
    let op = move |a: i128, b: i128| {
        let numeral: i128 = a * scale;
        match numeral.checked_div(b) {
            Some(res) => match res {
                res if res.abs() > max => None,
                _ => Some(res),
            },
            None => None,
        }
    };
    binary_checked(lhs, rhs, lhs.data_type().clone(), op)
}
pub fn checked_div ( lhs : & PrimitiveArray < i128 > , rhs : & PrimitiveArray < i128 > ) -> PrimitiveArray < i128 > { let ( precision , scale ) = get_parameters ( lhs . data_type ( ) , rhs . data_type ( ) ) . unwrap ( ) ; let scale = 10i128 . pow ( scale as u32 ) ; let max = max_value ( precision ) ; let op = move | a : i128 , b : i128 | { let numeral : i128 = a * scale ; match numeral . checked_div ( b ) { Some ( res ) => match res { res if res . abs ( ) > max => None , _ => Some ( res ) , } , None => None , } } ; binary_checked ( lhs , rhs , lhs . data_type ( ) . clone ( ) , op ) }
Checked division of two decimal primitive arrays with the same precision
and scale.
Checked division 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::checked_div;
use arrow2::array::PrimitiveArray;
use arrow2::datatypes::DataType.



let result = checked_div(&a, &b);
let expected = PrimitiveArray::from([None, None, Some(3_00i128)]).to(DataType::Decimal(5, 2)).

assert_eq!(result, expected);
```
` ` ` use arrow2 :: compute :: arithmetics :: decimal :: checked_div ; use arrow2 :: array :: PrimitiveArray ; use arrow2 :: datatypes :: DataType . let result = checked_div ( &a &b ) ; let expected = PrimitiveArray :: from ( [ None None Some ( 3_00i128 ) ] ) . to ( DataType :: Decimal ( 5 2 )) . assert_eq! ( result expected ) ; ` ` `