Круглая половина вниз в Swift

Question

Есть ли в Swift режим округления, который ведет себя так же, как ROUND_HALF_DOWN в Java?

Режим округления для округления до «ближайшего соседа», если оба соседа не равноудалены, в этом случае округление в меньшую сторону. Ведет себя так же, как и для RoundingMode.UP, если отбрасываемая дробь> 0,5; в противном случае ведет себя как для RoundingMode.DOWN.

Пример:

• 2,5 раунда до 2,0
• 2,6 раундов до 3,0
• 2,4 раунда до 2,0

Для отрицательного числа:

• -2,5 раундов до -2,0
• -2,6 округления до -3,0
• -2,4 раунда до -2,0

Answer 1

Существует - насколько я могу судить - нет FloatingPointRoundingRule с тем же поведением, что и в Java ROUND_HALF_DOWN, но вы можете получить результат с комбинацией rounded() и nextDown или nextUp:

func roundHalfDown(_ x: Double) -> Double {
    if x >= 0 {
        return x.nextDown.rounded()
    } else {
        return x.nextUp.rounded()
    }
}

Примеры:

print(roundHalfDown(2.4)) // 2.0
print(roundHalfDown(2.5)) // 2.0
print(roundHalfDown(2.6)) // 3.0

print(roundHalfDown(-2.4)) // -2.0
print(roundHalfDown(-2.5)) // -2.0
print(roundHalfDown(-2.6)) // -3.0

Или как общий метод расширения, чтобы его можно было использовать со всеми типами с плавающей запятой (Float, Double, CGFloat):

extension FloatingPoint {
    func roundedHalfDown() -> Self {
        return self >= 0 ? nextDown.rounded() : nextUp.rounded()
    }
}

Примеры:

print((2.4).roundedHalfDown()) // 2.0
print((2.5).roundedHalfDown()) // 2.0
print((2.6).roundedHalfDown()) // 3.0

print((-2.4).roundedHalfDown()) // -2.0
print((-2.5).roundedHalfDown()) // -2.0
print((-2.6).roundedHalfDown()) // -3.0

Answer 2

Swift реализует .round() функцию с правилами, в соответствии с Apple

FloatingPointRoundingRule

case awayFromZero

Округление до ближайшего допустимого значения, величина которого больше или равнак источнику.

case down

Округление до ближайшего допустимого значения, которое меньше или равно источнику.

case toNearestOrAwayFromZero

Округление до ближайшего допустимого значения;если два значения одинаково близки, выбирается значение с большей величиной.

case toNearestOrEven

Округление до ближайшего допустимого значения;если два значения одинаково близки, выбирается четное.

case towardZero

Округление до ближайшего допустимого значения, величина которого меньше или равна величине источника.

case up

Округлить до ближайшего допустимого значения, которое больше или равно источнику.

Answer 3

 var a = 6.54
        a.round(.toNearestOrAwayFromZero)
        // a == 7.0

        var b = 6.54
        b.round(.towardZero)
        // b == 6.0


        var c = 6.54
        c.round(.up)
        // c == 7.0


        var d = 6.54
        d.round(.down)
        // d == 6.0

Вы можете сделать то же самое, но вам нужно принимать значения и после десятичной дроби.

Answer 4

Как сказал @MohmmadS, это встроенные методы округления.

Вы можете реализовать пользовательское округление следующим образом:

func round(_ value: Double, toNearest: Double) -> Double {
    return round(value / toNearest) * toNearest
}

func roundDown(_ value: Double, toNearest: Double) -> Double {
    return floor(value / toNearest) * toNearest
}

func roundUp(_ value: Double, toNearest: Double) -> Double {
    return ceil(value / toNearest) * toNearest
}

Пример:

round(52.376, toNearest: 0.01) // 52.38
round(52.376, toNearest: 0.1)  // 52.4
round(52.376, toNearest: 0.25) // 52.5
round(52.376, toNearest: 0.5)  // 52.5
round(52.376, toNearest: 1)    // 52

Answer 5

Да, вы можете делать подобные вещи, используя NSNumberFormatter и RoundingMode

Прочитайте их здесь

NSNumberFormatter

RoundingMode