• NOME
• SINOSSI
• DESCRIZIONE
• Memorizzare i numeri
• Operatori numerici e conversioni numeriche
• Flavors of Perl numeric operations
• AUTHOR
• SEE ALSO
• TRADUZIONE
• Versione
• Traduttore
• Revisore

NOME

perlnumber - semantiche dei numeri ed operazioni numeriche in Perl

SINOSSI

    $n = 1234;              # intero decimale
    $n = 0b1110011;         # intero binario
    $n = 01234;             # intero ottale
    $n = 0x1234;            # intero esadecimale
    $n = 12.34e-56;         # notazione esponenziale
    $n = "-12.34e56";       # numero specificato come stringa
    $n = "1234";            # numero specificato come stringa
    $n = v49.50.51.52;      # numero specificato come stringa, che a sua
                            # volta e` specifica in termini numerici :-)

DESCRIZIONE

Questo documento descrive come il Perl gestisce i valori numerici internamente.

La funzionalita` di overloading degli operatori e` completamente ignorata in questa sede. L'overloading degli operatori consente di creare per i nomeri comportamenti definiti dall'utente, come operazioni su interi arbitrariamente larghi e su numeri in virgola mobile con precisione arbitraria, ooperazioni su numeri ``esotici'' come aritmetica modulare, aritmetica p-adica, e via dicendo. Consultate overload per maggiori dettagli.

Memorizzare i numeri

Perl puo` rappreentare internamenti i numeri in 2 modi diversi: come interi nativi, come numeri in virgola mobile nativi, e come stringhe decimali. Le stringhe decimali possono avere una parte in notazione esponenziale, come in "12.34e-56". In questo contesto, nativo indica ``un formato supportato dal compilatore C utilizzato per compilare perl''.

Il termine ``nativo'' non indica molto quando si parla di interi nativi, mentre e` significativo quando sono convolti i numeri in virgola mobile nativi. La sola implicazione del termine ``nativo'' sugli interi e` che i limiti per i veri valori interi massimi e minimi sono vicini alle potenze di 2. Invece, i numeri in virgola mobile ``nativi'' hanno una fondamentale restrizione: possono rappresentare solo quei numeri che, quando vengono convertiti in una frazione binaria, hanno una rappresentazione relativamente ``breve''. Per esempio, 0.9 non puo` essere rappresentato con un numero in virgola mobile nativo, poiche' la frazione binaria per 0.9 e` infinita:

  binary0.1110011001100...

con la sequenza 1100 che si ripete di continuo. In aggiunta a questa limitazione, l'esponente dei numeri binari e` ristretto se e` rappresentato come un numero in virgola mobile. Su un hardware normale, i valori in virgola mobile possono memorizzare valori con al massimo 53 cifre decimali, e con esponenti binari compresi tra -1024 e 1024. In una rappresentazione decimale, cio` significa piu` o meno 16 cifre decimali, ed esponenti nell'intervallo -304..304. Il risultato di tutto cio` e` che Perl non puo` memorizzare un numero come 12345678901234567 come un numero in virgola mobile su tali architetture senza che si verifichi una perdita di informazioni.

Similmente, le stringhe decimali possono rappresentare solo numeri con un'espansione decimale finita. Siccome si tratta di stringhe, e dunque di lunghezza arbitraria, non c'e` praticamente un limite per l'esponente o per il numero di cifre decimali per questi numeri. (Ma tenete conto che cio` che stiamo discutendo sono le regole per la sola memorizzazione di questi numeri. Il fatto che si possano memorizzare numeri cosi` ``larghi'' non implica che le operazioni su questi numeri useranno tutte le cifre significative di essi. Consultate Operatori numerici e conversioni numeriche per dettagli.)

In realta`, i numeri memorizzati come interi nativi possono essere memorizzati sia nella forma nativa con segno, o nella forma nativa senza segno. Dunque, i limiti del Perl per i numeri memorizzati come interi nativi sono tipicamente -2**31..2**32-1, con le opportune variazioni nel caso di interi a 64 bit. Ancora, questo non significa che Perl possa effettuare operazioni solo su interi compresi in questo intervallo: e` possibile memorizzare molti piu` interi nel formato a virgola mobile.

Riassumento, il valori numerici del Perl possono memorizzare solo i numeri che hanno un'espansione decimale finita, o un'espansione binaria ``corta''.

Operatori numerici e conversioni numeriche

Come accennato in precedente, Perl puo` memorizzare un numero in uno qualasisi dei tre formati, ma la maggior parte degli operatori solitamente capiscono solo uno di essi. Quanto un valore numerico e` passato come argomento a tali operatori, viene convertito nel formato compreso dall'operatore.

Sono possibili sei conversioni:

  intero nativo         --> virgola mobile nativo       (*)
  intero nativo         --> stringa decimale
  floating point nativo --> intero nativo               (*)
  floating point nativo --> stringa decimale            (*)
  stringa decimale      --> intero nativo
  stringa decimale      --> virgola mobile nativo       (*)

Queste conversioni sono governate dalle seguenti regole generali:

• Se il numero sorgente puo` essere rappresentato nella forma di destinazione, viene utilizzata tale forma.

• Se il numero sorgente e` fuori dai limiti rappresentabili nella forma di destinazione, viene utilizzata una rappresentazione del limite piu` vicino. (perdita di informazioni)

• Se il numero sorgente e` compreso tra due numeri rappresentabili nella forma di destinazione, viene utilizzata la rappresentazione di uno di essi. (perdita di informazioni)

• Nelle conversioni floating point nativo --> intero nativo la precisione del risultato e` minore o uguale alla precisione del sorgente. (``Arrotondamento a zero''.)

• Se la conversione stringa decimale --> intero nativo non puo` essere ottenuta senza perdita di informazioni, il risultato e` compatibile con la conversione stringa decimale -> virgola movile nativo --> intero nativo. In particolare, l'arrotondamento tende nettamente a zero, benche' sia possibile un numero come "0.99999999999999999999" venga arrotondato a 1.

RESTRIZIONE: Le conversioni sopra marcate con (*) implicano operazioni eseguite dal compilatore C. In particolare, bug e caratteristiche del compilatore usate possono portare all'infrazione di qualcuna delle regole sopra riportate.

Flavors of Perl numeric operations

Perl operations which take a numeric argument treat that argument in one of four different ways: they may force it to one of the integer/floating/ string formats, or they may behave differently depending on the format of the operand. Forcing a numeric value to a particular format does not change the number stored in the value.

All the operators which need an argument in the integer format treat the argument as in modular arithmetic, e.g., mod 2**32 on a 32-bit architecture. sprintf "%u", -1 therefore provides the same result as sprintf "%u", ~0.

Arithmetic operators

The binary operators + - * / % == != > < >= <= and the unary operators - abs and -- will attempt to convert arguments to integers. If both conversions are possible without loss of precision, and the operation can be performed without loss of precision then the integer result is used. Otherwise arguments are converted to floating point format and the floating point result is used. The caching of conversions (as described above) means that the integer conversion does not throw away fractional parts on floating point numbers.

++

++ behaves as the other operators above, except that if it is a string matching the format /^[a-zA-Z]*[0-9]*\z/ the string increment described in perlop is used.

Arithmetic operators during use integer

In scopes where use integer; is in force, nearly all the operators listed above will force their argument(s) into integer format, and return an integer result. The exceptions, abs, ++ and --, do not change their behavior with use integer;

Other mathematical operators

Operators such as **, sin and exp force arguments to floating point format.

Bitwise operators

Arguments are forced into the integer format if not strings.

Bitwise operators during use integer

forces arguments to integer format. Also shift operations internally use signed integers rather than the default unsigned.

Operators which expect an integer

force the argument into the integer format. This is applicable to the third and fourth arguments of sysread, for example.

Operators which expect a string

force the argument into the string format. For example, this is applicable to printf "%s", $value.

Though forcing an argument into a particular form does not change the stored number, Perl remembers the result of such conversions. In particular, though the first such conversion may be time-consuming, repeated operations will not need to redo the conversion.

AUTHOR

Ilya Zakharevich ilya@math.ohio-state.edu

Editorial adjustments by Gurusamy Sarathy <gsar@ActiveState.com>

Updates for 5.8.0 by Nicholas Clark <nick@ccl4.org>

SEE ALSO

overload, perlop

TRADUZIONE

Versione

La versione su cui si basa questa traduzione è ottenibile con:

   perl -MPOD2::IT -e print_pod perlnumber

Per maggiori informazioni sul progetto di traduzione in italiano si veda http://pod2it.sourceforge.net/ .

Traduttore

Traduzione a cura di Michele Beltrame.

Revisore

Revisione a cura di Michele Beltrame.