Sommatoria sicura di tracimazione

Supponiamo che mi vengano dati numeri interi a larghezza fissa (cioè si inseriscano in un registro di larghezza ), tale che la loro somma si inserisca anche in un registro di larghezza . $n$ $w$ $a_1, a_2, \dots a_n$ $a_1 + a_2 + \dots + a_n = S$ $w$

Mi sembra che possiamo sempre permutare i numeri per tale che ogni somma prefisso rientra anche a un registro di larghezza . $b_1, b_2, \dots b_n$ $S_i = b_1 + b_2 + \dots + b_i$ $w$

Fondamentalmente, la motivazione è calcolare la somma su macchine a registro a larghezza fissa senza doversi preoccupare di overflow di numeri interi in qualsiasi fase intermedia. $S = S_n$

C'è un rapido (tempo preferibilmente aria) algoritmo per trovare una tale permutazione (assumendo che il sono date come un array input)? (o dire se tale permutazione non esiste). $a_i$

— Aryabhata
fonte

Follow-up: rilevamento dell'overflow in somma : esiste un metodo più veloce che tiene conto delle caratteristiche tipiche del processore?

— Gilles 'SO- smetti di essere cattivo' il

Basta usare due registri complemento e sommarli. Anche se trabocca nel mezzo, la tua pre-condizione garantisce che gli overflow si annullino e il risultato sarà corretto. : P

— Codici A Caos il

@CodeInChaos: è davvero vero?

— Aryabhata,

Credo di si. In pratica stai lavorando in un gruppo modulo 2 ^ n, dove scegli la rappresentazione canonica da -2^(n-1)a 2^(n-1)-1. Naturalmente richiede il complemento a due e un comportamento di overflow ben definito, ma in un linguaggio come C # dovrebbe funzionare.

— CodesInChaos

@CodeInChaos: Non ci sono due possibilità che danno lo stesso resto modulo

? In pratica stai dicendo, indipendentemente dall'ordine, uno di loro non può mai accadere. Oppure mi sfugge qualcosa?

2^{n}

$2^n$

— Aryabhata,

Strategia
Il seguente algoritmo a tempo lineare adotta la strategia di rimanere in bilico intorno a , scegliendo numeri positivi o negativi in base al segno della somma parziale. Elabora la lista dei numeri; calcola la permutazione dell'input al volo , mentre esegue l'aggiunta. $0$

Algoritmo

Partizionare in un due liste, gli elementi positivi e gli elementi negativi . Gli zeri possono essere filtrati. $a_1, \ldots, a_n$ $P$ $M$
Sia . $Sum=0$
Mentre entrambi gli elenchi sono non vuoti
$~~~~~~$ Se { ; ; } $Sum>0$ $Sum:=Sum+\text{head}(M)$ $M:=\text{tail}(M)$
$~~~~~~$ else { ; ; } $Sum:=Sum+\text{head}(P)$ $P:=\text{tail}(P)$
Quando una delle due liste si svuota, aggiungere il resto della lista rimanente per . $S$

Correttezza La
correttezza può essere stabilita usando un semplice argomento induttivo sulla lunghezza dell'elenco di numeri.

Innanzitutto, prova che se sono tutti positivi (o tutti negativi), e la loro somma non provoca overflow, allora non fanno neppure le somme del prefisso. Questo è semplice. $a_1, \ldots, a_n$

In secondo luogo, dimostrare che è all'interno dei limiti è un invariante del ciclo dell'algoritmo. Chiaramente, questo è vero all'entrata nel loop, come . Ora, se , l'aggiunta di un numero negativo entro i limiti a non fa sì che esca dai limiti. Allo stesso modo, quando sommando un numero positivo entro i limiti da sommare non fa sì che esca dai limiti. Quindi all'uscita dal loop, $Sum$ $Sum=0$ $Sum>0$ $Sum$ $Sum$ $Sum\le0$ $Sum$ è nei limiti. $Sum$

Ora, il primo risultato può essere applicato e insieme questi sono sufficienti per dimostrare che la somma non va mai oltre i limiti.

— Dave Clarke
fonte

Verso un'implementazione sul posto efficiente, eseguire a) Quicksort-partitioning (la variante a due puntatori) con pivot implicito

e quindi b) sommare, spostando un puntatore ciascuno attraverso l'area con resp. numeri positivi.

0

$0$

— Raffaello