Ограничения на числовите данни, препълване и закръгляване

Когато компютърните програми записват числа в променливи, компютърът трябва да намери начин да представи тези числа в компютърната памет. Компютрите използват различни стратегии в зависимост от това дали числото е цяло или не. Поради ограниченията на компютърната памет, понякога програмите се сблъскват с проблеми като закръгляване, препълване или точност на числовите променливи.

Цяло число е всяко число, което може да бъде записано без дробна част. Един и същ термин се използва както в програмирането, така и в математиката, така че се надяваме да ти е познат.

Всички тези числа са цели: $120$‍, $10$‍, $0$‍, $-20$‍.

Как език за програмиране може да представи тези цели числа в компютърната памет? Компютрите представят всички данни като битове, така че знаем, че всяко от тези числа, в крайна сметка, е последователност от нули и единици.

За да започнем с нещо просто, представи си компютър, който използва само 4 бита, за да представя цели числа. Може използва първия бит, за да представи знака на цялото число, положителен или отрицателен, а останалите 3 бита - за абсолютната стойност.

В тази система числото едно ще бъде представено по следния начин:

$0$‍ в знаковия бит представя положително число, а $1$‍ в най-десния бит представя $2^0$‍ ($1$‍) място за стойността.

Кое е най-голямото число, което може да представи тази система? Нека попълним всички значещи битове и да проверим:

Това е положителното число $7$‍, тъй като $2^2+2^1+2^0=(4+2+1)=7$‍.

Какво ще се случи, ако изпълним програма като тази на 4-битов компютър, в който най-голямото положително число е 7?

Компютърът може да запише променливата x без проблем, но y е с 1 повече от най-голямото цяло число, което може да се представи с 4 бита. В случаи като този, компютърът може да изведе "грешка от препълване" или да покаже съобщение като "числото е твърде голямо". Може и да изреже резултата (ограничавайки отгоре всички резултати до 7) или да превърти числото (така че 8 става 1).

Не искаме да попаднем в нито една от тези ситуации, така че е важно да знаем ограниченията на нашия език и среда, когато пишем програми.

За щастие най-модерните компютри използват 64-битови архитектури, които могат да съхраняват невъобразимо големи числа. В JavaScript най-голямото сигурно цяло число е 9 007 199 254 740 992, равностойно на $2^{53}-1$‍. Отвъд него сме в опасната зона.

✏️ Позабавлявай се в опасната зона по-долу! JavaScript не изписва грешки от препълване, но прави други странни неща.

📝 Виж подобен код в: App Lab | Snap | Python

Видяхме, че има ограничения при записването на цели числа в компютър. Числата, които не са цели, като дробите и ирационалните числа, са още по сложни за представяне в компютърната памет.

Разгледай числа като $2/5$‍, $\mathrm{1,234}$‍, $\mathrm{9,999}999$‍, или известното безкрайно $\pi$‍.

Обикновено компютърните езици използват представяне на плаваща запетая за дробни числа (а понякога и за цели числа). Сходно е с "експоненциален запис" – представяне, което може да ти е познато от други обучения.

В представянето чрез плаваща запетая числото се умножава с основа, която е повдигната на степен.

Тъй като компютрите използват двоична вместо десетична система, основата за числа с плаваща запетая е $2$‍ вместо $10$‍. Поради това числата, които са точна степен на $2$‍, са най-прости за представяне:

Числата между степените на двойката изглеждат така:

А дробните числа? Отново степените на $2$‍ са най-лесни за представяне.

С плаваща запетая могат да се представят и дроби между степени на 2:

След като компютърът определи представянето с плаваща запетая за дадено число, той го записва в битове. Модерните компютри използват 64-битова система, която използва 1 бит за знака, 11 бита за порядъка и 52 бита за числото отпред.

Тук имаме $\mathrm{0,375}$‍, представено в двоичен вид с плаваща запетая:

Точното превръщане в битове е по-сложно отколкото можем да разгледаме тук, но е чудесна тема за теб, ако искаш да навлезеш повече в тази тема.

Все пак, представянето с плаваща запетая все още не може да представи всички числа. Разгледай дробното число $1/3$‍ и неговото представяне с плаваща запетая:

В двоичен вид, $,\bar{3}$‍ е все така безкрайно повтаряща се последователност:

Не можем да записваме безкрайни последователности в компютър! В един момент компютърът трябва по някакъв начин да завърши числото – или като го отреже, или като го закръгли до най-близкото число с плаваща запетая. Компютрите трябва да правят това сравнително често, тъй като дори дроби като $1/10$‍ (която е краткото $0,1$‍ в десетичен вид) са безкрайно повтарящи се последователности, когато са превърнати в двоичен вид.

Често не забелязваме ниската точност на представянето на дадено число, докато не го използваме в операция по пресмятане. Тогава може да ни се случи грешка от закръгляване в резултатите.

✏️ Това е програма, която се опитва да събере $0,1+0,1+0,1$‍. В некомпютърния свят знаем, че резултатът е $0,3$‍. Но в компютъра всяка от стойностите $0,1$‍ е записана като закръглена двоична дроб и когато ги съберем, те не дават точно това, което очакваме като резултат…

📝 Виж подобен код в: App Lab | Snap | Python

Колкото повече битове можем да използваме, толкова по-точни ще са числата и пресмятанията ни. Модерните 64-битови системи предлагат достатъчно висока точност за некритични пресмятания.

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

🙋🏽🙋🏻‍♀️🙋🏿‍♂️Имаш ли въпроси по темата? Ще се радваме да ти отговорим, просто задай въпросите си по-долу!