4. A Compact Time Representation with Logarithmic Range (Rappresentazione temporale compatta con intervallo logaritmico)
4. A Compact Time Representation with Logarithmic Range (Rappresentazione temporale compatta con intervallo logaritmico)
Questo documento utilizza la rappresentazione temporale compatta descritta in "Information-Centric Networking (ICN) Adaptation to Low-Power Wireless Personal Area Networks (LoWPANs)" (adattamento delle reti centrate sulle informazioni alle reti personali wireless a bassa potenza) (vedere sezione 7 di [RFC9139]) che è stata ispirata da [RFC5497] e [IEEE.754.2019]. La sua codifica logaritmica supporta una rappresentazione che va dai millisecondi agli anni. La figura 1 illustra la natura logaritmica di questa rappresentazione temporale.
|| | | | | | | | | | |
+-----------------------------------------------------------------+
millisecondi anni
Figura 1: Una rappresentazione di intervallo logaritmico consente una maggiore precisione negli intervalli temporali più piccoli e supporta comunque grandi delta temporali.
I codici temporali (time codes) codificano i valori di esponente e mantissa in un singolo byte. A differenza della rappresentazione in [IEEE.754.2019], i codici temporali codificano solo numeri non negativi e quindi non includono un bit separato per indicare il segno dell'intero. La figura 2 mostra la configurazione di un codice temporale: una larghezza dell'esponente di 5 bit e una larghezza della mantissa di 3 bit.
<--- largo un byte --->
+----+----+----+----+----+----+----+----+
| exponent (b) | mantissa (a) |
| esponente (b) | mantissa (a) |
+----+----+----+----+----+----+----+----+
0 1 2 3 4 5 6 7
Figura 2: Un codice temporale con esponente e mantissa per codificare una rappresentazione temporale a intervallo logaritmico.
L'unità di base per i valori temporali è il secondo. Un valore temporale viene calcolato utilizzando la seguente formula (adottata da [RFC5497] e [RFC9139]), dove (a) rappresenta la mantissa, (b) l'esponente e (C) un fattore costante impostato su C := 1/32.
Subnormale (Subnormal) (b == 0): (0 + a/8) * 2 * C
Normalizzato (Normalized) (b > 0): (1 + a/8) * 2^b * C
La forma subnormale fornisce un graduale underflow tra zero e il numero normalizzato più piccolo. Otto valori temporali esistono nell'intervallo subnormale [0s,~0.0546875s] con una dimensione del passo di ~0.0078125s tra ciascun valore temporale. Questa configurazione codifica anche i seguenti numeri convenienti in secondi: [1, 2, 4, 8, 16, 32, 64, ...]. L'appendice A include vettori di test per illustrare l'intervallo logaritmico.
Un algoritmo di esempio per codificare un valore temporale nell'esponente e nella mantissa corrispondenti è fornito come pseudocodice nella figura 3. Non tutti i valori temporali possono essere rappresentati da un codice temporale. Per questi casi, viene prodotto un codice temporale che rappresenta un valore temporale più vicino e inferiore al valore temporale di input iniziale.
input: float v // valore temporale
output: int a, b // mantissa, esponente del codice temporale
(a, b) encode (v):
if (v == 0)
return (0, 0)
if (v < 2 * C) // subnormale
a = floor (v * 4 / C) // arrotonda per difetto
return (a, 0)
else // normalizzato
if (v > (1 + 7/8) * 2^31 * C) // verifica limiti
return (7, 31) // restituisci massimo
else
b = floor (log2(v / C)) // arrotonda per difetto
a = floor ((v / (2^b * C) - 1) * 8) // arrotonda per difetto
return (a, b)
Figura 3: Algoritmo in forma di pseudocodice.
Ad esempio, non esiste un codice temporale specifico per 0.063. Tuttavia, questo algoritmo mappa al codice temporale valido più vicino che è inferiore a 0.063, cioè esponente 1 e mantissa 0 (lo stesso del valore temporale 0.0625).