Mangiare Senza Glutine disponibile su App Store

Per altre informazioni scrivi a fabriziocaldarelli@negusweb.it

Rappresentazioni Numeriche

Da Programmazione Software.

Descrizione

Lo spazio per rappresentare le cifre che esprimono un valore sono limitate;

Questo porta a:

  • chiusura dovuta ad OVERFLOW (es. se il numero di cifre è 3, nel sistema decimale avremo valori da 0 a 999 e una somma del tipo 600+600 o un prodotto 50x50 non appartiene più all'insieme di partenza);
  • chiusura dovuta ad UNDERFLOW (3-5 = -2)
  • perdita della proprietà associativa [(700 + (400-300) != (700+400) - 300]
  • perdita della proprietà distributiva


Sistema Numerico Posizionale

E' costituito da una coppia (A,B), con B>1 in cui A sono le cifre e B è la base (>1)

Esempio:

  • B = 16 => A = { 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F }
  • B = 10 => A = { 0,1,2,3,4,5,6,7,8,9 }
  • B = 8 => A = { 0,1,2,3,4,5,6,7 }
  • B = 2 => A = { 0,1 }

A rappresenta un valore distinto compreso tra 0 .. (B-1)

Un numero è costituito da una sequenza di cifre appartenenti ad A.

Es. <math>d_{k-1}d_{k-2}..d_2d_1d_0.d_{-1}d_{-2}...d_{-p}\,</math>

dove l'indice denota la posizione e quindi il peso della cifra.

Infatti il valore di di è

<math>d_i = V(d_i) = d_i \cdot B^i</math>

Ne consegue che:

<math>V(d_{k-1}d_{k-2}..d_2d_1d_0.d_{-1}d_{-2}...d_{-p}) = \sum_{i=-p}^{k-1} d_iB^i</math>


Conversione da base 10 a base B

Vediamo prima di tutto la parte intera.

<math>(N_I)_{10} = d_{k-1}B^{k-1} + ... + d_1B + d_0\,</math>


Ne consegue che <math>d_{k-1}B^{k-1} + ... + d_1B + d_0 = B(d_{k-1}B^{k-1}+ ... + d_1) + d_0 \,</math>


Dividendo per B si ha che <math>d_0 = resto\,</math> e <math>d_{k-1}B^{k-2} + ... + d_1 = quoziente \,</math>


Ovvero: <math>d_0 = (N_I mod B)\,</math> e <math>d_{k-1}B^{k-2} + ... + d_1 = \frac{N_I}{B}</math>

int i = 0;
while (N!=0)
{
     d[i] = N % B;
     N = N/B;
     i = i + 1;
}


Vediamo ora la parte frazionaria.

<math>(N_F)_{10} = d_{-1}B^{-1} + d_{-2}B^{-2} + ... + d_{-m}B^{-m}\,</math>


A questo punto si ha che <math>d_{-1} = </math>parte intera di N_FB ( =trunc(N_FB) ) e <math>N^\prime = N_FB-d_{-1} = d_{-2}B^{-1} + ... + d_{-m}B^{-m+1}\,</math>


Si procede fino a N=0 oppure fino alla precisione voluta.

int i = 0;
while ((N!=0) && (i<=m) )
{
     d[-i] = trunc(NB);
     N = NB - d[-i];
     i = i + 1;
}


Complemento a 2

Il complemento a 2 risolve i problemi relativi alla gestione di numeri negativi nel sistema binario.

Fissato un numero k>1 di cifre binarie, il complemento a 2 su k bit di un intero N,

<math>N \in \{ -2^{k-1},...,2^{k-1}-1 \}</math>
è
<math>

C(k, N) = \begin{cases}

   N & 0 \le N\le2^{k-1}-1 \\
   2^k-\|N\| & -2^{k-1} \le  N \le -1

\end{cases}

</math>


oppure <math>C(k,N) = (N + 2^k)\mod 2^k</math>


I vantaggi del complemento a due sono:

  • Semplificazione delle operazioni aritmetiche: <math>C(x-y) = C(x) + C(-y)\,</math>
  • Semplificazione dei circuiti che eseguono le operazioni