If you're seeing this message, it means we're having trouble loading external resources on our website.

Եթե գտնվում ես վեբ զտիչի հետևում, խնդրում ենք համոզվել, որ *.kastatic.org և *.kasandbox.org տիրույթները հանված են արգելափակումից։

Հիմնական նյութ

Թվի սահման, գերհոսք և կլորացում

Երբ համակարգչային ծրագրերը թվերը պահում են փոփոխականներով, համակարգիչը պետք է գտնի այդ թիվը համակարգչի հիշողության մեջ ներկայացնելու միջոց: Համակարգիչները օգտագործում են տարբեր տարբերակներ՝ ելնելով թիվը ամբողջ է, թե ոչ: Համակարգչային հիշողության սահմանափակ լինելու պատճառով ծրագրերը երբեմն բախվում են թվային փոփոխականների կլորացման, գերհոսքի կամ ճշգրիտության խնդիրների հետ:

Ամբողջ թվերի գրառում

Ամբողջ թիվը այն թիվն է, որը կարելի է գրել առանց կոտորակային բաղադրիչի։ Նույն տերմինն օգտագործվում է ինչպես ծրագրավորման, այնպես էլ մաթեմատիկայի մեջ, այնպես որ, հուսով ենք, որ այն քեզ ծանոթ է:
Այս բոլոր թվերը ամբողջ թվեր են. 120, 10, 0, 20.
Ինչպե՞ս կարող է ծրագրավորման լեզուն ներկայացնել այդ ամբողջ թվերը համակարգչի հիշողության մեջ: Դե, համակարգիչները ներկայացնում են բոլոր տվյալները բիթերով, այնպես որ գիտենք, որ, ի վերջո, այդ թվերից յուրաքանչյուրը 0-ների և 1-երի հաջորդականություն է:
Սկսենք պարզից․ եկեք պատկերացնենք մի համակարգիչ, որն օգտագործում է ընդամենը 4 բիթ՝ ամբողջ թվերը ներկայացնելու համար: Այն կարող է օգտագործել առաջին բիթը՝ ամբողջ թվի նշանը ներկայացնելու համար՝ դրական կամ բացասական, իսկ մնացած 3 բիթերը՝ բացարձակ արժեքի համար։
Այդ համակարգում թիվ 1-ը կներկայացվի այսպես.
0001
+/-421
նշան222120
Նշանի բիթում 0-ն ներկայացնում է դրական թիվ, իսկ 1-ը ամենաաջ բիթում ներկայացնում է 20 (1) արժեքը:
Ո՞րն է այն ամենամեծ թիվը, որ այս համակարգը կարող է ներկայացնել: Եկեք լրացնենք բոլոր արժեքային բիթերը 1-ով և տեսնենք.
0111
+/-421
նշան222120
Դա դրական 7 թիվն է, քանի որ 22+21+20=(4+2+1)=7.
Ստուգի՛ր գիտելիքդ
Դիտարկենք համակարգիչ, որն ամբողջ թվերը ներկայացնելու համար օգտագործում է 6 բիթ՝ 1 բիթ նշանի և 5 բիթ իրական թվի համար: Ո՞րն է ամենամեծ դրական ամբողջ թիվը, որն այն կարող է ներկայացնել:
  • Քո պատասխանը պետք է լինի
  • ամբողջ թիվ, օրինակ՝ 6
  • պարզեցված կանոնավոր կոտորակ, օրինակ՝ 3/5
  • պարզեցված անկանոն կոտորակ, օրինակ՝ 7/4
  • խառը թիվ, օրինակ՝ 1 3/4
  • վերջավոր տասնորդական կոտորակ, օրինակ 0,75
  • Պիի բազմապատիկ, օրինակ՝ 12 պի կամ 2/3 պի

Գերհոսք

Ի՞նչ կլիներ, եթե մենք գործարկեինք նման ծրագիր 4-բիթանոց համակարգչի վրա, որտեղ ամենամեծ դրական ամբողջ թիվը 7-ն է:
var x = 7;
var y = x + 1;
Համակարգիչը կարող է լավ պահել x փոփոխականը, բայց y -ը 4 բիթով ներկայացղվող ամենամեծ ամբողջ թվից մեկով մեծ է : Նման դեպքում համակարգիչը կարող է զեկուցել "գերհոսքի սխալ" կամ ցուցադրել այնպիսի հաղորդագրություն, ինչպիսին է "թիվը չափազանց մեծ է": Այն կարող է նաև կրճատել թիվը (բոլոր արդյունքները սահմանափակելով 7-ով) կամ կլորացնել թիվը (այնպես, որ 8-ը դառնա 1):
Մենք չենք ցանկանում հայտնվել այդ իրավիճակներից որևէ մեկում, ուստի կարևոր է, որ ծրագրեր գրելիս իմանանք մեր լեզվի և միջավայրի սահմանափակումները:
Ստուգի՛ր գիտելիքդ
Այս գործողություններից ո՞րն է հանգեցնում գերհոսքի այն համակարգչում, որն ամբողջ թվերը ներկայացնելու համար օգտագործում է 6 բիթ (1 բիթը՝ նշանը ներկայացնելու համար):
Ընտրիր բոլոր ճիշտ պատասխանները։

Բարեբախտաբար, ժամանակակից համակարգիչների մեծ մասը օգտագործում է 64 բիթ, որը կարող է պահել անհավատալի մեծ ամբողջ թվեր: JavaScript-ում ամենամեծ «անվտանգ» ամբողջ թիվը 9,007,199,254,740,992 է, որը համարժեք է 2531-ին: Դրանից այն կողմ մենք կգտնվենք վտանգավոր գոտում:
✏️ Խաղացեք ներքևում գտնվող վտանգավոր գոտում: JavaScript-ը չի ցուցադրում գերհոսքի սխալները, բայց անում է մի քանի այլ տարօրինակ բաներ:
📝 Տե՛ս նմանատիպ կոդ․ App Lab | Snap | Python

Լողացող ստորակետով գրառում

Մենք տեսանք, որ համակարգչում ամբողջ թվերը պահելու սահմանափակումներ կան: Համակարգչի հիշողության մեջ ավելի բարդ է ներկայացնելն այն թվերը, որոնք ամբողջ թվեր չեն, ինչպես կոտորակներն ու իռացիոնալ թվերը:
Դիտարկենք այնպիսի թվեր, ինչպիսիք են 2/5; 1,234; 9,999999 կամ հայտնի անվերջ π-ն:
Համակարգչային լեզուները սովորաբար օգտագործում են լողացող ստորակետով գրառում ոչ ամբողջ թվերի համար (և երբեմն նաև ամբողջ թվերի): Դա նման է «ցուցչային գրառմանը», մի գրառում, որը հնարավոր է իմանաս այլ առարկաներից:
Լողացող ստորակետով գրառման ժամանակ թիվը բազմապատկվում է հիմքով, որը բարձրացվում է համապատասխան աստիճան.
300=3×10հիմք2ցուցիչ
Քանի որ համակարգիչները տասական համակարգի փոխարեն օգտագործում են երկուական համակարգ, լողացող ստորակետով գրառմամբ թվերի հիմքը 2 է 10-ի փոխարեն: Դրա պատճառով այն թվերը, որոնք ճշգրիտ 2-ի աստիճաններ են, ներկայացնելու համար ամենապարզն են.
128=1×27256=1×28
2-ի աստիճանների միջև ընկած թվերն այսպիսի տեսք ունեն.
160=1.25×27192=1.50×27224=1.75×27
Ինչ վերաբերում է ոչ ամբողջ թվերին, կրկին, 2-ի աստիճաններն ամենապարզն են ներկայացնելու համար:
0.50=1×210.25=1×22
Լողացող ստորակետով գրառումը կարող է նաև ներկայացնել 2-ի աստիճանների միջև ընկած կոտորակներ.
0.750=1.5×210.375=1.5×22
Երբ համակարգիչը նկատում է լողացող ստորակետով գրված թիվ այն պահում է բիթերով: Ժամանակակից համակարգիչներն օգտագործում են 64-բիթանոց համակարգ, որն օգտագործում է 1 բիթ նշանի համար, 11 բիթ ցուցիչի համար և 52 բիթ դիմացի թվի համար:
Ահա 0,375 լողացող կետով գրառում երկուական համակարգում.
11111111011000000000000000000000000000000000000000000000000000
Բիթերի ճշգրիտ թարգմանությունն ավելի բարդ է, քան մենք կարող ենք անդրադառնալ այստեղ, բայց հիանալի թեմա է ձեզանից նրանց համար, ովքեր ցանկանում են ավելի խորը ուսումնասիրել:

Կլորացման սխալներ

Լողացող ստորակետով գրառումը դեռևս չի կարող ամբողջությամբ ներկայացնել բոլոր թվերը: Դիտարկենք 1/3 կոտորակը և դրա լողացող ստորակետի գրառումը.
1/3=1.3×22
.3-ը երկուական համակարգում դեռևս անվերջ կրկնվող հաջորդականություն է.
101010101…
Մենք չենք կարող անսահման հաջորդականություն պահել համակարգչում: Ինչ-որ պահի, համակարգիչը պետք է ինչ-որ կերպ ավարտի թիվը, կամ կտրելով այն կամ կլորացնելով մոտակա լողացող ստորակետի թիվը: Համակարգիչները ստիպված են դա անել բավականին հաճախ, քանի որ նույնիսկ այն կոտորակները, ինչպիսիք են 1/10-ը (որը տասական համակարգում կարճ 0,1 է) ավարտվում են որպես անսահման կրկնվող հաջորդականություններ, երբ վերածվում են երկուական թվի:
Մենք հաճախ չենք նկատում թվի ներկայացման ավելի փոքր ճշգրտությունը, քանի դեռ չենք օգտագործել այն հաշվարկներում: Հենց այդ ժամանակ մենք կարող ենք արդյունքների մեջ զգալ կլորացման սխալ:
✏️ Ահա մի ծրագիր, որը փորձում է գումարել 0.1+0.1+0.1: Ոչ համակարգչային աշխարհում մենք գիտենք, որ դա 0,3 է: Բայց համակարգչում 0.1 արժեքներից յուրաքանչյուրը պահվում է որպես կլորացված երկուական կոտորակ, և երբ դրանք գումարվում են, դրանք այնքան էլ չեն հավասարվում մեր ակնկալածին…
📝 Տե՛ս նմանատիպ կոդ․ App Lab | Snap | Python
Որքան շատ բիթ կարողանանք օգտագործել, այնքան ավելի ճշգրիտ կլինեն մեր թվերն ու հաշվարկները: Ժամանակակից 64-բիթանոց համակարգերն առաջարկում են բավականաչափ բարձր ճշգրտություն:
Հավանաբար ինչ-որ պահի դու կգրես ծրագրեր, որոնք հաշվարկում են քվեարկության արդյունքները, սնուցում են ինքնակառավարվող մեքենան կամ նույնիսկ հրթիռ են արձակում: Երբ խաղադրույքները մեծ են, ճշգրտությունը կարևոր է:
🙋🏽🙋🏻‍♀️🙋🏿‍♂️Ունե՞ք հարցեր այս թեմայի վերաբերյալ: Սիրով կպատասխանենք, պարզապես հարցրեք ստորև ներկայացված հարցերի համար նախատեսված մասում:

Ուզո՞ւմ ես միանալ խոսակցությանը։

Առայժմ հրապարակումներ չկան։
Անգլերեն հասկանո՞ւմ ես: Սեղմիր այստեղ և ավելի շատ քննարկումներ կգտնես «Քան» ակադեմիայի անգլերեն կայքում: