Laborator 4, 7 – referat

Prelucrarea informaţiei în sistemele de calcul (SC)

1. Suport teoretic și exerciții rezolvate

Însușirea corectă a unui limbaj de programare, a modului în care se alcătuiește un
program de calcul și se prelucrează instrucțiunile acestuia, necesită și înţelegerea și
interpretarea modului în care se reprezintă/prelucrează informațiile (date/instrucțiuni) în
MO. Organizarea lucrării este următoarea:
1. Reprezentarea informațiilor în memoria operativă (MO)
2. Operaţii aritmetice cu numere întregi
3. Operaţii relaţionale
4. Operaţii logice

1.1. Reprezentarea informațiilor în MO

Toate informațiile (date/instrucțiuni) se reprezintă/înscriu în MO numai sub formă
codificată numeric. Memorarea și prelucrarea informațiilor se realizează în
cvasitotalitatea cazurilor prin grupe de câte 8 biți (octet/byte). Tipul fiecărei variabile și,
în corespondență cu acesta, dimensiunea/numărul de octeți folosiți pentru fiecare locație
(1octet/2octeţi/4octeţi...), se alege astfel încât să se asigure obținerea rezultatelor cu
precizia necesară. Tipul unei variabile se precizează în instrucțiunile de declarare prin
cuvinte tip: int/char/float ș.a.

1.1.1. Reprezentarea numerelor întregi

Pentru simplificarea urmăririi prezentărilor concrete ulterioare, se va consideră că
pentru memorarea/înscrierea valorile întregi se vor folosi 2o/bytes sau 16 cifre binare/biți.
 A. Reprezentarea numerele întregi și strict pozitive
(numere întregi fără semn, mulțimea ℕ) se înscriu în MO, prin codul direct al
reprezentării în baza doi. Pentru numărul X > 0 codul direct se notează astfel:
Xd = X
Cifrele formei în baza doi sunt cifrele rest obținute prin împărțirea succesivă la
doi a numărului care se reprezintă, considerate în sens invers determinării, prima
cifra a reprezentării fiind ultima cifră rest obținută (fig.1). Reprezentarea numărului în
baza 16, forma externă a reprezentării interne, se obține înlocuind succesiv, de la stânga
spre dreapta, fiecare tetradă de cifre binare prin cifra corespunzătoare a bazei 16 sau
hexazecimală.
Cifrele bazelor 2, 10 și 16 Tabelul 1
Nr.crt. Numărul în baza 10 Numărul în baza 2 Cifra bazei 16
0 0 0000 0
1 1 0001 1
2 2 0010 2
3 3 0011 3
4 4 0100 4
5 5 0101 5
6 6 0110 6
7 7 0111 7
8 8 1000 8
9 9 1001 9
10 10 1010 A
11 11 1011 B
12 12 1100 C
13 13 1101 D
14 14 1110 E
15 15 1111 F

Obs. Un număr în baza 16 reprezentat pe 2o/bytes se afișează/tipărește sub forma

0x ∅∅∅∅, unde ∅∅∅∅ reprezintă tetrada cifrelor în baza 16, respectiv câte 2 cifre hexa
pentru fiecare octet.
Ex. (60)10 =(0000 0000 0011 1100)2 = (3C)16 se afișează sub forma: 0x003C
 Ex.1. Să se stabilească forma internă și externă a reprezentării pe 2o/bytes a
numărului 300.
Succesiunea împărțirilor la 2 și a aflării cifrelor restului este: (fig.1)

Fig.1. Determinarea Xd a numărului 300 prin împărţiri succesive la 2

Formatul intern (așa este salvat în MO) al numărului 300 este:

0 0 0 0 0 0 0 1 0 0 1 0 1 1 0 0

215 214 ................................................... 28 ........................ 25 .............. 23 ... 22 ...............20

Formatul extern (reprezentarea în baza 16):

0 1 2 C
Fig.2
Folosind puterile bazei 2, numărul 300 se scrie astfel:
300 =1x28 + 1x25+ 1x23+ 1x22 = 1x162 + 2x161 + 12x160
Deci, folosind o locație din MO de 2o forma internă și respectiv externă a
numărului 300 sunt:
(300)10 = (0000 0001 0010 1100)2 = (012C)16
Obs. Succesiunea de cifre (10) reprezintă baza de numerație respectiv:
(10)2 = 2 pentru baza 2 ; (10)10 = 10 pentru baza 10 și (10)16 = 16 pentru baza 16
Sau, folosind cifrele corespunzătoare pentru reprezentarea fiecărei baze de
numerație, aceeași reprezentare se poate scrie:
 (300)10 = (0000 0001 0010 1100)2 = (012C)16
Reprezentarea aceluiași număr într-o locație a MO de 32biţi/4bytes are forma:
(300)10 = (00000000 00000000 00000001 00101100)2 = (00 00 01 2C)16

Obs. Spațiile s-au introdus pentru ușurarea urmăriri formei numerice

Domeniul reprezentabil
Domeniul de valori care se poate înscrie într-o locație de 2o/bytes a MO este:
0 ≤ N ≤ 216 -1 sau N ∈ [0 , 65535]
Pentru cazul general, în care locația are m octeți/bytes, respectiv se folosesc pentru
reprezentare n=mx8 biți, domeniul reprezentabil pentru valori întregi strict pozitive este:
0 ≤ N ≤ 2n -1
Nerespectarea domeniului de valori determină înscrierea unei valori eronate, care nu
corespunde valorii adevărate a numărului.

B. Reprezentarea numerelor întregi (numere întregi cu semn, mulțimea ℤ )

Numerele întregi pozitive se reprezintă în MO la fel ca și numerele strict pozitive,
adică prin codul direct (Xd). Pentru reprezentarea numerelor negative se folosește forma
codificată a acestora, respectiv codul complementar față de doi sau, pe scurt, codul
complementar (Xc). Prin această reprezentare se elimină semnificația semnului iar
operația de scădere se transformă într-o operație de adunare între două reprezentări care
folosesc baza doi. Dacă rezultatul scăderii este un număr pozitiv atunci forma obținută
reprezintă codul direct al rezultatului (numărul pozitiv). Atunci când rezultatul scăderii
este un număr negativ se obține codul complementar al acestuia. Pentru a afla codul
direct, respectiv rezultatul cu semn negativ, xc → xd. Prin convenție primul bit din stânga
reprezentării (b15) codifică semnul numărului. Astfel b15=0 corespunde reprezentării unui
număr pozitiv iar b15=1 corespunde unui număr negativ reprezentat în cod complementar
față de doi. Semnificația biților reprezentării unui număr întreg cu semn este:
 b15 b14 ....................................................................................................................... b1 b0

semn cifrele reprezentării în baza 2

b15 = MSb (Most Significant bit) = bitul semn.
Reprezentarea numerelor negative
Codul complementar față de doi sau codul complementar (Xc) se definește cu
relația:
𝑛
𝑋𝑐 = 𝑓(𝑥) = {𝑋𝑑 , 𝑥 < 0 2 − |𝑋|, 𝑥≥0}

(2)
unde n este numărul de biți folosiți pentru reprezentare sau dimensiunea locației MO. În
exemplul considerat n=16.
Regula directă. Codul complementar se obține prin modificarea cifrelor binare, de la
stânga spre dreapta, până la ultimul bit care are valoarea =1, astfel: 0→1 respectiv 1→0.
Ultimul bit cu valoare =1 (indiferent de poziția sa în cadrul reprezentării) își păstrează
valoarea (rămâne nemodificat). Biții aflați la dreapta ultimei cifre 1, care sunt toți egali cu
zero, rămân neschimbați. Deci, spre deosebire de codul invers, ultimul bit cu valoarea
unu (cel mai din dreapta), rămâne neschimbat iar zerourile din dreapta acestuia își
păstrează valoarea.
Domeniul reprezentabil
Deoarece pentru reprezentarea valorii numerelor întregi cu semn se folosesc 15 biți,
valoarea maximă pozitivă reprezentabilă este:
Nmax ≤ 2 15 -1 = 32767
Codul complementar al valorii minime reprezentabilă, deci numărul negativ cu
modul maxim, este:
(Nmin)c=1000 0000 de unde se obține codul direct - (Nmin) d = (1000 0000)2 = -32768
Deci:
 - 216 ≤ N ≤ 216 -1 sau N ∈ [-32768 , 32767]
Pentru cazul general, în care locația are m octeți/bytes, respectiv folosește n=mx8
biți, domeniul reprezentabil pentru valori întregi cu semn este:
- 2n ≤ N ≤ 2n -1
Erori de reprezentare
În situațiile în care valorile înscrise în locația MO nu corespund domeniului
corespunzător de reprezentare, valorile înscrise nu pot corespunde numărului considerat
iar interpretarea conținutului locației MO determină obținerea unui rezultat eronat, fără ca
eroarea de reprezentare să fie semnalizată.
Ex.4. a) Să se reprezinte numărul 40000 într-o locație având 2/16 o/biți. Forma
internă este:
Xd = (40000)10 = (1001 1100 0100 0000)2 = (9C40)16
Interpretarea conținutului acestei locații (b15=1) precizează faptul că numărul
reprezentat este un număr negativ iar reprezentarea este codul complementar față de 2 a
respectivului număr negativ. Codul direct, obținut conform regulii anterioare, este:
(X)c = (1001 1100 0100 0000)2 → (X)d = - (0110 0011 1100 0000)2 = - (63C0)16 =
-(25536)10
b) Să se reprezinte numărul -40000 într-o locație având 2o sau 16 biți. Forma
internă este:
Xd = - (40000)10 = - (1001 1100 0100 0000)2= - (9C40)16
Deoarece numărul care se reprezintă este un număr negativ se va înregistra în
locația MO codul complementar al valorii absolute a numărului.
Xd = - (1001 1100 0100 0000)2 → Xc = (0110 0011 1100 0000)2 = (63C0)16
Interpretarea conținutului reprezentării (b15 =0) precizează faptul că numărul
reprezentat este un număr pozitiv și deci reprezentarea constituie codul direct al
acestuia. Codul direct, obținut conform regulii anterioare, este:
Xd = (0110 0011 1100 0000)2 = (63C0)16 = ( 25536)10
 c) Să se reprezinte numărul 70000 într-o locație având 2o sau 16 biți. Forma internă
este:
Xd = (70000)10 = ( 1 | 0001 0001 0111 0000 | )2 = (1 | 1170 | )16
Se observă că reprezentarea în baza 2 a numărului 70000 cuprinde 17 biți. În locația
de 16 b se vor înscrie numai ultimele 16 cifre ale numărului, ceea ce înseamnă că
numărul memorat este:
Xd = (0001 0001 0111 0000)2 = (1170)16 = (4464)10

1.1.2. Reprezentarea caracterelor

Caracterele corespund semnelor grafice:
- alfabetul limbajului: cifre și litere mari și mici;
- alte simboluri grafice;
- comenzi privind poziționarea cursorului la afișare/tipărire (tabulare, rând nou ș.a.).
Pentru reprezentarea în MO a caracterelor se folosesc coduri numerice. În timp,
pentru realizarea programelor s-au folosit diferite coduri numerice pentru reprezentarea
caracterelor. În prezent este generalizat codul ASCII - American Standard Code for
Information Interchange care este definit prin standardul ISO/IEC 8859 și conține 256
de coduri/caractere (http://www.iso.ro/Utile/Numere/CoduriASCII.aspx).
În sistemul ASCII pentru memorarea fiecărui cod/caracter se folosește un octet/
byte. Primele 128 de poziții, respectiv [0,127] corespund ”alfabetului” oricărui limbaj de
programare și de aceea se spune că acestea alcătuiesc secțiunea: Coduri ASCII
caractere. Secțiunea a doua Coduri ASCII extinse, respectiv codurile [128,255], este
rezervată caracterelor ”speciale” (litere cu accent, litere care nu aparțin alfabetului
englez, simboluri grafice).
Variabilele pentru care se atribuie ca valori coduri ASCII sunt de tip char iar
locațiile folosite sunt de 1o/1byte. Deci, unei variabile de tip char, care foloseşte o
locație de 1o/byte, nu i se poate atribui ca valoare decât un singur caracter. Dacă se
încearcă atribuirea a două caractere unei variabile char, în locația de MO se va
înscrie/memora numai primul caracter.

Codurile ASCII - Comenzi

Codul Codul Codul Codul Caracterul Comanda
Explicații
zecimal hexazecimal octal binar reprezentat reprezentată
0 0 0 0000 NUL ^@ Null character
1 1 1 0001 SOH ^A Start of Header
2 2 2 0010 STX ^B Start of Text
3 3 3 0011 ETX ^C End of Text
4 4 4 0100 EOT ^D End of Transmission
5 5 5 0101 ENQ ^E Enquiry
6 6 6 0110 ACK ^F Aknowlodgemen
7 7 7 0111 BEL ^G Bell
8 8 10 1000 BS ^H Backspace
9 9 11 1001 HT ^I Horizontal Tab
10 A 12 1010 LF ^J Linee Fed
11 B 13 1011 VT ^K Vertical Tab
12 C 14 1100 FF ^L Form feed
13 D 15 1101 CR ^M Carriage return
14 E 16 1110 SO ^N Shift Out
15 F 17 1111 SI ^O Shift In
16 10 20 1 0000 DLE ^P Data Link Escape
17 11 21 1 0001 DC1 ^Q Device Control 1(oft. XON)
18 12 22 1 0010 DC2 ^R Device Control 2
19 13 23 1 0011 DC3 ^S Device Control 3(oft. XOFF)
20 14 24 1 0100 DC4 ^T Device Control 4
21 15 25 1 0101 NAK ^U Negative Aknowlodgemen
22 16 26 1 0110 SYN ^V Synchronous idle
23 17 27 1 0111 ETB ^W End of Transmission Block
24 18 30 1 1000 CAN ^X Cancel
25 19 31 1 1001 EM ^Y End of Medium
26 1A 32 1 1010 SUB ^Z Substitute
27 1B 33 1 1011 ESC ^[ Escape
28 1C 34 1 1100 FS ^\ File Separator
29 1D 35 1 1101 GS ^] Group Separator
30 1E 36 1 1110 RS ^^ Record Separator
31 1F 37 1 1111 US ^ Unit Separator
127 7F 177 111 1111 DEL ^? Delete
 Codurile ASCII - caractere

68 44 104 100 0100 D

Codul Codul Codul Codul Caract 69 45 105 100 0101 E
zecim în octal binar er 70 46 106 100 0110 F
al baza 16 repreze 71 47 107 100 0111 G
ntat 72 48 110 100 1000 H
32 20 40 010 0000 Space 73 49 111 100 1001 I
33 21 41 010 0001 ! 74 4A 112 100 1010 J
34 22 42 010 0010 “ 75 4B 113 100 1011 K
35 23 43 010 0011 # 76 4C 114 100 1100 L
36 24 44 010 0100 $ 77 4D 115 100 1101 M
37 25 45 010 0101 % 78 4E 116 100 1110 N
38 26 46 010 0110 & 79 4F 117 100 1111 O
39 27 47 010 0111 ‘ 80 50 120 101 0000 P
40 28 50 010 1000 ( 81 51 121 101 0001 Q
41 29 51 010 1001 ) 82 52 122 101 0010 R
42 2A 52 010 1010 * 83 53 123 101 0011 S
43 2B 53 010 1011 + 84 54 124 101 0100 T
44 2C 54 010 1100 , 85 55 125 101 0101 U
45 2D 55 010 1101 - 86 56 126 100 0110 V
46 2E 56 010 1110 . 87 57 127 101 0111 W
47 2F 57 010 1111 / 88 58 130 101 1000 X
48 30 60 011 0000 0 89 59 131 101 1001 Y
49 31 61 011 0001 1 90 5A 132 101 1010 Z
50 32 62 011 0010 2 91 5B 133 101 1011 [
51 33 63 011 0011 3 92 5C 134 101 1100 \
52 34 64 011 0100 4 93 5D 135 101 1101 ]
53 35 65 011 0101 5 94 5E 136 101 1110 ^
54 36 66 011 0110 6 95 5F 137 101 1111 _
55 37 67 011 0111 7 96 60 140 110 0000 `
56 38 70 011 1000 8 97 61 141 110 0001 a
57 39 71 011 1001 9 98 62 142 110 0010 b
58 3A 72 011 1010 : 99 63 143 110 0011 c
59 3B 73 011 1011 ; 100 64 144 110 0100 d
60 3C 74 011 1100 < 101 65 145 110 0101 e
61 3D 75 011 1101 = 102 66 146 110 0110 f
62 3E 76 011 1110 > 103 67 147 110 0111 g
63 3F 77 011 1111 ? 104 68 150 110 1000 h
64 40 100 100 0000 @ 105 69 151 110 1001 i
65 41 101 100 0001 A 106 6A 152 110 1010 j
66 42 102 100 0010 B 107 6B 153 110 1011 k
67 43 103 100 0011 C 108 6C 154 110 1100 l
 109 6D 155 110 1101 m 120 78 170 111 1000 x
110 6E 156 110 1110 n 121 79 171 111 1001 y
111 6F 157 110 1111 o 122 7A 172 111 1010 z
112 70 160 111 0000 p 123 7B 173 111 1011 {
113 71 161 111 0001 q 124 7C 174 111 1100 |
114 72 162 111 0010 r 125 7D 175 111 1101 }
115 73 163 111 0011 s 126 7E 176 111 1110 ~
116 74 164 111 0100 t
117 75 165 111 0101 u
118 76 166 111 0110 v
119 77 167 111 0111 w

1.1.3. Reprezentarea numerelor reale

Numerele reale se reprezintă în MO într-o formă convențională denumită
reprezentarea în virgulă mobilă (floating-point→virgulă plutitoare). În principiu,
imaginea unui număr real în MO se determină pornind de la forma rațională a
reprezentării în baza doi a numărului real și folosește, în cele mai multe cazuri, o locație
de 4o/32 biți. Se spune că s-au reprezentat valori/variabile de tip float. Atunci când este
necesar programatorul poate alege pentru reprezentarea numerelor reale și structuri
optime ale locațiilor folosite pentru memorarea numerelor reale, astfel încât să poată fi
înscrise și folosite în calcule. Astfel, numărul real poate fi memorat pe 32/64/80 biți prin
folosirea unei locații de 4/8/10 octeți/bytes, respectiv valori/variabile de tipul
float/double/long double. Tipul float folosește 4o/32biți respectiv memorează primele
23 cifre binare ale mantisei, se numește și reprezentare în simplă precizie. Tipul double
folosește 8o/64biți respectiv memorează primele 52 cifre binare ale mantisei, se numește
și reprezentare în dublă precizie.
Reprezentarea numerelor reale pozitive
Pentru determinarea reprezentării în baza 2 se folosește formă rațională în baza 10 a
numărului. Se prelucrează separat partea întreagă și partea rațională a reprezentării în
baza 10. Corespunzător, partea întreagă/rațională vor determina partea întreagă/rațională
a reprezentării în baza 2 sau 16.
 Partea întreagă a reprezentării se obține la fel ca și pentru numerele întregi. Partea
rațională a reprezentării în baza 2 se obține înmulțind succesiv cu 2 partea rațională a
numărului în baza 10 și reținând cifrele care apar succesiv în fața virgulei, în ordinea în
care se obțin. Se observă că, pentru cvasitotalitatea numerele reale, partea rațională a
reprezentării în baza 2 are un număr infinit de cifre zecimale. Fac excepție numai
numerele reale la care partea rațională este egală cu 0.5 (10/2) sau 0.25(10/4). De aici
rezultă că precizia conversiei numărului este determinată de numărul de cifre
zecimale considerate pentru partea rațională.

Ex.5 Se cere să se determine reprezentarea în bazele 2 și 16 a numărului 170.4 .

5.a Reprezentarea în baza 2 a numărului rațional
Determinarea părții întregi a reprezentării numărului (vezi pct.)
(170)10 = (1010 1010)2 = (AA)16
Determinarea părții raționale a reprezentării numărului s-a calculat cu 8 cifre
binare/2 cifre hexazecimale.
(0.4)10 = (0.0110 0110)2 = (0.66)16
Forma internă a reprezentării numărului se obține de la forma normalizată a
reprezentării în baza 2.
0 . 4*2
0 8
1 6
1 2
0 4
0 8
1 6
Fig. 3
Deci:
(170.4) 10 = (1010 1010 . 0110 0110)2 = (AA.66)16
 Pentru trecerea numărului în baza 16 este necesar, dacă este nevoie, să se
completeze reprezentarea părții raționale spre dreapta cu zerouri, astfel încât să se
evidențieze tetrade complete de cifre binare.
Forma internă/externă a reprezentării unui număr real se alcătuiește pe baza
formei normalizate a reprezentării numărului în baza 2.
Eroarea de reprezentare Se convertește reprezentarea în baza 2 la baza 10.
Pentru partea rațională:
(0.0110 0110)2 = (0.66)16 = 6/16 + 6/162 = 6/16 + 6/162 =0.398
Eroarea de reprezentare a părții raționale este ε = | 0.4-0.398|/0.4 x 100 =0.39 %
Dacă se consideră pentru reprezentarea numărului o singură cifră semnificativă în
baza 2, eroare de reprezentare este:
{(0.01)2 = 1/ 22 = 0.25} ε = | 0.4-0.25| / 0.4 x 100 = 37.5 %
Evident, dacă ne raportăm la valoarea întregului număr eroarea este:
ε = |170.4-170.398| x 100 / 170.4 = 0.0011 %
● Reprezentarea pe 4o/32 biți-tipul float a numărului 170.4
Corespunzător structurii acestei reprezentări se determină semnificațiile biților
reprezentării:
- b31 = 0 reprezintă semnul numărului (numărul 170.04 este pozitiv);
- b30 – b23 - 8 biți – sunt folosiți pentru caracteristica numărului:
e = 0000 111=7; δ = 7+127=134 sau δ = (1000 0110)2 = (86)16
- b22 – b0 - primii 23 de biți ai formei normalizate:→(0101 0100 1100 1100
0000 000)
Formatul intern al numărului 170.4 declarat de tipul float este :
170.4 → (0 | | 0101 0100 1100 1100 0000 000 )
Regrupând în tetrade binare cifrele reprezentării se obține:
(0100 0011 0010 1010 0110 0110 0000 0000) → (432A6600) (8 cifre hexazecimale)
● Reprezentatea pe 8o/64biți - tipul double a numărului 170.4
Reprezentarea normalizată a numărului este :
(170.4) = [ (1.0101 0100 1100 110 | 0) x(10)111 ] 2
 Semnificațiile biților reprezentării sunt:
- b63 = 0 reprezintă semnul numărului (numărul 170.04 este pozitiv);
- b62 – b52 - 11 biți – reprezintă caracteristica numărului.
e = 0000 111=7; δ = 7+1023=1030 sau δ = (100 0000 0110)2 = (406)16
- b51 – b0 - 52 de biți pentru mantisă: (0101 0100 1100 1000 0000
000..................0)
Formatul intern al numărului 170.4 declarat de tipul double este :
170.4 → (0 | 100 0000 0110 | 0101 0100 1100 1100 0000 000 )
Regrupând în tetrade binare cifrele reprezentării se obține:
(0100 0000 0110 0101 0100 1100 1100 0000........0000) → (40 65 4C C0 ....00)
(64 biți sau 16 cifre hexazecimale)
● Reprezentatea pe 10 o/80 biți - tipul long double a numărului 170.4
Reprezentarea normalizată a numărului este:
(170.4) = [ (1.0101 0100 1100 110 | 0) x(10)111 ] 2
Semnificațiile biților reprezentării sunt:
- b 79 = 0 reprezintă semnul numărului (numărul 170.04 este pozitiv);
- b78 – b64 - 15 biți – sunt pentru caracteristica numărului.
e = 0000 111=7; δ = 7+8191=8198 = (4006)16 ; δ = (100 0000 0000 0110)2 =
(4006)16
- b63 = 1;
- b62 – b0 - 63 de biți pentru mantisă: (0101 0100 1100 1100 0000 000..................0)
Formatul intern al numărului 170.4 declarat de tipul long double este:
170.4 → (0 | 100 0000 0000 0110 | 1 | 0101 0100 1100 1100 0000 000..................0)
Regrupând în tetrade binare cifrele reprezentării se obține:
( 0100 0000 0000 0110 010 1010 0110 0110 0000 000..........0) → (40 06 AA 66 00
....00) (80 de biți sau 20 cifre hexazecimale)
Ex.7 Să se determine forma internă și valoarea în baza 10 a numărului de tip float
(32biți/4o) a cărui forma externă este: 0x412C0000 .
Se determină forma internă a reprezentării numărului:
(412C)→(0100 0001 0010 1100 0000 0000 0000 0000 )
 Se evidențiază în cadrul formei externe câmpurile care o definesc:
-b31 - semnul numărului;
- b30 - b23 - caracteristica numărului;
- b22 - b0 - matisa corespunzătoare formei normalizate a numărului.
Pornind de la structura anterioară se obține:
(0| 1000 0010| 0101 1000 0000 0000 0000 000)
de unde rezultă:
- semnul numărului: b31 = 0 deci numărul este pozitiv;
- caracteristica numărului: b30 – b23 → (1000 0010) δ = (1000 0010)2 = (82)16 =
(130)10;
- exponentul numărului: e = δ- Δ = 130 - 127 = 3;
- mantisa normalizată: b22 – b0 = (0101 1000 0000 0000 0000 000)
- forma normalizată a numărului se obține prin:
●completarea cu cifra unu pe poziția unităților adică în fața virgulei;
●completarea cu zerouri la dreapta pentru alcătuirea tetradelor binare;
● se adaugă exponentul.
Aplicând acest algoritm se determină numărul în baza doi:
((1.0101 1000 0000 0000 0000 0000) x 1011)2 =(1010.1100 0000)2 =(A .C0) 16 =
(160 + 12/16)10 = 160.75.

1.2. Efectuarea operațiilor într-un sistem de calcul

În SC operațiile se pot executa numai între operanzi exprimați în forma internă.
Blocul de calcul ALU-Arithmetic Logic Unit, adică elementul hardware care realizează
toate operațiile de calcul cerute într-un program, poate efectua electronic numai
operația de adunare. Scăderea se convertește într-o operație de adunare prin
reprezentarea numerelor negative în cod complementar față de doi. Înmulțirea se reduce
la o succesiune de adunări iar împărțirea la o succesiune de adunări în care împărțitorul
este reprezentat în cod complementar. Restricția generală este ca formatul intern al
operanzilor să fie de același tip.

1.2.1. Operații între numere întregi

Operația de adunare între operanzi de semn diferit se efectuează întotdeauna fără
eroare. Rezultatul se obține în cod direct dacă este pozitiv și în cod complementar dacă
este negativ. Pentru operanzi cu același semn este necesar să se verifice ca rezultatul să
aparțină domeniului reprezentabil. În caz contrar se memorează o valoare eronată dar nu
se semnalizează situația de eroare.
Ex.7 Pentru exemplificare se vor considera operanzi de tipul short (2 o/bytes). Se
va folosi forma externă a operanzilor, respectiv 4 cifre în hexazecimale/baza 16.
Fie operanzii: a = (542)10 = (021E)16 și b = (360)10 = (0168)16 și operațiile notate
7.1-7.4. Să se verifice operațiile, să se alcătuiască formatul intern al operanzilor și
rezultatelor și să se indice valorile indicatorilor de condiție.
7.1. c = (a+b)10 = (542 +360)10 = (902)10 sau c= (021E)16+(0168)16 = (0386)16 = (3*162
+ 8*161 +6*160 )10
7.2. c = (a-b)10 = (542-360)10 = (182)10 sau c= (021E)16-(0168)16 =(021E)16 + (FE98)16
= (00B6)16 =(3*161 +6*160 )10=(182)10
7.3. c = (-a+b)10 = (-542 +360)10 = -(182)10 sau c= -(021E)16+(0168)16 = (FDE2)16 +
(0168)16 = (FF4A)16 = - (00B6)16 = - (11*161 +6*160 )10= - (182)10
7.4. c = (-a - b) = (-542 - 360)10 = -(902)10 sau c= -(021E)16-(0168)16 = (FDE2)16 +
(FE98)16 = (FC7A)16 = - (0386)16 = - (3*162 + 8*161 +6*160)10= - (902)10
7.5. Să se însumeze operanzii: a= (15000)10 = (3A98)16 și b=(20000)10 = (4E20)16
c=(a+b) = (55000)10 + (20000)10 = (75000)10 c=(D6D8)16 + (4E20)16 = 1(24F8)16 =
(75000)10
Cifra 1 în fața parantezei arată apariția unui transfer spre rangul b16. Dar, acest bit
NU poate fi memorat deoarece locația are numai 16 biți, identificabili prin: [b15 – b0]. În
locația c se înscrie valoarea eronată:
 c=(24F8)16 = (2*163 + 4*162 +15*161 + 8*160 )10 = (9464)10
În prelucrările ulterioare SC va considera c=9464, fără a semnaliza programului că
aceasta este o valoare incorectă. Altfel spus, transferul în rangul superior nu constituie o
situație de ”excepție neprevizibilă” și care este automat evidențiată. De aceea, pentru
evitarea acestui tip de eroare programatorul trebuie să anticipeze posibilele valori care se
vor atribui variabilelor în timpul executării programului și să folosească tipuri de date
(dimensiuni ale locațiilor MO) corelate cu acestea. Pentru acest exemplu soluția este
folosirea datelor întregi de tip int sau long, respectiv atribuirea locațiilor de 4 sau 8
o/bytes.

1.2.2. Operații între operanzi reali

Având în vedere atât modul de reprezentare a numerelor reale (sub formă de
mantisă și exponent) cât și valorile curente atribuite variabilelor reale, nu există pericolul
depășirii domeniului reprezentabil în cazul operațiilor cu numere reale. Declararea
apriorică a tuturor variabilelor ca fiind de tip float poate constitui cauza altor erori. În
continuare sunt evidențiate două astfel de situații.
Verificarea egalității cu zero. Se cunoaște că numerele reale, în special valorile
calculate, se reprezintă cu un număr infinit de zecimale. De aceea verificarea egalității a
două variabile de tip real nu este posibil întotdeauna. De exemplu, verificarea domeniului
de definiție al unei funcții raționale cu coeficienți numere reale, revine la verificarea
condiției: numitorul≠0. Pentru a avea o verificare certă a acestei condiții se definește o
vecinătate a lui zero (fig.5 și fig.6).
-5≈ –6
O valoare eps = (1.0 1.0 ) este acoperitoare deoarece corespunde cifrelor care
sunt determinate corect. Acestea sunt primele 5 sau 6 cifre semnificative ale numărului
reprezentat în baza 10.
Dacă numitorul se află în exteriorul acestei vecinătăți se acceptă că este nenul.
Această precauție nu este necesară în cazul numerelor întregi, la care forma internă a
reprezentării are un număr finit de cifre în baza 2.
 Impunerea folosirii numerelor întregi. Câteva variabile care trebuie să fie de tip
întreg sunt: indexul/coordonata folosită pentru identificarea locațiilor într-o arie de date
sau contorul într-o secvență repetitivă cu contorizare.
Ex.8 Se consideră expresia e = (x+5)/(y-2)
Pentru y = int se poate folosi condiția: (y-2)≠0.
Pentru y=float aceeași condiție poate stabili rezultate diferite, în funcție de modul
în care a fost calculată valoarea lui y. De aceea, pentru evitarea unor rezultate eronate este
-5≈
indicat să se folosească o expresie de forma: | y -2. | > eps unde eps = 1.0 1.0 -6.
Exprimarea geometrică a acestei condiții este prezentată în fig.4.

Fig.4
Este evident că erorile datorate reprezentării ca număr de tip float cresc dacă
valoarea acestuia se obținute prin intermediul unor calcule complexe.
Ex.9 Fie variabile reale x și y care sunt definite astfel:
x=5.2 și y = x-3.2.
Se cere să se stabilească valoarea logică a expresiei (y = 2.0)? Verificând printr-un
program se obține rezultatul FALS, ceea ce din punct de vedere matematic este incorect,
eroarea fiind consecința modului de reprezentare a valorii reale a lui y. Interpretarea
grafică a situării valorii variabilei y în vecinătatea lui 2 este reprezentată în fig.5.

Fig.5
 1.3. Operații relaționale
Pentru verificarea valorilor variabilelor (de ex. apartenența la un domeniu de
definiție) în programele de calcul se folosesc expresii relaționale și/sau logice (vezi și
pct.4).
Expresiile relaționale se alcătuiesc prin înlănțuirea operanzilor, care pot fi
expresii/variabile/constante numerice, cu ajutorul operatorilor relaționali. Rezultatul
evaluării unei expresii relaționale este o valoare logică: ADEVĂRAT/TRUE sau
FALS/FALSE. Se reamintește că aceste valori sunt exprimate printr-un numărul întreg
1 pentru valoarea logică ADEVĂRAT/TRUE sau prin valoarea 0 pentru valoarea logică
FALS/FALSE. Această valoare logică poate fi folosită pentru definirea modului de
efectuare a unor instrucțiuni (de decizie sau repetitive).
În C/C++, deși nu este definit tipul de date logic/boolean, se poate atribui unei
variabile de tip int rezultatul logic al evaluării unei expresii relaționale sau logice. În Java
sunt definite tipul boolean și valorile logice corespunzătoare acestuia: true/false. De
aceea alcătuirea în Java a unei expresii relaționale este mai explicită. Memorarea acestor
valori se efectuează conform convenției aplicate în C/C++.
Operatori relaționali, aceeași ca și în matematică, sunt:
< (mai mic); <= (mai mic sau egal);
> (mai mare); >= (mai mare sau egal);
!= diferit: = = (egal).
Prioritatea operatorilor relaționali este aceeași, dar este mai mică decât a
operatorilor aritmetici. De aceea, la evaluarea unei expresii relaționale se evaluează întâi
expresiile aritmetrice/algebrice și apoi, rezultatele astfel obținute sunt analizate prin
intermediul operatorilor relaționali.
Pentru evaluarea expresiilor relaționale la nivelul μProcesorului se calculează
diferența operanzilor, care nu poate fi decât o valoare numerică. În funcție de semnul
rezultatului: pozitiv/negative/zero se apreciază valoarea expresiei relaționale
ADEVĂRAT/FALS. Această valoare poate fi memorată printr-o variabilă întreagă. (vezi
Ex.10). Efectuarea acestui calcul NU modifică valorile operanzilor înscrise în MO.
Ex.10. Să se precizeze valoarea indicatorilor de condiție pentru secvența:
.............
int x=10, y;
y = x > =7;
Se efectuează operația: x - 7= 3 al cărei rezultat este un număr pozitiv. Deci se
stabilește că y =ADEVARAT și se memorează y = 1.
Ex.11 Pentru următoarea secvență C/C++ să se verifice formatul extern al
variabilelor de tip short folosite/calculate și să se comenteze rezultatele.
......................
int x=6, y=10; // x=(0006)16 ; y=(000A)16
y=x<=10; // y=(0001)16
y=(x+4) != 10; // y=(0000)16
y= (x = = 6); // y=(0001)16
....................
Ex.12 Pentru următoarea secvență Java să se precizeze formatul extern al
variabilelor de tip short folosite și să se comenteze rezultatul. Se va folosi formatul
extern.
......................
boolean x=true, y;
y=false;
y=(x+4) != 10; // The operator + is undefined for the argument boolean
y = (x = = 6); // The operator == is undefined for the argument boolean
......................
Obs. Spre deosebire de C/C++, în Java nu sunt acceptate expresii de calcul care
includ variabile de tip boolean și short, int, ș.a.
 1.4. Operații logice
Toate limbajele de programare au definite operațiile logice. Forma de
implementare poate fi însă diferită. De aceea programatorul trebuie să cunoască modul în
care sunt definite aceste operații în limbajul de programare folosit pentru implementarea
programului său. Operațiile logice sunt implementate în două variante:
- cu considerarea globală a operanzilor (pe întreaga locație a MO) și
- cu aplicarea operatorilor la nivelul fiecărui bit al operanzilor.

1.4.1. Operații cu întregul operand

Operatorii logici la nivel de locație de MO sunt:
- ! negarea logică (NOT) – se aplică unui operand (operator unar);
- && produsul logic (SI/AND) – se aplică între doi operanzi;
- | | suma logică (SAU/OR) – se aplică între doi operanzi.
Prioritatea operatorilor logici este: ! (negarea) → &&(produsul)→ ||(suma)
Aceste funcții se exprimă sub formă de tabel de adevăr în care: A-reprezintă
valoarea logică ADEVĂRAT/true iar F- valoarea logică FALS/false.
Funcția ! Funcția && Funcţia | |

X !X X Y X && Y X Y X || Y
F/0 A/1 F/0 F/0 F/0 F/0 F/0 F/0
A/1 F/0 F/0 A/1 F/0 F/0 A/1 A/1
A/1 F/0 F/0 A/1 F/0 A/1
A/1 A/1 A/1 A/1 A/1 A/1

Obs. Indiferent de tipul declarat pentru variabila folosită pentru memorarea

rezultatului: short(2o); int(4o) sau long(8o) numai b0 va înscrie valoarea 1 sau 0, în
corespondență cu valoarea logică a rezultatului ADEVARAT/FALS.
 Ex.13 Pentru secvența C/C++ să se precizeze valoarea expresiei logice și forma
internă a valorii variabilei t. A→ reprezintă valoarea logică ADEVĂRAT; F→ reprezintă
valoarea logică FALS.
..................
int x=10, y=5, z=4, t; // t→4 o/bytes
t = (x >= 5) && !(y==6) || (z!=4);
Considerând valorile cu care variabilele au fost inițializate prin instrucțiunea de
declarare, se evaluează fiecare operand și întreaga expresie după cum urmează:
(x>=5) → A ; !(y==6)→A (z!=4)→F ; t=A && A || F = A
Valoarea înscrisă în locația atribuită lui t este: t=(0000 0000 0000 0001)

1.4.2. Operații la nivel de bit

Operațiile logice definite la nivelul locațiilor de MO se deosebesc de operațiile
logice pe bit prin:
- operația se execută la nivelul fiecărui bit al operandului/operanzilor;
- rezultatul operațiilor pe bit este determinat de interpretarea ansamblului
biților locației, care s-au obținut pe baza operației date.
Dacă locațiile operanzilor și rezultatului au dimensiuni diferite, se realizează
conversia implicită la dimensiunea maximă. Dar aceasta poate determina înregistrarea
unei valori eronate.
Operatorii logici la nivel de bit sunt:
- ~ : negarea logică/complementul față de unu – se aplică unui bit (operator
unar);(~bi)
- & : produsul logic(SI/AND) – se aplică între biți; (ci)= (ai) & (bi)
- | : suma logică(SAU/OR) – se aplică între doi biți; (ci)= (ai) | (bi)
- ^ : sau exclusiv/suma modulo doi - se aplică între doi biți;
(ci)= (ai) &(~bi) | (~ai) &(bi)
 - >> d : deplasare la dreapta a operandului cu d biți. Este echivalentă cu
împărțirea cu 2d a numărului. Dacă locația atribuită operandului are n biți atunci pentru
deplasarea la dreapta se aplică relația: (bi-d) = (bi) și bm =0 , m∈[n-1,n-d].
- << k : deplasare la stânga a operandului cu k biți. Este echivalentă cu
înmulțirea cu 2k a numărului. Dacă locația atribuită operandului are n biți atunci pentru
deplasarea la stânga se aplică relația: (bi+k) = (bi) și bm =0 , m∈ [0,k-1].
Operatorii ~ ; >> ; << sunt prioritari față de ceilalți operanzi. Prioritatea
operatorilor definiți pentru doi operanzi este, în ordine descrescătoare: ⊕ → & → | .
Funcția logică sau exclusiv denumită și funcția modulo doi este folosită pentru a
verifica egalitatea a doi biți (vezi tabelul de adevăr). Această funcție se definește cu
relația:
zi = xi ⊕ yi =(~ xi)&( yi) | (xi)&(~ yi)

Funcția x ⊕ y

Xi Yi Zi
F/0 F/0 F/0
F/0 A/1 A/1
A/1 F/0 A/1
A/1 A/1 F/0

Ex.14. Pentru secvența C/C++ următoare să se verifice valorile calculate pentru

variabilele (a - f) și să se alcătuiască forma externă a acestora.
..................
short x = 4387, y = 10545; // x=0x1123 ; y=0x2931
short a, b, c, d, e, f;
a = ~ x; // a=0xEEDC
b = x | y; // b→ 0x3933
c = x & y; // c→0x0121
d = a ^ b; // d →0x3812
 e = x >> 2; // e →0x0448
f = y << 3; // f → 0x8918
În continuare, aplicând funcțiile logice indicate biților formei interne a
reprezentării fiecărei variabile, se determină forma internă a fiecărei variabile.

1 1 2 3
X→ 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 1

2 9 3 1
Y→ 0 0 1 0 1 0 0 1 0 0 1 1 0 0 0 1

~ X→ { a 1= ~ 1x
i i
1 0 1 1 1 0 1 1 0 1 1 1 0 0

X|Y → { b0=x |0y 1

i i i
1 1 0 0 1 0 0 1 1 0 0 1 1

X&Y→ { c 0=x &0 y0

i i i
0 0 0 0 1 0 0 1 0 0 0 0 1

X^Y→ { d0=x ^0 y 1
i i i
1 1 0 0 0 0 0 0 1 0 0 1 0

X>>2→ { e 0 =x0
i-2 i
0 0 0 1 0 0 0 1 0 0 1 0 0 0

X<<3→ { f 1 =x0
i+3 i
0 0 1 0 0 1 0 0 0 1 1 0 0 0
2. Întrebări de autocontrol
1. Ce este un byte? Care este denumirea în limba română?
2. De câți biți este necesar pentru a reprezenta numărul (13)10? Dar numărul
(6)16?
3. Câte cifre în baza 16 sunt necesare pentru reprezentarea unui număr binar pe
32biți?
4. Cum se deosebesc în reprezentarea binară numerele întregi pozitive de cele
negative? (considerând că sunt reprezentate pe 32 biți).
5. Cum se stabilește numărul de octeți necesari păstrării unei valori numerice?
6. Să presupunem că vrem să memorăm un număr care ocupă 27 biți. Câți octeți
vom rezerva în memorie pentru numărul respectiv?
7. Având în vedere codurile ASCII, câți biți sunt diferiți între reprezentările ’A’
și ’a’?
8. Ce sunt erorile de reprezentare? Pot apărea erori de reprezentare în cazul
numerelor întregi?
9. Cum se pot strecura erori în cazul operațiilor cu numere întregi?
10. Având în vedere secțiunea ”operații relaționale”, ce reprezintă semnul „< >„?
11. Ce valoare se memorează în limbajul C în cazul în care se evaluează expresia
3<6?
12. Ce operație reprezintă semnele: ~, ^, |, &, !, <<, >>?
13. Care este deosebirea dintre operatorul & și &&? Dar dintre | și || ?
3. Exerciții pentru fixarea cunoștințelor.
1. Realizați conversia următoarelor numere din baza 10 în baza 2 folosind
reprezentări pe 16 biți: 16, 32, 48, 63, 64, 128, 250, 255, 1024, 1280, 2048,
2050, 10000, 65535.
2. Realizați conversia următoarelor numere din baza 10 în baza 2 folosind
reprezentări pe 16 biți: -16, -32, -48, -63, -64, -128, -250, -255, -1024, -1280,
-2048, -2050, -10000, -32764.
3. Realizați următoarele operații folosind reprezentarea numerelor în baza 2:
a. 25+128=
b. 68+165=
c. -32+128=
d. -89-67=
e. 129-47=
f. 253+(-15)=
g. 12-158=
4. Transformaţi următorul număr 1101 0111 1010 1111 în formă hexazecimală.
Ce valoare reprezintă în baza 10?
5. a. Reprezentați -5 în formă binară pe 16 biţi.
b. Evaluaţi expresia 25+(-5) sub formă binară.
c. Transformaţi rezultatul în baza 10.
6. Realizați conversia în baza 2 pe 16 biți și aplicați operațiile logice NOT,
AND, OR la nivel de bit asupra următoarelor numere (sau combinații ale
acestora): 27, 35, 87, 96, -111, -145, 198, 243,-243
4. Exerciții pentru aprofundarea cunoștințelor.
1. Realizați conversia următoarelor numere din baza 10 în baza 16: 16, 32, 48,
63, 64, 128, 250, 255, 1024, 1280, 2048, 2050, 10000, 65535.
2. Realizați următoarele operații folosind reprezentarea numerelor în baza 16:
a. 25+128=
b. 68+165=
c. 32+128=
d. 89-67=
e. 129-47=
f. 223+15=
g. 192-158=
3. Reprezentați următoarele numere în format virgulă mobilă pe 32 biți (float):
12.5, 15.75, 23.625, 347.125, 655.375
4. Reprezentați următoarele numere în format virgulă mobilă pe 64 biți
(double):
39.5625, 3.25125
5. Considerând a=23, b=89, c= 162 realizați următoarele operații la nivel de bit:
!a=, !b=, !c=,
a&b=, a|b=, b&c=, c|b=,
!a&!b=, !(c|a)=,
!(a&c)=, (a|b)&(a&b)=.
6. Considerând a=23, b=89, c= 162 evaluați următoarele expresii logice:
a<b=, c>a=, (b<c)&&(b<a)=,
!(a>b)||!(c>a)=, !(a>b)=,
!(b>c)||(a<b)=, !((a<c)&&!(c>a))=.