Zaokrąglanie liczb dziesiętnych: zasady matematyczne, JavaScript i Ruby

18 paź 12:59

7 min. czytania

meme code

@memecode

Okładka posta: Zaokrąglanie liczb dziesiętnych: zasady matematyczne, JavaScript i Ruby

Spis treściKliknij link, aby przejść do wybranego miejsca

Matematyczne zaokrąglanie Zaokrąglanie w JavaScript Zaokrąglanie w Ruby

Ta treść została automatycznie przetłumaczona z ukraińskiego.

Zobacz oryginał

Zaokrąglanie jest ważną operacją przy pracy z liczbami dziesiętnymi, ponieważ pozwala przedstawić wartości w bardziej przystępnej formie, zmniejszając liczbę cyfr po przecinku. Jednak różne języki programowania mogą stosować różne podejścia do zaokrąglania, co może prowadzić do nieoczekiwanych wyników w niektórych scenariuszach. W tym wpisie omówimy matematyczne zasady zaokrąglania oraz ich implementację w JavaScript i Ruby.

Matematyczne zaokrąglanie

Matematyczne zaokrąglanie — to proces zmniejszania liczby miejsc dziesiętnych liczby, aby uczynić ją prostszą do użycia, wyświetlania lub dalszych obliczeń. Jest to szczególnie ważne w obliczeniach finansowych, naukowych i inżynieryjnych, gdzie dokładność musi być zrównoważona z praktycznością.

Zaokrąglanie do najbliższej liczby

Ta metoda zaokrągla liczbę do najbliższej liczby całkowitej lub dziesiętnej. Jeśli liczba znajduje się dokładnie w połowie między dwoma opcjami (na przykład 2.5), zaokrągla się ją do większej liczby.

Reguła: Jeśli część ułamkowa ≥ 0.5, zaokrąglamy w górę. Jeśli mniej — zaokrąglamy w dół.

Przykład:

2.4 → 2

2.5 → 3

Zaokrąglanie w dół

Przy użyciu tej metody wszystkie wartości są zaokrąglane w dół, niezależnie od części ułamkowej liczby.

Reguła: Liczba zawsze zaokrąglana jest do mniejszej liczby całkowitej.

Przykład:

2.9 → 2

-2.1 → -3

Zaokrąglanie w górę

Zaokrągla się w większą stronę, niezależnie od części ułamkowej liczby.

Reguła: Liczba zawsze zaokrąglana jest w górę do najbliższej liczby całkowitej.

Przykład:

2.1 → 3

-2.9 → -2

Obcinanie części dziesiętnej

Ta metoda po prostu odrzuca część ułamkową, pozostawiając tylko całkowitą.

Reguła: Część ułamkowa liczby jest ignorowana.

Przykład:

3.9 → 3

-3.9 → -3

Powtórzyliśmy program szkolny i możemy przejść do Javascript i Ruby. Rozważmy istniejące metody, niuanse i pułapki każdego z tych języków programowania. Rozważam właśnie te języki, ponieważ to mój główny stos roboczy.

Zaokrąglanie w JavaScript

W JavaScript zaokrąglanie odbywa się za pomocą metod Math.round(), Math.floor() i Math.ceil():

Przykłady:

Math.round(4.73) → 5
Math.round(4.76) → 5
Math.floor(4.76) → 4 (zaokrąglanie w dół)
Math.ceil(4.76) → 5 (zaokrąglanie w górę)

Ale najpierw rozważmy metody toFixed() i toPrecision().

Zaokrąglanie do określonej liczby miejsc po przecinku (JS)

W JavaScript do zaokrąglania liczby do określonej liczby miejsc po przecinku najczęściej używa się metod toFixed() i toPrecision().

Metoda toFixed() pozwala zaokrąglić liczbę do podanej liczby miejsc dziesiętnych i zwraca wynik w postaci łańcucha.

num.toFixed(digits);

num: Liczba, którą należy zaokrąglić.

digits: Liczba miejsc po przecinku.

let num = 5.6789;
console.log(num.toFixed(2)); // "5.68"

W przykładzie liczba 5.6789 została zaokrąglona do dwóch miejsc po przecinku, wynik — "5.68". Metoda zawsze zwraca łańcuch, dlatego w razie potrzeby można ją przekształcić na liczbę za pomocą parseFloat() lub Number().

Metoda toPrecision() pozwala zaokrąglać liczbę do podanej całkowitej liczby cyfr (w tym cyfr przed i po przecinku).

num.toPrecision(precision);

precision: Liczba cyfr.

let num = 5.6789;
console.log(num.toPrecision(3)); // "5.68"

Tutaj liczba 5.6789 została zaokrąglona do trzech cyfr, wynik — "5.68".

Podsumowując i porównując te metody:

toFixed() ustala liczbę miejsc po przecinku.
toPrecision() działa ze wszystkimi cyframi liczby, w tym całkowymi i ułamkowymi.

Metody zaokrąglania toFixed() i toPrecision() stosują ogólne matematyczne zasady zaokrąglania — zaokrąglanie arytmetyczne. Oznacza to, że zaokrąglają liczbę w górę lub w dół w zależności od wartości następnej cyfry po granicy zaokrąglania.

Zasady zaokrąglania:

Jeśli cyfra po granicy zaokrąglania jest mniejsza niż 5, liczba jest zaokrąglana w dół (w mniejszą stronę).
Jeśli cyfra po granicy zaokrąglania jest równa lub większa niż 5, liczba jest zaokrąglana w górę (w większą stronę).

Przykłady .toFixed() z .5
Liczba 2.5 jest zaokrąglana w górę do 3, ponieważ cyfra po przecinku wynosi 5.

let num = 2.5; 
console.log(num.toFixed(0)); // "3"

Zaokrąglając do jednego miejsca po przecinku, liczba 2.45 staje się 2.5, ponieważ cyfra po granicy zaokrąglania (4) nie osiąga 5.

let num = 2.45;
console.log(num.toFixed(1)); // "2.5"

Przykłady .toPrecision() z .5
Przy zaokrąglaniu do dwóch cyfr znaczących liczba 1.005 staje się 1.0, ponieważ granica zaokrąglania znajduje się na 0, a następna cyfra jest mniejsza niż 5.

let num = 1.005;
console.log(num.toPrecision(2)); // "1.0"

Liczba 2.555 jest zaokrąglana do trzech cyfr znaczących, i otrzymujemy 2.56, ponieważ po granicy zaokrąglania znajduje się cyfra 5.

let num = 2.555;
console.log(num.toPrecision(3)); // "2.56"

Specyfika JS

JavaScript zaokrągla liczby zmiennoprzecinkowe, i czasami może wystąpić nieprecyzyjne zaokrąglanie z powodu reprezentacji liczb w systemie binarnym. Na przykład:

let num = 1.005;
console.log(num.toFixed(2)); // "1.00" (oczekiwano "1.01")

Tutaj oczekiwano, że 1.005 stanie się 1.01, ale z powodu arytmetyki binarnej wynik może być nieco inny. Aby poradzić sobie z tymi problemami, często stosuje się metody takie jak mnożenie liczby przez 10^n przed zaokrąglaniem lub korzystanie z wyspecjalizowanych bibliotek do dokładnych obliczeń. Można spotkać takie opcje rozwiązania tego problemu:

let num = 1.005;
let rounded = Math.round(num * 100) / 100;
console.log(rounded); // "1.01"

Oto doszliśmy do praktycznego zastosowania metod Math. Aby lepiej zrozumieć metody zaokrąglania w JavaScript, szczególnie te, które są częścią biblioteki Math, przyjrzyjmy się ich podstawowym funkcjom i podajmy przykłady ich użycia.

Math.round()

Metoda zaokrągla liczbę do najbliższej liczby całkowitej. Jeśli część ułamkowa liczby jest większa lub równa 0.5 — zaokrągla w większą stronę, w przeciwnym razie — w mniejszą.

Math.round(4.7); // 5
Math.round(4.3); // 4
Math.round(4.5); // 5 (jeśli .5, to w większą stronę)
Math.round(-1.5); // -1 (ujemne .5 również zaokrąglają się w większą stronę)

Math.floor()

Ta metoda zawsze zaokrągla liczbę w dół (do najbliższej mniejszej liczby całkowitej).

Math.floor(4.9); // 4
Math.floor(4.1); // 4
Math.floor(-2.3); // -3 (ujemne liczby również zaokrąglają się w mniejszą stronę)

Math.ceil()

Ta metoda zawsze zaokrągla liczbę w górę (do najbliższej większej liczby całkowitej).

Math.ceil(4.1); // 5
Math.ceil(4.9); // 5
Math.ceil(-2.3); // -2 (ujemne liczby zaokrąglają się w większą stronę)

Math.trunc()

Ta metoda obcina część ułamkową liczby, zwracając tylko część całkowitą, niezależnie od tego, czy część ułamkowa jest dodatnia czy ujemna.

Math.trunc(4.9); // 4
Math.trunc(-4.9); // -4
Math.trunc(4.1); // 4

A dla wygody mały cheatsheet w formie obrazka:

A teraz rozważmy metody zaokrąglania w Ruby.

Zaokrąglanie w Ruby

Ruby, podobnie jak JavaScript, ma kilka metod do zaokrąglania liczb. Główne metody to round, floor, ceil i truncate. Przyjrzyjmy się każdej z nich bliżej.

.round

Metoda round zaokrągla liczbę do najbliższej liczby całkowitej lub do określonej liczby miejsc po przecinku. Jeśli część ułamkowa liczby wynosi 0.5 lub więcej, liczba jest zaokrąglana w większą stronę. Jeśli mniej, to w mniejszą stronę.

2.5.round # => 3
2.49.round # => 2

Zaokrąglanie do określonej liczby miejsc dziesiętnych odbywa się poprzez przekazanie dodatkowego parametru:

2.456.round(2)  # => 2.46

.floor

Metoda floor zaokrągla liczbę w dół do najbliższej liczby całkowitej, niezależnie od wartości części ułamkowej. Jest analogiczna do metody Math.floor w JavaScript.

2.9.floor    # => 2
-2.1.floor   # => -3

.ceil

Metoda ceil, przeciwnie, zaokrągla liczbę w górę do najbliższej liczby całkowitej, niezależnie od części ułamkowej. Jest analogiem metody Math.ceil w JavaScript.

2.1.ceil     # => 3
-2.9.ceil    # => -2

.truncate

Metoda truncate odrzuca część ułamkową liczby i zwraca tylko część całkowitą. Jest podobna do metody Math.trunc w JavaScript.

2.9.truncate   # => 2
-2.9.truncate  # => -2

Zaokrąglanie do określonej liczby miejsc po przecinku (Ruby)

Jeśli musisz zaokrąglić liczbę do określonej liczby miejsc po przecinku, Ruby również na to pozwala za pomocą metody round. Parametr w nawiasach wskazuje, ile miejsc pozostawić po przecinku.

5.6789.round(2)   # => 5.68
5.6789.round(3)   # => 5.679

Podobnie jak w JavaScript, zaokrąglanie w Ruby również może prowadzić do nieoczekiwanych wyników z powodu użycia liczb zmiennoprzecinkowych. Na przykład w starszych wersjach Ruby (2.+):

(1.005).round(2)  # => 1.0 (oczekiwano 1.01)

Obecnie mam ruby 3.2.1 (2023-02-08 revision 31819e82c8) +YJIT [x86_64-darwin23] i nie widzę tego problemu:

(1.005).round(2)
=> 1.01

Te niuanse w zaokrąglaniu mogą być często poruszane podczas technicznych rozmów kwalifikacyjnych. Dlatego warto je przemyśleć, zrozumieć i zapamiętać (i śledzić aktualizacje). Nie chcemy, aby trywialny błąd w zaokrąglaniu doprowadził nas do problemów w środowisku produkcyjnym.