Laborator 4 – suport teoretic

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

Î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
5. Structura internă a unui SC şi a unui µP

1. Reprezentarea informațiilor în MO
Toate informațiile (date/instrucțiuni) se reprezintă/înscriu în MO numai sub formă
codificată numeric. Dispozitivele tehnice folosibile pentru realizarea MO pot avea numai
două stări stabile de funcționare, care se pun în corespondență cu cifrele bazei doi {0,1}.
De ex., exagerând puțin, un condensator electric este/nu este încărcat cu sarcină electrică,
un corp este magnetizat nord/sud, un tranzistor este saturat/blocat, “pits” (gropi) și
“lands” (terenuri) pe suprafață unui CD [1]. Memorarea și prelucrarea informațiilor se
realizează în cvasitotalitatea cazurilor prin grupe de câte 8 biți (octet/byte-B).
Forma/imaginea în MO a codificării numerice a valorii atribuite unei variabile se numește
forma internă a reprezentării acesteia. Pentru afișare, forma internă (numărul în baza
doi) se convertește în baza 16 (hexazecimală). Se obține astfel forma externă a
reprezentării interne. Aceasta este numai o convenție pentru afișare, deoarece în MO
numărul se înscrie întotdeauna în baza doi.
Forma sub care se codifică informațiile, după reprezentarea în baza doi, este
determinată de tipul informației pe care numărul respectiv o reprezintă. De ex. numerele
întregi/reale se codifică după reguli diferite iar pentru caractere/simboluri grafice se
definesc coduri numerice. Interpretarea valorilor înscrise în MO este determinată
numai de precizările/cerințele existente în programul care prelucrează respectivele
informații. Folosirea corectă a informațiilor este determinată de respectarea unei
corespondențe riguroase între conținutul unei locații a MO și modul în care acesta este
interpretat de către program. Ignorarea acestei cerințe determină compromiterea lucrării
datorită obținerii unor rezultate eronate.

Reprezentarea numerelor în baza doi/hexazecimală

Forma efectivă a reprezentării în baza doi a unui număr folosește un format fix și
este determinată de dimensiunea locației MO/numărul de octeți folosiți pentru
memorarea/ înscrierea sa. Dimensiunile locațiilor sunt stabilite prin ”declarațiile” privind
tipul variabilelor/valorilor care se folosesc în programul care se execută. În locațiile
atribuite variabilelor se înscriu valorile acestora, după codificarea prin intermediul bazei
doi. Domeniul și precizia reprezentării numerelor sunt determinate de dimensiunea
/numărul de octeţi atribuiți locației folosite pentru memorarea fiecăruia.
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. Pentru o realizare corectă a
unui program este necesar să existe o corespondență între tipul ales/declarat pentru o
variabilă și valorile atribuite acesteia. Tipul declarat pentru o variabilă nu poate fi
modificat prin declarații ulterioare asupra acesteia.
Obs. Dimensiunea locației din MO folosită pentru înscrierea unei valori numerice,
deci formatul fix, este specific fiecărei platforme software pe care este implementat
limbajul de programare.
Ex. Pentru C/C++ implementat pe platforma BorlandC (sau pentru compilatoare
dedicate unor microcontrolere) înscrierea valorii unui număr întreg atribuit unei variabile
de tip int folosește 2octeţi (fig.1.a). În schimb, C/C++ implementat pe platforma Eclipse
folosește pentru același tip de variabilă 4octeţi (fig.1.b).

a) b)
Fig.1. Alocare spaţiu în MO pentru tipul de date „int”, a – alocare 2 octeţi în cazul
BorlandC, b – alocare 4 octeţi în cazul Eclipse (MinGW)

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.
➢ Reprezentarea numerele întregi și strict pozitive (numere întregi fără semn,
mulțimea ℕ) se înscriu în MO (forma internă), 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.2). 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.2)
 Fig.2. Determinarea Xd a numărului 300 prin împărţiri succesive la 2

Formatul intern (î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 (baza 16):

0 1 2 C
Fig.3
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.
Ex.2. La reprezentarea numerelor 65536 și 65600 forma înscrisă și care va fi
folosită în calcule este:
(65536)10 → (0000)16 ; (65600)10 = (00000000 01000000)2 = (0040)16 = (64)10
În toate aceste exemple s-a avut în vedere ipoteza aleasă: reprezentarea numerelor
întregi și pozitive folosind 2o/bytes.
Dacă se încearcă memorarea unui număr negativ înregistrarea efectivă este compromisă
(vezi Ex.4).
➢ 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.

Coduri de reprezentare a numerelor negative

Sunt definite două coduri de reprezentare a numerelor negative: codul
complementar față de unu respectiv codul complementar față de doi.
Codul complementar față de unu sau codul invers (Xi) se definește cu relația:
𝑛
𝑋𝑖 = {𝑋𝑑 , 𝑋≥0 2 − |𝑋| − 1, 𝑋 < 0

(1)
unde n este numărul de biți folosiți pentru reprezentare sau dimensiunea locației MO. În
exemplul considerat n=16.
Regulă directă. Codul invers se obține prin modificarea, de la stânga spre dreapta, a
tuturor cifrelor binare astfel: 0→1 respectiv 1→0.
Ex.3. Fie numerele 300 și -300
Pentru numărul pozitiv 300 se folosește codul direct.
X=Xd = (0000 0001 0010 1100)2 = (012C)16
Pentru numărul negativ -300 se folosește codul invers, determinat conform regulii
anterioare. Deci:
 Xi = (1111 1110 1101 0011)2 = (FED3)16
Verificare. Conform lui (1) se determină:
Xi = 216 - |-300|-1 = 65536 -300-1=(65235)10 sau, folosind baza 16:
Xi = 1 0000 – (012C)16 -1 = (FED3)16
Obs. Codul invers al unui număr negativ se recunoaște și prin acea că prima cifra a
reprezentării externe (deci în baza 16) este strict mai mare ca 7 sau, altfel spus, este cel
puțin egală cu 8.
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.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).
Codul ASCII a fost propus în anul 1960 iar primul standard a fost aprobat în 1963.
Ulterior acest standard a fost revizuit și actualizat în 1967 și 1986.
(ro.wikipedia.org/wiki/ASCII). În anul 1998 a fost aprobat standardul ISO
8859-1(Latin1) care codifică setul de caractere specific ariei geografice Western
European.(en.wikipedia.org/wiki/ISO/ IEC_8859-1). Începând cu 1999 s-au aprobat noi
standarde, care constituie părți ale ISO 8859-x, ultimul standard ISO 8859-16 care
conține și caracterele specifice limbii române fiind aprobat în 2001. Diferențele între
aceste standarde se referă numai la codurile ASCII extinse, care reprezintă caractere
specifice fiecărui tip de alfabet: Western European, Central European, Fantasy
mix.(en.wikipedia.org/wiki/ISO/IEC _8859).
Obs. Codurile ASCII extinse prezentate în continuare s-au preluat din
implementarea DEV C++, care este anterioară impunerii standardelor ISO. Platforma
Eclipse are implementat standardul ISO 8859-1. Dacă programatorul dorește să
folosească și caracterele corespunzătoare codurilor ASCII extinse atunci este necesar ca
în prealabil să verifice care standardul ISO 8859-x este implementat.
 Î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

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

133 85 205 10000101 à

Codul Codul Codul Codul Caracter 134 86 206 10000110 å
zecimal hexa octal binar 135 87 207 10000111 ç
128 80 200 10000000 Ç 136 88 210 10001000 ê
129 81 201 10000001 ü 137 89 211 10001001 ë
130 82 202 10000010 é 138 8A 212 10001010 è
131 83 203 10000011 â 139 8B 213 10001011 ï
132 84 204 10000100 ä 140 8C 214 10001100 î
141 8D 215 10001101 ì 186 BA 272 10111010 ║
142 8E 216 10001110 Ä 187 BB 273 10111011 ╗
143 8F 217 10001111 Å 188 BC 274 10111100 ╝
144 90 220 10010000 É 189 BD 275 10111101 ╜
145 91 221 10010001 æ 190 BE 276 10111110 ╛
146 92 222 10010010 Æ 191 BF 277 10111111 ┐
147 93 223 10010011 ô 192 C0 300 11000000 └
148 94 224 10010100 ö 193 C1 301 11000001 ┴
149 95 225 10010101 ò 194 C2 302 11000010 ┬
150 96 226 10010110 û 195 C3 303 11000011 ├
151 97 227 10010111 ù 196 C4 304 11000100 ─
152 98 230 10011000 ÿ 197 C5 305 11000101 ┼
153 99 231 10011001 Ö 198 C6 306 11000110 ╞
154 9A 232 10011010 Ü 199 C7 307 11000111 ╟
155 9B 233 10011011 ¢ 200 C8 310 11001000 ╚
156 9C 234 10011100 £ 201 C9 311 11001001 ╔
157 9D 235 10011101 ¥ 202 CA 312 11001010 ╩
158 9E 236 10011110 ₧ 203 CB 313 11001011 ╦
159 9F 237 10011111 ƒ 204 CC 314 11001100 ╠
160 A0 240 10100000 á 205 CD 315 11001101 ═
161 A1 241 10100001 í 206 CE 316 11001110 ╬
162 A2 242 10100010 ó 207 CF 317 11001111 ╧
163 A3 243 10100011 ú 208 D0 320 11010000 ╨
164 A4 244 10100100 ñ 209 D1 321 11010001 ╤
165 A5 245 10100101 Ñ 210 D2 322 11010010 ╥
166 A6 246 10100110 ª 211 D3 323 11010011 ╙
167 A7 247 10100111 º 212 D4 324 11010100 ╘
168 A8 250 10101000 ¿ 213 D5 325 11010101 ╒
169 A9 251 10101001 ⌐ 214 D6 326 11010110 ╓
170 AA 252 10101010 ¬ 215 D7 327 11010111 ╫
171 AB 253 10101011 ½ 216 D8 330 11011000 ╪
172 AC 254 10101100 ¼ 217 D9 331 11011001 ┘
173 AD 255 10101101 ¡ 218 DA 332 11011010 ┌
174 AE 256 10101110 « 219 DB 333 11011011 █
175 AF 257 10101111 » 220 DC 334 11011100 ▄
176 B0 260 10110000 ░ 221 DD 335 11011101 ▌
177 B1 261 10110001 ▒ 222 DE 336 11011110 ▐
178 B2 262 10110010 ▓ 223 DF 337 11011111 ▀
179 B3 263 10110011 │ 224 E0 340 11100000 α
180 B4 264 10110100 ┤ 225 E1 341 11100001 ß
181 B5 265 10110101 ╡ 226 E2 342 11100010 Γ
182 B6 266 10110110 ╢ 227 E3 343 11100011 π
183 B7 267 10110111 ╖ 228 E4 344 11100100 Σ
184 B8 270 10111000 ╕ 229 E5 345 11100101 σ
185 B9 271 10111001 ╣ 230 E6 346 11100110 µ
 231 E7 347 11100111 τ 246 F6 366 11110110 º
232 E8 350 11101000 Φ 247 F7 367 11110111 ≈
233 E9 351 11101001 Θ 248 F8 370 11111000 °
234 EA 352 11101010 Ω 249 F9 371 11111001 ∙
235 EB 353 11101011 δ 250 FA 372 11111010 ·
236 EC 354 11101100 ∞ 251 FB 373 11111011 √
237 ED 355 11101101 φ 252 FC 374 11111100 ⁿ
238 EE 356 11101110 ε 253 FD 375 11111101 ²
239 EF 357 11101111 ∩ 254 FE 376 11111110 ■
240 F0 360 11110000 ≡ 255 FF 377 11111111
241 F1 361 11110001 ±
242 F2 362 11110010 ≥
243 F3 363 11110011 ≤
244 F4 364 11110100 ⌠
245 F5 365 11110101 ⌡

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). Formatul intern al
numerelor reale este o structură tip care se stabilește conform precizărilor standardului
IEEE 754-2008 sau, forma actualizată a acestuia, ISO/IEC/IEEE 60559:2011. Î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 %
Obs. Precizia conversiei unui număr real este influențată semnificativ de numărul
de cifre considerate la schimbarea de bază. Indiferent de baza de numerație folosită,
numărul cifrelor corespunzătoare părții întregi este întotdeauna finit și cunoscut. Erorile
apar datorită faptului că partea rațională se convertește cu un număr infinit de cifre. Se
poate recomanda ca alegerea numărului de octeți folosiți pentru memorarea unui număr
real (dimensiunea locației din MO) respectiv 4 / 8 / 10 o/bytes să se coreleze cu valoarea
absolută a numărului și precizia dorită a rezultatului.
a. Forma normalizată a reprezentării
Forma normalizată a reprezentării este forma exponențială a numărului la care
exponentul se calculează astfel încât prima cifră semnificativă a reprezentării (prima cifră
1 a numărului) să se afle pe poziția cifrei unităților.
 Forma normalizată a reprezentării anterioare este:
(1010 1010 . 0110 0110)2 = [ (1.0101 0100 1100 110 | 0) x(10)111 ] 2
unde:
- s-a completat partea dreaptă a părții raționale cu o cifră zero astfel încât să se
obțină tetrade complete de cifre în baza 2, ceea ce permite alcătuirea imediată a formei
externe;
- s-a calculat exponentul, ca număr întreg, corespunzător formei normalizate:
e = (7)10 = (111)2
b. Determinarea caracteristicii (δ)
Cei 4o folosiți pentru înscrierea valorii unui număr real ar trebui să memoreze
următoarele informații:

…….. ……

b31 b30 b29 ............................................. b23 b22 b21 ……………. b1 b0

MSb SE exponentul mantisa normalizată

unde:
- b31 /MSb codifică semnul numărului. Numerele raționale pozitive au prima cifră a
formei externe cel mult egală cu 7;
- b30 codifică semnul exponentului SE;
- b29 - b23 memorează cifrele exponentului;
- b0 - b22 reprezintă cifrele mantisei corespunzătoare formei normalizate a
reprezentării numărului real.
Cei 8 biți ai exponentului (bitul semn + 7 cifre) corespund domeniului de valori
[-128,127] (vezi Ex.3).
Pentru evitarea reprezentării a două cifre semn (număr și exponent) s-a înlocuit
exponentul printr-o mărime echivalentă denumită caracteristică sau exponentul mediat
(b23, b30). Caracteristica unui număr real scris sub formă exponențială normalizată este un
număr întreg fără semn, care folosește pentru reprezentare 1o/8biți. Domeniul de valori al
caracteristicii este [0,255]. (vezi Ex.1). Se observă că ambele domenii, [-128,127] și
[0,255], așa cum este și firesc, au 256 de poziții, corespunzătoare celor 8 biți folosiți
pentru înscrierea valorilor numerelor din fiecare domeniu. La implementarea modelului
de reprezentare a numerelor reale domeniul de valori al caracteristicei [1, 254] se pune în
corespondență cu domeniul [-126, 127] prin aplicarea unei translații/deplasament Δ =
127. Pentru calculul caracteristicii se folosește relația:
δ = e + 127
Obs. Valoarea exponentului e = - 127 (δ =0) este folosită pentru a indica depășirea
domeniului de reprezentativitate.
● Formatul float, respectiv 4o/32biți, are următoarea semnificație a biților
reprezentării:
…….. ……

b31 b30 ….............................................. b23 b22 b21 ……………. b1 b0

MSb caracteristica mantisa normalizată

● Formatul double, respectiv 8o/64biți, are următoarea semnificație a biților
reprezentării:
…….. ……

b63 b62 …....................... b52 b51 ………………………..………… b0

MSb caracteristica mantisa normalizată

unde:
- b63 - MSb – codifică semnul numărului;
- b52 - b62 - codifică caracteristica folosind 11 biți. Deci:
e ∈ [-1022,1023]; δ = [1,2046] și Δ = 1023;
- b0 - b51 - memorează cifrele binare ale mantisei.
● Formatul long double, respectiv 10o/80biți, are următoarea semnificație a biților
reprezentării:
…….. 1 ……

b79 b78 …....................... b64 b63 b62 ………………………..……… b0

MSb caracteristica mantisa normalizată

unde:
- b79 - MSb – codifică semnul numărului;
- b64 - b78 - înscriu caracteristica folosind 15 biți.
Deci: e ∈ [-8190,8191] ; δ = [1,16382] și Δ = 8191;
- b63 = 1 - memorează prima cifră a mantisei normalizate (cifra unităților).
- b0 - b62 - memorează cifrele binare ale mantisei.
Obs. Prin setarea b63 = 1 se indică faptul că cei 64 de biți corespunzători mantisei
reprezintă forma normalizată completă. Aceasta nu este valabil pentru tipurile de date
float și double.
c. Determinarea mantisei
Numărul de cifre al mantisei corespunde părții fracționare a reprezentării formei
normalizate a numărului. Dacă este necesar se completează reprezentarea la dreapta cu
zerouri astfel încât să se obțină numărul biți corespunzători tipului ales pentru
reprezentare (float, double, long double).
Ex.6 Să se alcătuiască forma internă/externă a reprezentării numărului 170.4. (vezi
Ex.5)
(170.4)10 = (1010 1010 . 0110 0110)2 = (AA . 66) 16
Forma normalizată a reprezentării numărului este:
(170.4) = [ (1.0101 0100 1100 110 | 0) x(10)111 ] 2
● Reprezentarea pe 4o/16 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 | 1000 0110 | 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ț - 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.
➢ Reprezentarea numerelor reale negative
Forma internă/externă a unui număr real negativ se determină de la forma
internă/externă a valorii absolute a numărului (numărul pozitiv) la care se setează
MSb=1.
Ex.8 Să se alcătuiască forma externă/internă a reprezentării în MO a numărului –
170.4 considerat de tip float.
Forma internă a numărului |-170.4| este:
(0100 0011 0010 1010 0110 0110 0000 0000)→ (432A6600)
Forma internă/externă a numărului negativ este:
-170.4 → (1100 0011 0010 1010 0110 0110 0000 0000) = (C32A6600)16
Se observă că b31= l , ceea ce arată că numărul reprezentat este negativ.
Regulă practică. Forma internă/externă a unui număr negativ se obține de la
forma internă/externă a valorii absolute a numărului la care se adună:
- 0001 la prima tetradă binară semnificativă (sau cea mai din stânga) sau
- 8 la prima cifră semnificativă în baza 16.
Obs. Numărul zero reprezentat ca număr real este o valoare specială reprezentată
prin câmpurile exponentului şi al mantisei umplute cu zero. În această formă de
reprezentare există structuri diferite pentru +–0 şi -0.

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.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.
Obs. μProcesorul conține Registrul indicatorilor de condiții sau registrul F, care are
8/16 biți.
b7 b6 ...........................................................................................................................................b0
S Z * AC * P * CY

Fig.4
Sunt semnificativi pentru această prezentare:
- b0 - CARRY - prin valoarea 1 precizează producerea unui transfer spre
rangul superior, în afara locației MO (vezi ex.7.5);
- b7 – SIGN – prin valoarea (vezi ex.7.1 – 7.4)
✓ b7 = 0 precizează faptul că ultimul rezultat este un număr pozitiv;
✓ b7 = 1 precizează faptul că ultimul rezultat este un număr negativ.
- b6 – ZERO – prin valoarea:
✓ b6 = 0 precizează faptul că ultimul rezultat este un număr diferit de zero;
✓ b7 = 1 precizează faptul că ultimul rezultat este egal cu zero. Este
semnificativ pentru valorile de tip int.

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].
Înregistrarea acestui transfer este semnalizat prin setarea b0 =1 în registrul F (vezi fig.4).
Î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. 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.5.
 Fig.5
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.3.

Fig.6

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.
Obs. Pentru analiza semnului/valorii: pozitiv/negative/zero se folosesc indicatorii
de condiții( vezi fig.4).
Ex.10
1) 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, în
registrul F se poziționează b7 = 0 și b6 = 0. Corespunzător acestor cerințe:
operatorul relaţional >= ; b7 =0 ; b6 =0
se stabilește că y =ADEVARAT și se memorează y = 1.
2) Să se aleagă valori adecvate pentru variabilele x, y și să se alcătuiască
secvența de instrucțiuni care la verificarea condiției (!=) poziționează b6
=0.
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.
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.
Operanzii sunt înscriși în locații similare tipului int. Valoarea logică stabilită pentru
o expresie relațională/logică se concretizează în registrul F prin valoarea lui b6 astfel:
- b6 =0→ ADEVĂRAT/true;
- b6 =1→ FALS/false.

3.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 vă î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)

Ex.14 Pentru secvența Java următoare se cere să se verifice valoarea variabilei b

și forma internă acesteia.
.......................
boolean a=true,b;
int c=10; // c→true
b= (c<=10)&& a; // b→true
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ă:
a=true ; c=true ; b= (c<=10) && a ; b=true && true = true.
Valoarea înscrisă în locația atribuită lui b este: b=(0000 0000 0000 0001)
3.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.15. 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

5. Structura internă a unui SC şi a unui µP

Sistemul de calcul (SC) reprezintă ansamblul de echipamente (hardware)
interconectate şi programe (software) care asigură realizarea următoarelor funcţiuni:
- introducerea datelor iniţiale (de intrare);
- prelucrarea acestora în conformitate cu relaţiile de calcul;
- afişarea rezultatelor astfel obţinute.
Efectuarea tuturor acestor operaţii este determinată de interpretarea şi execuţia
instrucţiunilor programelor utilizator. Prin arhitectura unui sistem de calcul se înţelege
componenta hardware a unui calculator, adică acea parte ce se ocupă de elementele fizice
ale unui sistem de calcul (piesele dintr-un calculator). Prin upgrade se înţelege adăugarea
unor componente noi sau înlocuirea unor piese dintr-un calculator cu altele mai
performante. Această operaţie trebuie să ia în considerare întreaga arhitectură a
calculatorului, fiindcă unele piese noi nu pot funcţiona pe un sistem mai vechi din lipsă
de compatibilitate.

4.1. Componenta hardware a unui SC

În fig. 5.1 este prezentată configuraţia hardware generală a unui SC. Sunt indicate şi
principalele căi de transfer a informaţiilor (magistralele) între diferitele blocuri.
 Fig.5.1.
Elementele fizice (resursele) minimale necesare funcţionării oricărui SC sunt:
- echipamentele periferice sau dispozitivele de intrare / ieşire (I/O)
(tastatură, monitor, imprimantă, mouse, etc.) prin intermediul cărora se

poate efectua dialogul utilizator SC; Acestea sunt de două feluri:

o dispozitivele periferice de intrare (au rolul de a introduce datele

în calculator) ex. tastatura, mouse, microfon etc.
o dispozitivele periferice de ieşire (au rolul de a extrage datele în
calculator) ex. monitor, imprimantă, boxe etc.
- unitatea centrală care include principalele blocuri electronice: memorie
operativă - MO sau memoria RAM (Random Access Memmory),
 circuite de comandă şi control a funcţionării SC, plăci sau circuite
necesare interconectării blocurilor externe;
- memoria externă: hard – disk -ul (HDD) , unitatea de citire a dischetelor
(Floppy Disk Driver -FDD), unitatea de citire a CD-ROM-urilor etc;

Microprocesorul - μP

Microprocesorul (μP), numit şi creierul calculatorului are (asemenea creierului

uman) două funcţii importante:
- coordonează activitatea tuturor componentelor unui calculator
- efectuează diverse operaţii.
Microprocesorul (μP) este elementul principal al unităţii centrale (fig. 5.1) şi
constituie blocul în care se fac operaţiile de calcul şi care coordonează execuţia
programului de calcul. În fig. 5.2 este prezentată structura principală a unui μP 8086 care
utilizează 16 cb.

Fig. 5.2
unde:
 - ALU – unitatea aritmetico logică;
- IP – registrul de adresă a instrucţiunilor;
- AX – are o utilizare dublă:
o înscrierea primului operand al instrucţiunii;
o înscrierea rezultatului obţinut în urma execuţiei acesteia.
- BX ... EX – registre folosite pentru memorarea operanzilor;
- SP – vârful stivei;
- BP – baza stivei;
- FLAGS - Indicatorii de condiţii.
Notaţia [A], [BP] .... – reprezintă conţinutul registrului A, BP, ....
În principiu μP conţine blocul de calcul şi registrele. Acestea sunt elementele care
asigură memorarea temporară sau permanentă a informaţiilor necesare efectuării
operaţiilor indicate prin instrucţiunea care se execută.
Funcţiile blocurilor din fig. 5.2 sunt:
- ALU este singurul bloc dintr–un SC în care se efectuează operaţii de
calcul şi / sau comparaţie; Registrele generale AX, BX, CX, DX sunt
elementele de memorare pe 16 cb şi sunt destinate înscrierii rezultatelor
intermediare. Rezultatul final al execuţiei unei instrucţiuni de calcul este
întotdeauna transferat în MO. Aceste registre pot fi folosite şi parţial
(având dimensiunea de 8 cb):

Indicatorii de condiţii – sunt memoraţi într-un registru special de 16 cb şi descriu

modul în care a fost executată o operaţie de calcul.
De exemplu b6 este indicatorul (flag -ul) de rezultat nul. Dacă b6 = 0 are
semnificaţia unui rezultat diferit de zero, iar b6 = 1 are semnificaţia unui rezultat nul.
 IP este contorul (numărător) care memorează adresa următoarei instrucţiuni care se
va executa. Deoarece μP poate interpreta şi executa numai câte o singură instrucţiune,
este necesar să se cunoască permanent adresa locaţiei de memorie (adresa primului octet
al acesteia) în care este înscrisă următoarea instrucţiune care se va executa.
- BP (base pointer) şi SP (stack pointer) sunt registre care permit
determinarea adreselor efective ale operanzilor. Segmentul de date
folosit de fiecare modul (funcţie) a unui program C/C++ alcătuieşte o
zonă distinctă. Totalitatea zonelor de date care sunt atribuite de către SC
fiecărui modul alcătuieşte stiva de memorie.
- Conţinutul registrului BP ([BP]) este constant pentru fiecare funcţie a
programului C/C++. Definirea de noi variabile în cadrul unei funcţii are
ca efect atribuirea unei locaţii pentru memorarea valorilor care se vor
atribui respectivei variabile. Corespunzător se modifică şi conţinutul SP,
acesta reprezentând adresa ultimei variabile introduse. Prin modul de
funcţionare al compilatorului C/C++ adresele se atribuie descrescător.
Deci, pe măsură ce dimensiunea zonei variabilelor creşte, corespunzător
creşte si dimensiunea stivei iar [SP] se micşorează corespunzător.