Sono confuso sul perché ci preoccupiamo di diverse rappresentazioni per zero positivo e negativo.

Ricordo vagamente la lettura di affermazioni secondo cui avere una rappresentazione zero negativa è estremamente importante nella programmazione che coinvolge numeri complessi. Non ho mai avuto l'opportunità di scrivere codice con numeri complessi, quindi sono un po 'confuso sul perché questo sarebbe il caso.

L'articolo di Wikipedia sul concetto non è particolarmente utile; fa solo vaghe affermazioni sullo zero con segno rendendo più semplici alcune operazioni matematiche in virgola mobile, se capisco correttamente. Questa risposta elenca un paio di funzioni che si comportano diversamente e forse si potrebbe dedurre dagli esempi se si ha familiarità con il modo in cui potrebbero essere utilizzate. (Anche se, l'esempio particolare delle complesse radici quadrate sembra completamente sbagliato, poiché i due numeri sono matematicamente equivalenti, a meno che non abbia un equivoco). Ma non sono stato in grado di trovare una chiara dichiarazione del tipo di problema che potresti incontrare se non ci fosse. Le maggiori risorse matematiche che sono riuscito a trovare affermano che non esiste alcuna distinzione tra i due da una prospettiva matematica e l'articolo di Wikipedia sembra suggerire che ciò sia visto raramente al di fuori dell'informatica oltre a descrivere i limiti.

Quindi, perché uno zero negativo è prezioso nell'informatica? Sono sicuro che mi sto perdendo qualcosa.

È necessario tenere presente che nell'aritmetica FPU, 0 non deve necessariamente significare esattamente zero, ma anche un valore troppo piccolo per essere rappresentato utilizzando un dato tipo di dati, ad es.

a = -1 / 1000000000000000000.0

a è troppo piccolo per essere rappresentato correttamente da float (32 bit), quindi è "arrotondato" a -0.

Ora, supponiamo che il nostro calcolo continui:

b = 1 / a

Poiché a è float, risulterà -infinito che è abbastanza lontano dalla risposta corretta di -100000000000000000000.0

Ora calcoliamo b se non c'è -0 (quindi a è arrotondato a +0):

b = 1 / +0
b = +infinity

Il risultato è di nuovo sbagliato a causa dell'arrotondamento, ma ora è "più sbagliato" - non solo numericamente, ma soprattutto a causa del segno diverso (il risultato del calcolo è + infinito, il risultato corretto è -100000000000000000000.0).

Si potrebbe ancora dire che non importa davvero perché entrambi hanno torto. La cosa importante è che ci sono molte applicazioni numeriche in cui il risultato più importante del calcolo è il segno, ad esempio quando si decide se girare a sinistra o a destra all'incrocio usando un algoritmo di apprendimento automatico, è possibile interpretare un valore positivo => turn sinistra, valore negativo => gira a destra, la "grandezza" effettiva del valore è solo "coefficiente di confidenza".

Innanzitutto, come si crea un -0? Esistono due modi: (1) eseguire un'operazione in virgola mobile in cui il risultato matematico è negativo, ma così vicino a zero che viene arrotondato a zero e non a un numero diverso da zero. Questo calcolo darà un -0. (b) Determinate operazioni che comportano zeri: moltiplicare uno zero positivo per un numero negativo o dividere uno zero positivo per un numero negativo o annullare uno zero positivo.

Avere uno zero negativo semplifica un po 'la moltiplicazione e la divisione, il segno di x * yo x / y è sempre il segno di x, esclusivo o il segno di y. Senza zero negativo, ci dovrebbe essere un controllo extra per sostituire -0 con +0.

Ci sono alcune situazioni molto rare in cui è utile. Puoi verificare se il risultato di una moltiplicazione o divisione è matematicamente maggiore o minore di zero, anche se c'è un underflow (purché tu sappia che il risultato non è uno zero matematico). Non ricordo di aver mai scritto codice in cui fa la differenza.

Ottimizzare i compilatori odia -0. Ad esempio, non è possibile sostituire x + 0.0 con x, poiché il risultato non dovrebbe essere x se x è -0.0. Non puoi sostituire x * 0.0 con 0.0, perché il risultato dovrebbe essere -0.0 se x <0 o x è -0.0.

Doppio C # conforme a IEEE 754

    double a = 3.0;
    double b = 0.0;
    double c = -0.0;

    Console.WriteLine(a / b);
    Console.WriteLine(a / c);

stampe:

Infinity
-Infinity

in realtà per spiegare un po '...

Double d = -0.0; 

Questo significa qualcosa di molto più vicino a d = The Limit of x as x approaches 0-o The Limit of x as x approaches 0 from the negatives.

Per rispondere al commento di Philipp ...

Lo zero sostanzialmente negativo significa underflow.

C'è uno scarso utilizzo pratico per zero negativo se presente ...

ad esempio, questo codice (di nuovo C #):

double a = -0.0;
double b = 0.0;

Console.WriteLine(a.Equals(b));
Console.WriteLine(a==b);
Console.WriteLine(Math.Sign(a));

produce questo risultato:

True
True
0

Per spiegare in modo informale, tutti i valori speciali che un IEEE 754 in virgola mobile può avere (infinito positivo, infinito negativo, NAN, -0,0) non hanno significato in senso pratico. Non possono rappresentare alcun valore fisico o alcun valore che abbia senso nel calcolo del "mondo reale". Ciò che significano è fondamentalmente questo:

• l'infinito positivo indica un overflow all'estremità positiva che può rappresentare un punto mobile
• l'infinito negativo indica un overflow all'estremità positiva che può rappresentare un punto mobile
• zero negativo significa un underflow e gli operandi avevano segni opposti
• zero positivo può significare un underflow e gli operandi avevano lo stesso segno
• NAN significa che il tuo calcolo è indefinitamente definito, simile sqrt(-7)o che non ha un limite simile 0/0o similePositiveInfinity/PositiveInfinity

La domanda su come ciò si riferisce ai calcoli di numeri complessi è davvero al centro del motivo per cui sia +0 che -0 esistono in virgola mobile. Se studi affatto l'Analisi Complessa, scopri rapidamente che le funzioni continue da Complesso a Complesso di solito non possono essere trattate come "a valore singolo" a meno che non si adotti la "finzione educata" che gli output formano quella che è conosciuta come una "superficie di Riemann". Ad esempio, il logaritmo complesso assegna ad ogni input infinitamente molte uscite; quando li "colleghi" per formare un output continuo, finisci con tutte le parti reali che formano una superficie di "cavatappi infinito" attorno all'origine. Una curva continua che attraversa l'asse reale "verso il basso dal lato positivo-immaginario" e un'altra curva che "avvolge il polo" e attraversa l'asse reale "

Ora applicalo a un programma numerico che calcola usando il virgola mobile complesso. L'azione intrapresa dopo un determinato calcolo può essere molto diversa a seconda di quale "foglio" il programma è attualmente "attivo", e il segno dell'ultimo risultato calcolato probabilmente indica quale "foglio". Supponiamo ora che il risultato sia zero? Ricorda, qui "zero" significa davvero "troppo piccolo per rappresentare correttamente". Ma se il calcolo è in grado di organizzare la conservazione del segno (ovvero ricordare quale 'foglio') quando il risultato è zero, il codice può controllare il segno ed eseguire l'azione giusta anche in questa situazione.

Il motivo è più semplice del solito

Naturalmente ci sono molti hack che sembrano davvero belli e sono utili (come arrotondare a -0.0o +0.0ma supponiamo che all'inizio abbiamo una rappresentazione di int firmato con un segno meno / più (so che è stato risolto dal codice binario U2 in numeri interi di solito, ma assume una rappresentazione meno complessa del doppio):

0 111 = 7
^ sign

E se c'è un numero negativo?

1 111 = -7

Va bene, così semplice. Quindi rappresentiamo 0:

0 000 = 0

Anche questo va bene. Ma che dire 1 000? Deve essere un numero proibito? Meglio di no.

Supponiamo quindi che ci siano due tipi di zero:

0 000 = +0
1 000 = -0

Bene, questo semplificherà i nostri calcoli e fornirà alcune funzionalità aggiuntive. Quindi gli +0e -0provengono solo da problemi di rappresentazione binaria.