Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.0

0.6.0 / src / ak / math_3.lucb

#==============================================================================================
#
#   math_3 - clamp_to
#
#   DESCRIPTION:
#       Port of AK/Math.h clamp_to (lines 1021-1041) for every pair of destination
#       (i32, i64, u32, u64) and source (i32, i64, u32, u64, f32, f64) type:
#       `clamp_to_<destination>_<source>`. A float source is rounded with round_to.
#
#==============================================================================================

# mark: clamp_to ================================================================================

## Ported from AK/Math.h:1022 AK::clamp_to<i32>(i32).
pub func clamp_to_i32_i32(value: i32) -> i32:
    let max_ = (i32)i32_max
    if max_ > (i32)0:
        if value >= max_:
            return i32_max

    let min_ = (i32)i32_min
    if min_ <= (i32)0:
        if value <= min_:
            return i32_min

    return (i32)value

## Ported from AK/Math.h:1022 AK::clamp_to<i32>(i64).
pub func clamp_to_i32_i64(value: i64) -> i32:
    let max_ = (i64)i32_max
    if max_ > (i64)0:
        if value >= max_:
            return i32_max

    let min_ = (i64)i32_min
    if min_ <= (i64)0:
        if value <= min_:
            return i32_min

    return (i32)value

## Ported from AK/Math.h:1022 AK::clamp_to<i32>(u32).
pub func clamp_to_i32_u32(value: u32) -> i32:
    let max_ = (u32)i32_max
    if max_ > (u32)0:
        if value >= max_:
            return i32_max

    let min_ = (u32)i32_min
    if min_ <= (u32)0:
        if value <= min_:
            return i32_min

    return (i32)value

## Ported from AK/Math.h:1022 AK::clamp_to<i32>(u64).
pub func clamp_to_i32_u64(value: u64) -> i32:
    let max_ = (u64)i32_max
    if max_ > (u64)0:
        if value >= max_:
            return i32_max

    let min_ = (u64)i32_min
    if min_ <= (u64)0:
        if value <= min_:
            return i32_min

    return (i32)value

## Ported from AK/Math.h:1022 AK::clamp_to<i32>(f32).
pub func clamp_to_i32_f32(value: f32) -> i32:
    let max_ = (f32)i32_max
    if max_ > (f32)0:
        if value >= max_:
            return i32_max

    let min_ = (f32)i32_min
    if min_ <= (f32)0:
        if value <= min_:
            return i32_min

    return rounding_round_to_f32_i32(value)

## Ported from AK/Math.h:1022 AK::clamp_to<i32>(f64).
pub func clamp_to_i32_f64(value: f64) -> i32:
    let max_ = (f64)i32_max
    if max_ > (f64)0:
        if value >= max_:
            return i32_max

    let min_ = (f64)i32_min
    if min_ <= (f64)0:
        if value <= min_:
            return i32_min

    return rounding_round_to_f64_i32(value)

## Ported from AK/Math.h:1022 AK::clamp_to<i64>(i32).
pub func clamp_to_i64_i32(value: i32) -> i64:
    let max_ = (i32)i64_max
    if max_ > (i32)0:
        if value >= max_:
            return i64_max

    let min_ = (i32)i64_min
    if min_ <= (i32)0:
        if value <= min_:
            return i64_min

    return (i64)value

## Ported from AK/Math.h:1022 AK::clamp_to<i64>(i64).
pub func clamp_to_i64_i64(value: i64) -> i64:
    let max_ = (i64)i64_max
    if max_ > (i64)0:
        if value >= max_:
            return i64_max

    let min_ = (i64)i64_min
    if min_ <= (i64)0:
        if value <= min_:
            return i64_min

    return (i64)value

## Ported from AK/Math.h:1022 AK::clamp_to<i64>(u32).
pub func clamp_to_i64_u32(value: u32) -> i64:
    let max_ = (u32)i64_max
    if max_ > (u32)0:
        if value >= max_:
            return i64_max

    let min_ = (u32)i64_min
    if min_ <= (u32)0:
        if value <= min_:
            return i64_min

    return (i64)value

## Ported from AK/Math.h:1022 AK::clamp_to<i64>(u64).
pub func clamp_to_i64_u64(value: u64) -> i64:
    let max_ = (u64)i64_max
    if max_ > (u64)0:
        if value >= max_:
            return i64_max

    let min_ = (u64)i64_min
    if min_ <= (u64)0:
        if value <= min_:
            return i64_min

    return (i64)value

## Ported from AK/Math.h:1022 AK::clamp_to<i64>(f32).
pub func clamp_to_i64_f32(value: f32) -> i64:
    let max_ = (f32)i64_max
    if max_ > (f32)0:
        if value >= max_:
            return i64_max

    let min_ = (f32)i64_min
    if min_ <= (f32)0:
        if value <= min_:
            return i64_min

    return rounding_round_to_f32_i64(value)

## Ported from AK/Math.h:1022 AK::clamp_to<i64>(f64).
pub func clamp_to_i64_f64(value: f64) -> i64:
    let max_ = (f64)i64_max
    if max_ > (f64)0:
        if value >= max_:
            return i64_max

    let min_ = (f64)i64_min
    if min_ <= (f64)0:
        if value <= min_:
            return i64_min

    return rounding_round_to_f64_i64(value)

## Ported from AK/Math.h:1022 AK::clamp_to<u32>(i32).
pub func clamp_to_u32_i32(value: i32) -> u32:
    let max_ = (i32)u32_max
    if max_ > (i32)0:
        if value >= max_:
            return u32_max

    let min_ = (i32)u32_min
    if min_ <= (i32)0:
        if value <= min_:
            return u32_min

    return (u32)value

## Ported from AK/Math.h:1022 AK::clamp_to<u32>(i64).
pub func clamp_to_u32_i64(value: i64) -> u32:
    let max_ = (i64)u32_max
    if max_ > (i64)0:
        if value >= max_:
            return u32_max

    let min_ = (i64)u32_min
    if min_ <= (i64)0:
        if value <= min_:
            return u32_min

    return (u32)value

## Ported from AK/Math.h:1022 AK::clamp_to<u32>(u32).
pub func clamp_to_u32_u32(value: u32) -> u32:
    let max_ = (u32)u32_max
    if max_ > (u32)0:
        if value >= max_:
            return u32_max

    let min_ = (u32)u32_min
    if min_ <= (u32)0:
        if value <= min_:
            return u32_min

    return (u32)value

## Ported from AK/Math.h:1022 AK::clamp_to<u32>(u64).
pub func clamp_to_u32_u64(value: u64) -> u32:
    let max_ = (u64)u32_max
    if max_ > (u64)0:
        if value >= max_:
            return u32_max

    let min_ = (u64)u32_min
    if min_ <= (u64)0:
        if value <= min_:
            return u32_min

    return (u32)value

## Ported from AK/Math.h:1022 AK::clamp_to<u32>(f32).
pub func clamp_to_u32_f32(value: f32) -> u32:
    let max_ = (f32)u32_max
    if max_ > (f32)0:
        if value >= max_:
            return u32_max

    let min_ = (f32)u32_min
    if min_ <= (f32)0:
        if value <= min_:
            return u32_min

    return rounding_round_to_f32_u32(value)

## Ported from AK/Math.h:1022 AK::clamp_to<u32>(f64).
pub func clamp_to_u32_f64(value: f64) -> u32:
    let max_ = (f64)u32_max
    if max_ > (f64)0:
        if value >= max_:
            return u32_max

    let min_ = (f64)u32_min
    if min_ <= (f64)0:
        if value <= min_:
            return u32_min

    return rounding_round_to_f64_u32(value)

## Ported from AK/Math.h:1022 AK::clamp_to<u64>(i32).
pub func clamp_to_u64_i32(value: i32) -> u64:
    let max_ = (i32)u64_max
    if max_ > (i32)0:
        if value >= max_:
            return u64_max

    let min_ = (i32)u64_min
    if min_ <= (i32)0:
        if value <= min_:
            return u64_min

    return (u64)value

## Ported from AK/Math.h:1022 AK::clamp_to<u64>(i64).
pub func clamp_to_u64_i64(value: i64) -> u64:
    let max_ = (i64)u64_max
    if max_ > (i64)0:
        if value >= max_:
            return u64_max

    let min_ = (i64)u64_min
    if min_ <= (i64)0:
        if value <= min_:
            return u64_min

    return (u64)value

## Ported from AK/Math.h:1022 AK::clamp_to<u64>(u32).
pub func clamp_to_u64_u32(value: u32) -> u64:
    let max_ = (u32)u64_max
    if max_ > (u32)0:
        if value >= max_:
            return u64_max

    let min_ = (u32)u64_min
    if min_ <= (u32)0:
        if value <= min_:
            return u64_min

    return (u64)value

## Ported from AK/Math.h:1022 AK::clamp_to<u64>(u64).
pub func clamp_to_u64_u64(value: u64) -> u64:
    let max_ = (u64)u64_max
    if max_ > (u64)0:
        if value >= max_:
            return u64_max

    let min_ = (u64)u64_min
    if min_ <= (u64)0:
        if value <= min_:
            return u64_min

    return (u64)value

## Ported from AK/Math.h:1022 AK::clamp_to<u64>(f32).
pub func clamp_to_u64_f32(value: f32) -> u64:
    let max_ = (f32)u64_max
    if max_ > (f32)0:
        if value >= max_:
            return u64_max

    let min_ = (f32)u64_min
    if min_ <= (f32)0:
        if value <= min_:
            return u64_min

    return rounding_round_to_f32_u64(value)

## Ported from AK/Math.h:1022 AK::clamp_to<u64>(f64).
pub func clamp_to_u64_f64(value: f64) -> u64:
    let max_ = (f64)u64_max
    if max_ > (f64)0:
        if value >= max_:
            return u64_max

    let min_ = (f64)u64_min
    if min_ <= (f64)0:
        if value <= min_:
            return u64_min

    return rounding_round_to_f64_u64(value)