Compiler Explorer

Source code

#![no_std]

/*
#[no_mangle]
pub fn midpoint_i64_wider(a: i64, b: i64) -> i64 {
    ((a as i128 + b as i128) / 2) as i64
}

#[no_mangle]
pub fn midpoint_i64_hackers(a: i64, b: i64) -> i64 {
    // Use the well known branchless algorithm from Hacker's Delight to compute
    // `(a + b) / 2` without overflowing: `((a ^ b) >> 1) + (a & b)`.
    let t = ((a ^ b) >> 1) + (a & b);
    // Except that it fails for integers whose sum is an odd negative number as
    // their floor is one less than their average. So we adjust the result.
    t + (if t < 0 { 1 } else { 0 } & (a ^ b))
}
*/

#[no_mangle]
pub fn midpoint_i32_wider(a: i32, b: i32) -> i32 {
    ((a as i64 + b as i64) / 2) as i32
}

#[no_mangle]
pub fn midpoint_i32_hackers(a: i32, b: i32) -> i32 {
    // Use the well known branchless algorithm from Hacker's Delight to compute
    // `(a + b) / 2` without overflowing: `((a ^ b) >> 1) + (a & b)`.
    let t = ((a ^ b) >> 1) + (a & b);
    // Except that it fails for integers whose sum is an odd negative number as
    // their floor is one less than their average. So we adjust the result.
    t + (if t < 0 { 1 } else { 0 } & (a ^ b))
}

/*
#[no_mangle]
pub fn midpoint_i16_wider(a: i16, b: i16) -> i16 {
    ((a as i32 + b as i32) / 2) as i16
}

#[no_mangle]
pub fn midpoint_i16_hackers(a: i16, b: i16) -> i16 {
    // Use the well known branchless algorithm from Hacker's Delight to compute
    // `(a + b) / 2` without overflowing: `((a ^ b) >> 1) + (a & b)`.
    let t = ((a ^ b) >> 1) + (a & b);
    // Except that it fails for integers whose sum is an odd negative number as
    // their floor is one less than their average. So we adjust the result.
    t + (if t < 0 { 1 } else { 0 } & (a ^ b))
}
*/

/*
#[no_mangle]
pub fn midpoint_i8_wider(a: i8, b: i8) -> i8 {
    ((a as i16 + b as i16) / 2) as i8
}

#[no_mangle]
pub fn midpoint_i8_hackers(a: i8, b: i8) -> i8 {
    // Use the well known branchless algorithm from Hacker's Delight to compute
    // `(a + b) / 2` without overflowing: `((a ^ b) >> 1) + (a & b)`.
    let t = ((a ^ b) >> 1) + (a & b);
    // Except that it fails for integers whose sum is an odd negative number as
    // their floor is one less than their average. So we adjust the result.
    t + (if t < 0 { 1 } else { 0 } & (a ^ b))
}
*/