Diferencia entre revisiones de «Representació de la informació»
Línea 434: | Línea 434: | ||
El signe és '''1''', la mantisa és '''1101101010000000000000000000000000000000000000000000''' (52 bits) | El signe és '''1''', la mantisa és '''1101101010000000000000000000000000000000000000000000''' (52 bits) | ||
L'exponent | L'exponent sí canvia, perquè l'excés és a 1023. Per tant, '''1023+6 = 1029 = 10000000101''' | ||
El resultat final: | El resultat final: | ||
Línea 444: | Línea 444: | ||
63 62 52 51 0 <-- índex del bit (0 a la dreta) | 63 62 52 51 0 <-- índex del bit (0 a la dreta) | ||
desplaçat +1023 | desplaçat +1023 | ||
</pre> | |||
Anem a fer un exemple de coma flotant doble en hexadecimal a decimal: | |||
Tenim aquest número: '''0x0xC2A8666666666666''' que està en coma flotant doble. | |||
Si el passem a binari i separem el signe i l'exponent: | |||
<pre style="font-family:monospace"> | |||
1 11 52 <-- tamany en bits | |||
+-+--------------+------------------------------------------------------+ | |||
|1| 10000101010 | 1000011001100110011001100110011001100110011001100110 | | |||
+-+--------------+------------------------------------------------------+ | |||
63 62 52 51 0 <-- índex del bit (0 a la dreta) | |||
</pre> | </pre> | ||
Revisión del 09:15 22 jun 2021
Els sistemes informàtics manegen informació. Ja sigui com a entrada, com a procés o com a sortida. Hi ha dos tipus de sistema en funció del tractament que facin de la informació: Els sistemes de flux d'informació en què la informació d'entrada i sortida és la mateixa i els sistemes de tractament de la informació, on la informació és tractada i ofereixen una informació de sortida diferent a la d'entrada. La informació en un sistema informàtic ha d'estar representada per uns símbols que el sistema pugui emmagatzemar o processar. La informació està composta de dades, aquestes dades poden classificar com:
- Dades Numèrics.
- Dades alfabètics.
- Dades alfanumèrics.
- Dades Binaris.
Perquè puga ser emmagatzemada o processada la informació, cal una correspondència entre els símbols i els que utilitza l'ordinador. Això es diu codificació i el contrari descodificació. Per als caràcters alfanumèrics podem utilitzar codificacions com l'ASCII, UNICODE o el EDBCDIC i per als números, codificacions basades en el sistema de numeració binari.
Representació de números naturals
El sistema binari és el que utilitzen els ordinadors des dels seus començaments. La raó d' usar és perquè els ordinadors utilitzaven interruptors que podien estar encesos 1 o apagats 0. Amb aquests dos símbols es representa tota la informació que poden emmagatzemar i processar els ordinadors.
Sistema binari vol dir que està en base 2, és a dir, que utilitza els símbols 0 i 1 per representar els nombres.
Com que és un sistema posicional, el valor d'un un símbol depèn de la seva posició. Per que per passar de binari a decimal cal multiplicar el dígit per 2 elevat a la seva posició. Per exemple el número 1101 és igual a 1 * 2 ^ 3 + 1 * 2 ^ 2 + 0 * 2 ^ 1 + 1 * 2 ^ 1 = 13 Per passar de decimal a Binari (o qualsevol base) cal dividir el nombre entre 2 i el resultat de nou entre dos fins que el resultat sigui inferior a 2 i quedar-se amb el resultat i les restes de dreta a esquerra.
Per exemple el número 13 en base 10 els dividim entre 2 i tenim de resta 1 i de quocient 6 que dividit entre dos dóna de resta 0 i de quocient 3 que dividit entre dos dóna de resta 1 i de quocient 1 pel que el nombre resultant en base 2 és 1101.
13 |_2_ 1 6|_2_ 0 3|_2_ 1 1 <-- 1101
Si hi ha decimals, per passar de binari a decimal cal multiplicar el símbol per 2 elevat a la seva posició negativa i sumar. I per passar de decimal a binari cal separar els enters dels fraccionaris, els sencers es fan com sempre i els fraccionaris es multipliquen successivament per 2 i agafant la part sencera:
0,35 * 2 = 0,70 -----------------0 0,70 * 2 = 1,40 -----------------1 0,40 * 2 = 0,80 -----------------0 0,80 * 2 = 1,60 -----------------1 0,60 * 2 = 1,20 -----------------1 Així que 0,35 = 0,01011
Com veiem, un nombre decimal amb xifres decimals finites pot esdevenir un nombre binari amb decimals infinits. Això pot produir alguns problemes amb els arrodoniments en càlculs fets amb ordinador.
Aquesta forma de passar de decimal a binari i de binari a decimal és extrapolable a totes les bases. Normalment per passar d'una base diferent de 10 a altres distintes a 10 és necessari passar-la a base 10 i després a l'altra base. Però més endavant veurem que existeixen mètodes més senzills per a determinades bases.
Octal
El sistema octal és un sistema en base 8, de manera que els símbols que utilitza són:
0,1,2,3,4,5,6,7
Mentre que el mètode per passar del sistema octal al decimal és el mateix que el binari, el mètode per passar a binari és bastant més senzill.
Com que 8 és potència de 2, per passar de octal a binari només cal substituir cada xifra pel seu equivalent en binari amb 3 dígits.
Per exemple:
234 base 8 és igual a 010.011.100 = 10.011.100 en binari Per passar de binari a octal només cal agrupar en grups de 3 xifres el nombre a binari començant per la dreta i substituir-lo per el seu valor en octal:
1100110101101 -> 001 100 110 101 101 = 14655 en octal
Si falten xifres es substitueixen per zeros a l'esquerra. En cas que tingui decimals es utilitzar el mateix sistema sense problemes, però els zeros s'afegeixen a la dreta en el cas que faltin.
Hexadecimal
El sistema Hexadecimal és a base 16, els símbols que fa servir són:
0,1,2,3,4,5,6,7,8,9, A, B, C, D, E, F
El hexadecimal és un sistema molt utilitzat per representar nombre binaris sense haver de escriure tants nombres. I ja que és potència de 2 com el octal, el pas de Hexadecimal a Binari és igual de senzill. En aquest cas els grups són de 4 xifres.
En Unix i C, els números en hexadecimal es representen amb el prefix 0x
Operacions en binari
Com que els ordinadors treballen amb binari cal esmentar les operacions que es poden fer sobre nombres binaris, les lògiques i les aritmètiques. Hi ha 4 operacions lògiques que es poden realitzar amb nombres binaris: AND, OR, NOT, XOR. Aquestes operacions es realitzen bit a bit.
- L'operació AND té resultat 1 només si els dos operands tenen com valor 1
- L'operació OR té resultat 0 només si els dos operands tenen com valor 0
- L'operació XOR té resultat 1 si els dos operands són distintintos un de l'altre.
- L'operació NOT inverteix el bit, si val 1 és 0 i si val 0 és 1
Per sumar en binari és igual que en decimal, si els sumands donen més que 1 "Portem", això es diu arrossegament o carry.
Per restar és igual que en el sistema decimal, en el cas de 0 -1 el que fem és prendre una unitat prestada de la posició següent que serà retornada sumada. Per exemple:
1110101 - 11001 ----------- 1011100
El producte és molt senzill en binari perquè el 0 multiplicat per qualsevol és 0 i el 1 és el neutre de la multiplicació. El mètode és el mateix que en decimal.
La divisió es realitza de la mateixa manera que en decimal, cal dir que les restes en la divisió es fan en binari.
Representació de números sencers
Els números naturals són molt fàcils de representar. Inclús, en paper, és molt fàcil dir que -101 = -5. No obstant, en un computador, no existeix el signe + o -. La primera solució que podem pensar és utilitzar un bit per a dir si és positiu o negatiu. Això dona problemes, com explicarem a continuació.
Signe Magnitud
És la manera més sencilla de representar els negatius. Un número amb signe magnitud té el bit més significatiu com a signe.
3 = 00000011 -3 = 10000011
El signe magnitud té alguns problemes:
- Té dos representacions per al 0 (per exemple, en 8 bits 00000000 i 10000000)
- És complicat fer circuits per a les operacions matemàtiques entre aquest números.
- Al tindre un bit de signe, els màxims números en valor absolut que es poden representar queden reduïts a la meitat. (per exemple, en 16 bits de -(215-1) a 215-1) Encara que aquest problema està en tots els demés sistemes.
Complement a 1 i a 2
Complement a 1 és el mateix que complement a la base menys 1. Es tracta de fer un not bit a bit del número positiu. Un número en complement a 1 té:
- Un bit de signe 1 per a negatiu i 0 per a positiu.
- n-1 bits per al número amb els bits invertits si és negatiu.
Per exemple, el número -50:
50 = 00110010 (amb 8 bits) -50 = 11001101 50 = 0000000000110010 -50 = 1111111111001101
Observem que:
255-50=205= 11001101 65535-50 = 65485 = 1111111111001101
Per tant, també es pot calcular com el máxim número que es pot representar en els bits menys el que volem fer negatiu.
Els avantatges del complementa a 1:
- Té un rang simètric.
- Permet operar aritmèticament, encara que és un poc més complicat que el Ca2.
Desavantatges:
- Té doble representació del 0. (Per exemple:00000000 i 11111111, en 8 bits)
El Complement a 2, és el complement a 1 més 1. Es pot calcular com el Ca1 més 1.
Per exemple, el -50:
50 = 00110010 (amb 8 bits) -50 = 11001110 50 = 0000000000110010 -50 = 1111111111001110
Per a saber quin número està representat en Co2 cal restar 1 i invertir els bits:
11110000 (número en Co2) 11101111 (restem 1) 00010000 (Invertim els bits) -16
Els avantatges del complementa a 2:
- Facilitat per fer restes: una resta és igual a una suma del complement a 2.
- No té doble representació del 0
Desavantatges:
- Rang asimètric.
El complement a 2 és l'elegit per representar els números en els processadors MIPS o x86, per exemple.
Excés a 2n-1-1
Una última manera és en excés a K, de manera que no cal representar números negatius, perquè se li suma un excés i el rang va de 0 a 2n.
K pot ser el que siga, però normalment és 2n-1 o 2n-1-1. Aquest últim respeta l'estandar IEEE-754 i és el que anem a estudiar.
Per exemple, el -50:
50 = 00110010 + 28-1-1 = 177 = 10110001 (amb 8 bits) -50 = -00110010 + 28-1-1 = 77 = 01001101 50 = 0000000000110010 + 216-1-1 = 32817 = 1000000000110001 (amb 16 bits) -50 = -0000000000110010 + 216-1-1 = 32717 = 0111111111001101
Desavantages:
- Necessita operacions aritmètiques per l'obtenció.
- Té rang asimètric.
Avantages:
- El menor número es tot 0 i el major tot 1, com en els números sense signe.
- Perment operacions aritmètiques si tens en compte l'excés.
- Tots els bits formen part del número, no hi ha bit de signe.
L'excés s'utilitza en l'exponent de la coma flotant o en alguns processos de digitalització.
BCD
Serveix per codificar nombres decimals a binari (Binary Coded Decimal) S'utilitzen quatre bits per a cada xifra en decimal del nombre. Per exemple:
1982 = 0001 1001 1000 0010
Hi ha diversos tipus de BCD:
- Natural: En el qual cada xifra correspon amb el seu codi en binari.
- Aiken: En el qual cada xifra és el complement a 9 de la seva simètrica. Això fa que les operacions de resta i divisió es puadan fer amb més facilitat.
- Excés a 3: S'obté sumant 3 a la xifra en binari també és complement a 9 del seu simètric.
Si Volem representar el signe podem utilitzar el BCD empaquetat ficant al final 1100 per al + o 1101 per al -
Rangs i el 0
Els diferents sistemes de representació de sencers donen uns rangs distints. Els que tenen dos 0 són simètrics i els que no, poden representar un número més en positiu o negatiu.
En el cas del signe magnitut, el rang és simètric, però té dos 0
Màxim | Cero | Mínim | |
---|---|---|---|
8 Bits | 01111111 = 127 | 00000000 11111111 |
11111111 = -127 |
16 bits | 0111111111111111 = 32767 | 0000000000000000 1111111111111111 |
1111111111111111 = -32767 |
Per a l'excés, el rang és asimètric. En el cas d'excés 2n-1-1 és:
Màxim | Cero | Mínim | |
---|---|---|---|
8 Bits | 11111111 = 128 | 01111111 | 00000000 = -127 |
16 bits | 1111111111111111 = 32768 | 0111111111111111 | 0000000000000000 = -32767 |
El complement a 1 te dos 0:
Màxim | Cero | Mínim | |
---|---|---|---|
8 Bits | 01111111 = 127 | 00000000 11111111 |
10000000 = -127 |
16 bits | 0111111111111111 = 32767 | 0000000000000000 1111111111111111 |
1000000000000000 = -32767 |
I per últim, el Complement a 2:
Màxim | Cero | Mínim | |
---|---|---|---|
8 Bits | 01111111 = 127 | 00000000 | 10000000 = -128 |
16 bits | 0111111111111111 = 32767 | 0000000000000000 | 1000000000000000 = -32768 |
En el cas del complement a 2, el 0, al passarse a negatiu es queda igual, i per tant, el 11111111 de 8 bits representa el -1. El 128 al passar-lo a negatiu es queda igual, però com queda a 1 el bit de signe es considera negatiu.
Representació de números reals
Per representar reals s'usa el sistema de coma flotant. Aquest sistema permet representar nombres amb decimals i nombres molt grans i molt petits. les operacions amb nombres en coma flotant són més complexes i per a elles hi ha circuits específics anomenats coprocessadors matemàtics.
Un número R es representa de la següent manera:
R = M x B ^ E
On:
- M és la mantissa, té signe i sol ser un nombre fraccionari
- B és la base de l'exponent que sol ser 2
- I és l'exponent.
El sistema és igual a la notació científica normalitzada en què la mantissa no té part sencera i la primera xifra després de la coma és diferent de 0. En la memòria de l'ordinador aquest és l'ordre dels camps:
Signe | Exponent | Mantisa |
Segons l'estàndar IEE 754, amb 32 bits (precisió simple) per al signe s'usa 1 bit, 8 pel exponent i 23 per a la mantissa.
En 64 bits (precisió doble) s'usa 1 per al signe, 11 per l'exponent i 52 per a la mantissa.
Ja que el primer bit de la mantissa sempre seria 1, aquest es pot obviar usant la técnica del bit implícit.
L'exponent està en excés 127 per 32 bits i 1023 per a 64 bits.
Hi ha desbordament si:
- El nombre en valor absolut és tan gran que no pot ser representat. overflow
- El nombre en valor absolut és tan a prop del zero que que no es pot representar.
Underflow.
Precisió simple 32-bits
1 8 23 <-- tamany en bits +-+--------+-----------------------+ |S| Exp | Mantisa | +-+--------+-----------------------+ 31 30 23 22 0 <-- índex del bit (0 a la dreta) desplaçat +127
on S és el bit de signe i Exp és el camp exponent. (Per al signe: 0 = Positiu; 1 = Negatiu).
El exponent és desplaçat en l'un nombre en precisió simple, un exponent en el rang -126 a +127 és desplaçat mitjançant la suma de 127 per obtenir un valor en el rang 1 a 254 (0 i 255 tenen valors especials per al 0 infinit o números imaginaris). Quan s'interpreta el valor en coma flotant, el nombre és desplaçat de nou per obtenir l'exponent real.
El conjunt de valors possibles poden ser dividits en els següents:
- zeros
- Nombres normalitzats
- Nombres desnormalizados
- infinits
- NaN (¬ I, no és un nombre, com per exemple, l'arrel quadrada d'un nombre negatiu)
Un número no normalitzat té com a mínim exponent -126 si està a 0 el exponent.
Exemple:
Tenim el número: -118,625
El signe serà 1 perquè és negatiu.
Representem el número sense signe: 1110110,101 En binari.
El desplacem la coma 6 posicions per a deixar sols un 1 com a part sencera: 1110110,101=1,110110101·26
La mantisa és la part que queda en decimal omplint de 0 fins als 23 bits de la mateixa. (11011010100000000000000).
L'exponent és 6, el pasem a binari i li sumem 127 per a representarlo. 133=10000101
Resultat:
1 8 23 <-- tamany en bits +-+--------+-----------------------+ |S| Exp | Mantisa | |1|10000101|11011010100000000000000| +-+--------+-----------------------+ 31 30 23 22 0 <-- índex del bit (0 a la dreta) desplaçat +127
Precisió doble 64-bits
1 11 52 <-- tamany en bits +-+--------+-----------------------+ |S| Exp | Mantisa | +-+--------+-----------------------+ 63 62 52 51 0 <-- índex del bit (0 a la dreta) desplaçat +1023
Anem a representar el mateix número -118,625
El signe és 1, la mantisa és 1101101010000000000000000000000000000000000000000000 (52 bits)
L'exponent sí canvia, perquè l'excés és a 1023. Per tant, 1023+6 = 1029 = 10000000101
El resultat final:
1 11 52 <-- tamany en bits +-+--------------+------------------------------------------------------+ |1| 100000000101 | 1101101010000000000000000000000000000000000000000000 | +-+--------------+------------------------------------------------------+ 63 62 52 51 0 <-- índex del bit (0 a la dreta) desplaçat +1023
Anem a fer un exemple de coma flotant doble en hexadecimal a decimal:
Tenim aquest número: 0x0xC2A8666666666666 que està en coma flotant doble.
Si el passem a binari i separem el signe i l'exponent:
1 11 52 <-- tamany en bits +-+--------------+------------------------------------------------------+ |1| 10000101010 | 1000011001100110011001100110011001100110011001100110 | +-+--------------+------------------------------------------------------+ 63 62 52 51 0 <-- índex del bit (0 a la dreta)
La precisió
L'explicació més comuna per a la coma flotant parla d'un exponent i una mantissa i la relaciona en la notació científica. El problema és que la notació científica en paper pot tindre els decimals que vulgam, però en la mantissa sols té 23 o 52 bits. Amés, si el número és gran, molts bits de la mantissa representen la part sencera i no la decimal.
L'altra manera d'entendre cóm funciona la coma flotant és pensant que l'exponent representa una interval entre dos potències de 2 consecutives i la mantissa és el desplaçament dins d'aquest interval.
1 8 23 <-- tamany en bits +-+--------+-----------------------+ |S|Interval| Desplaçament | |1|10000101|11011010100000000000000| +-+--------+-----------------------+ 31 30 23 22 0 <-- índex del bit (0 a la dreta)
L'Interval entre dues potències consecutives de 2 pot ser de [2-127,2-126] ... [0.5,1],[1,2],[2,4],[4,8] ... [2127,2128]. Com es pot veure, l'interval es multiplica per 2 cada vegada.
Metre que l'interval es multiplica per 2 quant augmenta l'exponent en 1, el desplaçament sempre es divideix en 223 = 8388608 parts.
En aquest exemple, l'exponent és 6, per tant, el número va de 26 a 27, és a dir [64,128]. Si dividim aquest interval en 8388608 parts, cada part és de 26/223 = 2-17 = 0.00000762939453125. El que vol dir que aquesta és la distància entre tots els números que es poden representar en coma flotant simple en el exponent de 6. Qualsevol número que tinga més decimals que fins el 7 no es representa exacte. Si multipliquem el deplaçament (mantissa) per aquest interval en queda el desplaçament que s'ha d'aplicar a 64. El desplaçament en decimal és 7159808. El càlcul és el següent:
0.00000762939453125 x 7159808 = 54.625. 64+54.625=118,625
La part interessant d'aquesta explicació és que ens donem compte que la precisió és la meitat en cada exponent superior, ja que l'interval és el doble.
Quant un número en coma flotant té la mantissa (desplaçament) tot a 1, el següent número té un exponent més i la mantissa tot a 0 i aquest té la meitat de precisió.
Observem l'exemple de l'exponent 2 que provoca un interval de [4,8] i cóm el número 6.1, que està em mig, té un desplaçament de 2.1 respecte a la base de l'interval.
+-+--------+-----------------------+ |S| Exp | Mantisa | +-+--------+-----------------------+ | | | | | \______ \________ \ |·········|······| |----|--------|---------|------| 1 2 4 6.1 8
- http://stackoverflow.com/questions/6874357/why-0-1-0-2-0-3-in-d
- http://puntoflotante.org/
- http://fabiensanglard.net/floating_point_visually_explained/
Representació de Caracters
Els codis alfanumèrics serveixen per emmagatzemar caràcters en format binari. Tenen les següents característiques:
- Un conjunt de caràcters que solen ser la xifres decimals, les lletres del alfabet en majúscules i minúscules, els signes de puntuació, caràcters especials i caràcters de control.
- Una longitud del codi binari que és el nombre de bits usats per codificar un caràcter
- Un màxim de caràcters determinat pel codi binari. La longitud del codi binari ha anat augmentant. En principi eren 6 bits, el que limitava el conjuto de caràcters a 64. Més tard es van usar 7 bits en codis com el ASCII (American Estàndard Code for Information Interchange) en l'actualitat s'usen codis de 8 bits com l'ASCII estès que pot representar 256 caràcters.
Existeixen taules diferents de caràcters segons l'idioma que s'usi. Però si és necessari utilitzar diversos idiomes s'han d'usar codis de doble byte com l'estàndard UNICODE que permet 65536 símbols diferents.
ASCII
ASCII (de l'anglès American Standard Code for Information Interchange) és un Codi Estàndard Americà per a l'Intercanvi d'Informació. L'ASCII és un joc de caràcters que assigna valors numèrics (del 0 al 127, 7 bits de longitud) a les lletres, xifres i signes de puntuació. Existeixen codis ASCII extensos de 256 caràcters (del 0 al 255, un byte), que permeten representar caràcters no anglesos com poden ser accents o la «ç». Els caràcters de la part superior (127 a 255), varien d'un estàndard tècnic a un altre, encara que el més utilitzat és el ISO Latin-1 o ISO-8859-1.
El codi ASCII utilitza 7 bits per representar els caràcters, encara que inicialment emprava un bit addicional (bit de paritat) que s'usava per detectar errors en la transmissió. Sovint es diu incorrectament ASCII a uns altres codis de caràcters de 8 bits, com l'estàndard ISO-8859-1 que és una extensió que utilitza 8 bits per proporcionar caràcters addicionals usats en idiomes diferents a l'anglès, com el català.
ASCII va ser publicat com a estàndard per primera vegada en 1967 i va ser actualitzat per última vegada en 1986. En l'actualitat defineix codis per 33 caràcters no imprimibles, dels quals la majoria són caràcters de control obsolets que tenen efecte sobre com es processa el text, més altres 95 caràcters imprimibles que els segueixen en la numeració (començant pel caràcter espai).
Gairebé tots els sistemes informàtics actuals utilitzen el codi ASCII o una extensió compatible per representar textos i per al control de dispositius que manegen text.
Del 0 al 31 i el 127 són caràcters de control, la majoría obsolets, utilitzats per a controla impressores.
Els carácters imprimibles són:
|
|
|
Podem observar que els 4 bits meny significatius del números són la seua representació en BCD o que de una majúscula a la seua minúscula sols canvia un bit.
EBCDIC
Utilitza 8 bits, els 4 primers es diuen de zona i els 4 segons de posició.
Els dos primers bits poden tenir aquests valors:
- 11 per majúscules i números
- 10 per minúscules
- 01 per caràcters especials
- 00 per informació de control.
Els dos següents:
- 00 de A a I
- 01 de J a R
- 10 S a Z
- 11 per als números
Les majúscules:
A - 1 1 0 0 0 0 0 1
B - 1 1 0 0 0 0 1 0
C - 1 1 0 0 0 0 1 1
D - 1 1 0 0 0 1 0 0
E - 1 1 0 0 0 1 0 1
F - 1 1 0 0 0 1 1 0
G - 1 1 0 0 0 1 1 1
H - 1 1 0 0 1 0 0 0
I - 1 1 0 0 1 0 0 1
J - 1 1 0 1 0 0 0 1
K - 1 1 0 1 0 0 1 0
L - 1 1 0 1 0 0 1 1
M - 1 1 0 1 0 1 0 0
N - 1 1 0 1 0 1 0 1
O - 1 1 0 1 0 1 1 0
P - 1 1 0 1 0 1 1 1
Q - 1 1 0 1 1 0 0 0
R - 1 1 0 1 1 0 0 1
S - 1 1 1 0 0 0 1 0
T - 1 1 1 0 0 0 1 1
U - 1 1 1 0 0 1 0 0
V - 1 1 1 0 0 1 0 1
W - 1 1 1 0 0 1 1 0
X - 1 1 1 0 0 1 1 1
I - 1 1 1 0 1 0 0 0
Z - 1 1 1 0 1 0 0 1
La lletra Ñ es representa 0 1 1 0 1 0 0 1
Els dígits del zero (0) al nou (9): s'identifiquen amb un 1 en les primeres quatre posicions (és a dir, 1111) i en les restants quatre posicions el dígit en binari.
0 - 1 1 1 1 0 0 0 0
1 - 1 1 1 1 0 0 0 1
2 - 1 1 1 1 0 0 1 0
3 - 1 1 1 1 0 0 1 1
4 - 1 1 1 1 0 1 0 0
5 - 1 1 1 1 0 1 0 1
6 - 1 1 1 1 0 1 1 0
7 - 1 1 1 1 0 1 1 1
8 - 1 1 1 1 1 0 0 0
9 - 1 1 1 1 1 0 0 1
UNICODE
L' Unicode és un estàndard de codificació de caràcters dissenyat per facilitar el tractament informàtic, transmissió i visualització de textos de múltiples llenguatges i disciplines tècniques a part de textos clàssics de llengües mortes. El terme Unicode prové dels tres objectius perseguits: universalitat, uniformitat i unicitat.
Unicode especifica un nom i identificador numèric únic per a cada caràcter o símbol, el code point o punt de codi, a més d'altres informacions necessàries per al seu ús correcte: direccionalitat, capitalització i altres atributs. Unicode tracta els caràcters alfabètics, ideogràfics i símbols de forma equivalent, el que significa que es poden barrejar en un mateix text sense la introducció de marques o caràcters de control.
Els punts de codi d'Unicode s'identifiquen per un nombre enter. Segons la seva arquitectura, un ordinador utilitzarà unitats de 8, 16 o 32 bits per representar aquests sencers. Les formes de codificació d'Unicode reglamenten la manera com els punts de codi es transformaran en unitats tractables per l'ordinador.
Unicode defineix tres formes de codificació sota el nom UTF o Format de Transformació Unicode (Unicode Transformation Format):
UTF-8 - codificació orientada a byte amb símbols de longitud variable. UTF-16 - codificació de 16 bits de longitud variable optimitzada per a la representació del mapa bàsic multilingüe (BMP). UTF-32 - codificació de 32 bits de longitud fixa, i la més senzilla de les tres.
Les formes de codificació es limiten a descriure la manera com es representen els punts de codi en format intel·ligible per la màquina.
UTF-8:
Les seves característiques principals són:
- És capaç de representar qualsevol caràcter Unicode.
- Utilitza símbols de longitud variable (d'1 a 6 bytes per caràcter Unicode).
- Inclou l'especificació US-ASCII de 7 bits, per la qual cosa qualsevol missatge ASCII es representa sense canvis.
- Inclou sincronia. És possible determinar l'inici de cada símbol sense reiniciar la lectura des del principi de la comunicació.
- No superposició. Els conjunts de valors que pot prendre cada byte d'un caràcter multibyte, són disjunts, de manera que no és possible confondre'ls entre si.
Codificació UTF-8
Bits of code point |
First code point |
Last code point |
Bytes in sequence |
Byte 1 | Byte 2 | Byte 3 | Byte 4 | Byte 5 | Byte 6 |
---|---|---|---|---|---|---|---|---|---|
7 | U+0000 | U+007F | 1 | 0xxxxxxx
| |||||
11 | U+0080 | U+07FF | 2 | 110xxxxx |
10xxxxxx
| ||||
16 | U+0800 | U+FFFF | 3 | 1110xxxx |
10xxxxxx |
10xxxxxx
| |||
21 | U+10000 | U+1FFFFF | 4 | 11110xxx |
10xxxxxx |
10xxxxxx |
10xxxxxx
| ||
26 | U+200000 | U+3FFFFFF | 5 | 111110xx |
10xxxxxx |
10xxxxxx |
10xxxxxx |
10xxxxxx
| |
31 | U+4000000 | U+7FFFFFFF | 6 | 1111110x |
10xxxxxx |
10xxxxxx |
10xxxxxx |
10xxxxxx |
10xxxxxx
|
Observem que el primer byte indica la longitud del caràcter amb la quantitat de 1.
Exemple:
Considerem el caràcter ç que és el Unicode U+00E7. Necessita 2 bytes. Per tant, davant ha de tindre 110.
0xE7 = 1110 0111
11000011 10100111 = 0xC3A7
https://www.cl.cam.ac.uk/~mgk25/ucs/utf-8-history.txt
http://reedbeta.com/blog/programmers-intro-to-unicode/
Ferramentes útils de terminal
En Internet hi ha molts conversors de base, també podem utilitzar la calculadora del sistema si té binari en alguns casos. Però no tots funcionen correctament o estan llimitats. Linux ofereix moltes ferramentes de terminal que poden ser útils per fer conversions.
Números naturals
De decimal a binari:
$ echo "obase=2;13" | bc $ printf "%x\n" 13 # hexadecimal
De binari a decimal:
$ echo "ibase=2;10101010" | bc $ echo $((2#100110)) $ echo $((06777)) #octal
Números sencers
Amb signe:
$ echo "obase=2;-13" | bc $ echo "ibase=2;-10101010" | bc
Signe magnitut:
# Per a 8 bits: $ printf "%08d\n" $(echo "obase=2;-13" | bc) | tr "-" "1" $ echo -$(( $(echo 'ibase=2;10001101' | bc) & 0x7F ))
Complement a 1:
$ echo "obase=2;(2^8-1)-13" | bc $ echo 1$(echo "obase=2;$((~13 & 0x7fffffffffffffff))" | bc) $ echo 11110010 | tr "01" "10" $ echo "ibase=2;-$(echo 11110010 | tr "01" "10")" | bc
Complement a 2:
$ echo "obase=2;(2^8)-13" | bc $ echo 1$(echo "obase=2;$((-13 & 0x7fffffffffffffff))" | bc) $ echo "ibase=2;-$(echo 11110011 | tr "01" "10")-1" | bc $ echo $((0xF000000000000002))
Excés a K:
$ echo "obase=2;-13+2^(8-1)-1" | bc $ echo "obase=2;13+2^(8-1)-1" | bc $ printf "%08d\n" $(echo "obase=2;-13+2^(8-1)-1" | bc) $ echo "ibase=2;01110010-01111111" | bc
Coma flotant Bash no sap treballar amb números amb decimals. El comando bc treballa amb decimals, però no en coma flotant. Per tant, cal fer un programa en un llenguatge de programació que els compile. Es pot fer un programa, però si volem que siga sols amb un comandament de terminal, podem utilitzar el comandament gdb per a compilar al vol un fragment de C:
$ LC_NUMERIC=C gdb --batch -ex 'print/x (float *) ( (float) 1234.5 )' $ gdb --batch -ex "print/f (float *) 0x449a5224"
En python:
$ python -c 'import struct; print "%#x" % struct.unpack("I", struct.pack("f", 1234.567))' $ python -c 'import struct; print "%#x" % struct.unpack("Q", struct.pack("d", 1234.567))'
Un altre comandament pot ser od que té una opció -f per a interpretar bytes en coma flotant. Però abans cal enviar-li els bytes de manera correcta. També cal especificar que vols el resultat com si fora big endian.
$ echo -en $(echo -n "45800000" | sed 's/../\\x&/g') | od --endian=big -f
Si volem utilitzar la terminal per facilitar els cálculs per convertir a coma flotant, es poden seguir estos pasos:
Per al número -0.025 Primer anem a convertir-lo en binari. La part sencera és 0, podem usar el comandament bc, sols que la part decimal la representarem com una fracció: $ bc -l <<< "obase=2; 0+25/1000" .0000011001100110011001100110011001100110011001100110011001100110011 Observem que el 0+ es pot substituir per la part sencera i el 25/1000= 0,025 El exponen ha de ser, per tant, -6 $ bc -l <<< "obase=2; -6+127" 1111001 Inclús es pot calcular la mantisa: $ bc -l <<< "obase=2; 0+25/1000" | tr -d "." | sed -r -e 's/^0*1//' | cut -c-23
ASCII i UNICODE
En principi, bash funciona en UTF-8. Per tant, si volem saber la codificació UTF-8 d'una cadena:
$ echo "Hola € ç" | xxd # De caracters utf-8 a bits $ printf "%d\n" \'€ # de caracters utf-8 a unicode en decimal $ ascii # man 7 ascii $ printf "%X\n" \'€ # de caracters utf-8 a unicode en Hexadecimal $ echo -e "\u20AC" # de unicode a caracter utf-8 $ echo -e "\xce\xb1" # bits a caracer utf-8
Per introduir dirèctament un Unicode en Bash, podem fer ctrl+shift+u, el codi i enter