Un computer tenterà di dividere per zero?

La CPU ha rilevato il rilevamento. La maggior parte delle architetture di set di istruzioni specificano che la CPU eseguirà il trap su un gestore di eccezioni per la divisione dell'intero per zero (non penso che importi se il dividendo è zero).

È possibile che il controllo di un divisore nullo avvenga in parallelo nell'hardware insieme al tentativo di eseguire la divisione, tuttavia, la rilevazione della condizione di violazione cancella invece la divisione e le trappole, quindi non possiamo davvero dire se una parte di esso ha tentato la divisione o meno.

(L'hardware spesso funziona in questo modo, facendo più cose in parallelo e poi scegliendo il risultato appropriato in seguito, perché ognuna delle operazioni può essere avviata immediatamente invece di serializzare sulla scelta dell'operazione appropriata.)

Lo stesso meccanismo di trap to exception verrà utilizzato anche quando viene attivato il rilevamento di overflow, che si richiede di solito usando diverse istruzioni add / sub / mul (o un flag su quelle istruzioni).

La divisione in virgola mobile ha anche incorporato il rilevamento per dividere per zero, ma restituisce un valore diverso ( IEEE 754 specifica < a href="https://en.wikipedia.org/wiki/NaN"> NaN ) invece di intercettare un gestore di eccezioni.

Ipoteticamente parlando, se la CPU ha omesso qualsiasi rilevamento per il tentativo di dividere per zero, i problemi potrebbero includere:

• sospensione della CPU (ad esempio in un ciclo inf.) - ciò potrebbe accadere se la CPU utilizza un algoritmo per dividere gli stop quando il numeratore è inferiore al divisore (in valore assoluto). Un blocco come questo conta praticamente come il crash della CPU.
• una risposta garbage (probabilmente prevedibile), se la CPU utilizza un contatore per terminare la divisione al massimo numero possibile di passaggi di divisione (ad esempio 31 o 32 su una macchina a 32 bit).

Dipende dalla lingua, dal compilatore, dal fatto che tu stia usando numeri interi o numeri in virgola mobile e così via.

Per il numero in virgola mobile, la maggior parte delle implementazioni utilizza lo standard IEEE 754 , in cui la divisione per 0 è ben definita. 0/0 dà un risultato ben definito di NaN (non-un-numero), e x / 0 per x ≠ 0 dà + Infinity o -Infinity, a seconda del segno di x.

In lingue come C, C ++ ecc. la divisione per zero richiama il comportamento non definito. Quindi, secondo la definizione del linguaggio, può accadere qualsiasi cosa . Soprattutto cose che non vuoi che succedano. Come tutto funziona perfettamente bene quando scrivi il codice e distruggendo i dati quando il tuo cliente lo usa. Quindi dal punto di vista della lingua, non farlo . Alcune lingue garantiscono che la tua applicazione andrà in crash; tocca a loro come viene implementato. Per quelle lingue, la divisione per zero si bloccherà.

Molti processori hanno una sorta di istruzione "divide" incorporata, che si comporta in modo diverso a seconda del processore. Nei processori Intel a 32 bit e 64 bit, le istruzioni "divide" provocano il crash dell'applicazione quando si tenta di dividere per zero. Altri processori potrebbero comportarsi diversamente.

Se un compilatore rileva che una divisione per zero si verifica quando si esegue un codice, e il compilatore è bello per i suoi utenti, probabilmente vi darà un avvertimento e genererà un'istruzione "divide" incorporata in modo che il comportamento è lo stesso.

Sembra che ti stia chiedendo cosa succederebbe se qualcuno facesse una CPU che non controlla esplicitamente lo zero prima di dividersi. Ciò che accadrebbe dipende interamente dall'attuazione della divisione. Senza entrare nei dettagli, un tipo di implementazione produrrebbe un risultato che ha tutti i bit impostati, ad es. 65535 su una CPU a 16 bit. Un altro potrebbe riattaccare.

Sappiamo ormai che x/0 e 0/0 non hanno risposte ben definite. Cosa succede se tenti di calcolare 0/0 comunque?

Su un sistema moderno, il calcolo viene passato alla MPU all'interno della CPU e viene contrassegnato come operazione non valida, restituendo NaN .

Su un sistema molto più vecchio, come gli home computer degli anni '80 che non avevano una divisione on-chip, il calcolo era fatto da qualunque software fosse in esecuzione. Ci sono alcune scelte possibili:

• Sottrai le copie sempre più piccole del divisore fino a quando il valore non raggiunge lo zero e tieni traccia di quali copie di dimensioni sono state sottratte
  • Se controlla zero prima della prima sottrazione, uscirà rapidamente e il risultato sarà 0
  • Se presuppone che deve essere in grado di sottrarre almeno una volta, il risultato sarà 1
• Calcola i logaritmi di entrambi i numeri, sottraili e aumenta e alla potenza del risultato. Un metodo molto inefficiente rispetto al metodo di sottrazione sopra, ma matematicamente valido
  • Potrebbe verificarsi un overflow nel tentativo di calcolare log(0) e il software userebbe le sue routine di gestione degli errori o l'arresto
  • Il software potrebbe presumere che tutti i logaritmi possano essere calcolati in un numero fisso di passaggi e restituire un valore grande ma errato. Poiché entrambi i logaritmi sarebbero uguali, la differenza sarebbe 0 e e ⁰ = 1, dando un risultato di 1

In altre parole, dipenderebbe dall'implementazione di ciò che accadrebbe e sarebbe possibile scrivere un software che produca risultati corretti e prevedibili per ogni valore, ma valori apparentemente strani per 0/0 che sono nondimeno, ancora internamente coerenti.