Representació de la informació

De castillowiki
Saltar a: navegación, buscar

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ó.

Els números naturals, en llenguatges com C, es poden guardar com unsigned int, per exemple. En aquest cas, normalment utilitza 32 bits per representar de 0 a 232. El números sencers, són els integers o en cas de C, els int, que, en cas dels de 32 bits, van de -231 fins a 231-1

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+1 o de la següent manera:

                                                       Exemple 1       Exemple 2
1. Començant per la dreta trobem el primer  '1'        0101001   0101100
2. Fer un not a tots els bits de l'esquerra:           1010111         1010100

Per exemple, el -50:

  50 = 00110010 (amb 8 bits)
 -50 = 11001110
  50 = 0000000000110010
 -50 = 1111111111001110

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.

Altres en la Wikipedia

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 si 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

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:

Binari Dec Hex Representació
0010 0000 32 20 espai ( )
0010 0001 33 21 !
0010 0010 34 22 "
0010 0011 35 23 #
0010 0100 36 24 $
0010 0101 37 25 %
0010 0110 38 26 &
0010 0111 39 27 '
0010 1000 40 28 (
0010 1001 41 29 )
0010 1010 42 2A *
0010 1011 43 2B +
0010 1100 44 2C ,
0010 1101 45 2D -
0010 1110 46 2I .
0010 1111 47 2F /
0011 0000 48 30 0
0011 0001 49 31 1
0011 0010 50 32 2
0011 0011 51 33 3
0011 0100 52 34 4
0011 0101 53 35 5
0011 0110 54 36 6
0011 0111 55 37 7
0011 1000 56 38 8
0011 1001 57 39 9
0011 1010 58 3A :
0011 1011 59 3B ;
0011 1100 60 3C <
0011 1101 61 3D =
0011 1110 62 3I >
0011 1111 63 3F ?
 
Binari Dec Hex Representació
0100 0000 64 40 @
0100 0001 65 41 A
0100 0010 66 42 B
0100 0011 67 43 C
0100 0100 68 44 D
0100 0101 69 45 E
0100 0110 70 46 F
0100 0111 71 47 G
0100 1000 72 48 H
0100 1001 73 49 I
0100 1010 74 4A J
0100 1011 75 4B K
0100 1100 76 4C L
0100 1101 77 4D M
0100 1110 78 4I N
0100 1111 79 4F O
0101 0000 80 50 P
0101 0001 81 51 Q
0101 0010 82 52 R
0101 0011 83 53 S
0101 0100 84 54 T
0101 0101 85 55 U
0101 0110 86 56 V
0101 0111 87 57 W
0101 1000 88 58 X
0101 1001 89 59 Y
0101 1010 90 5A Z
0101 1011 91 5B [
0101 1100 92 5C \
0101 1101 93 5D ]
0101 1110 94 5I ^
0101 1111 95 5F _
 
Binari Dec Hex Representació
0110 0000 96 60 `
0110 0001 97 61 a
0110 0010 98 62 b
0110 0011 99 63 c
0110 0100 100 64 d
0110 0101 101 65 e
0110 0110 102 66 f
0110 0111 103 67 g
0110 1000 104 68 h
0110 1001 105 69 i
0110 1010 106 6A j
0110 1011 107 6B k
0110 1100 108 6C l
0110 1101 109 6D m
0110 1110 110 6I n
0110 1111 111 6F o
0111 0000 112 70 p
0111 0001 113 71 q
0111 0010 114 72 r
0111 0011 115 73 s
0111 0100 116 74 t
0111 0101 117 75 u
0111 0110 118 76 v
0111 0111 119 77 w
0111 1000 120 78 x
0111 1001 121 79 y
0111 1010 122 7A z
0111 1011 123 7B {
0111 1100 124 7C |
0111 1101 125 7D }
0111 1110 126 7I ~

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/

Per mostrar tots els caracters unicode es poden instal·lar fonts que els suporten com la Noto, Symbola o Unifont.

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

[1] [2]

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
$ printf "%d\n" \'€
$ ascii # man 7 ascii
$ printf "%X\n" \'€
$ echo -e "\u20AC"
$ echo -e "\xce\xb1"

Per introduir dirèctament un Unicode en Bash, podem fer ctrl+shift+u, el codi i enter