Newsgroup: it.comp.lang.delphi
Titolo: Divisione a 64 bit

Sto implementando la divisione a 64 in quanto dovro' usare tale 
procedura in un microcontroller in C like che arriva solo fino a 32bit.
Ecco il codice (qui tutte le var sono int64 ad esclusione di n e Count)
n:=64;
Count:=64;
Q:=0;
R:=0;
for i:=1 to n do
    begin
    Count:=Count-1;
    K:=(1 Shl Count);
    K:=Dv And K;        // Cifra al posto Count
    K:=K Shr Count;
    R:=(R Shl 1) Or K;
    While R>=De do
      begin
      Q:=Q+1;
      R:=R-De;
      end;
    if i<n then
      Q:=Q Shl 1;
    end;
 
Per Dividendi inferiori ai 4Giga (DWord) funziona bene, appena sopra da 
risultati errati. Qualcuno riesce ad intravedere errori?
 
Grazie, Giorgio

 risultati errati. Qualcuno riesce ad intravedere errori?
Questo rafforza i miei dubbi sulla coesistenza di variabili a 64 bit su 
hardware a 32. Il tuo errore è un tipico overflow che si verifica quando 
vuoi rappresentare un numero troppo grande per i bit che hai a disposizone.
Io non sono in grado di supportarti perchè non ho più delphi installato, 
tuttavia su stackoverflow puoi verificare questo suggerimento:
http://stackoverflow.com/questions/2566010/fastest-way-to-calculate-a-128-bit-integer-modulo-a-64-bit-integer
 
 
 
-- 
morde
QT 4.7
Delphi (5,6,7.. expired)
Firebird Database
 

 Io non sono in grado di supportarti perchï¿œ non ho piï¿œ delphi installato,


Dopo qualche debug ho trovato il problema, che non saprei se e' un baco 
del compilatore o se c'e' qualcosa da impostare:
 
la linea imputata era:
 
K:=1 SHl Count;
 
provate con K: Int64;
 
K:=1 Shl 31; //e con
K:=1 Shl 63;
 
si ottiene lo stesso valore, sembra che usando gli int64 lo Shl lavori 
fino a 31 shiftate e poi si fermi.
Ottenedo K in un altra maniera i risultati tornano a coincidere con la 
div e il mod calcolati da Delphi.
 
Giorgio

 div e il mod calcolati da Delphi.
 
Il compilatore suppone che quell' "1" di cui vai a fare lo shift
sia un intero a 32 bit, a prescindere da quello che c'è a sinistra
dell'assegnazione o il tipo della variabile count.
Prende un registro a 32 bit, gli assegna "1" e ne fa lo shift tramite
l'SHL delle CPU x86 che operano in modulo 32. Shift di 1 o 33 danno
lo stesso risultato.
 
Se fai un typecast della costante il compilatore ti dà retta e vedrai
che (Int64(1) shl 31) <> (Int64(1) shl 63) .
 
Ciao,
 
-- 
Virgilio Lattanzi        Teamsystem Communication srl
Tel: 
+39 0733 818863
     via Fontanella, 38
Fax: 
+39 0733 819133
     62012 Civitanova Marche MC
WWW: 
www.tscomm.it
       ITALY


Grazie, in effetti era cosi', giorgio

 Grazie, in effetti era cosi', giorgio
 
La cosa e' un po strana pero' dal momento che l'assegnazione viene 
effettuata su una var int64 non trovi?
giorgio

 effettuata su una var int64 non trovi?
 
Sì e no. Mettiti nei panni di chi scrive il compilatore e di chi il
compilatore lo usa. Se a sinistra dell'assegnazione avessi avuto un
byte, ti sarebbe andato bene se le eventuali operazioni di shift
fossero state effettuate su 8 bit ? A me no, perché avrei preferito
lavorare su 32 ed usare solo alla fine gli 8 bit meno significativi.
 
D'altro canto, usare sempre 64 bit per troncare alla fine, sarebbe
stato troppo oneroso in termini computazionali ed io mi sarei lamentato
lo stesso. Direi che usare i 32bit di default e darti la possibilità
con il typecast di forzare la mano sia la cosa più ragionevole.
 
Visto il tipo di lavoro che stai facendo, ti consiglio, in caso di
dubbi, di dare un'occhiata al codice compilato con il debugger e
la visualizzazione della CPU. Solo in quel modo hai la sicurezza
del comportamento effettivo del codice.



Grazie del suggerimento, cmq il piu' e' fatto, sto ottenendo la 
differenza da 32 a 64 bit e l'incremento di uno. Poi basta riscrivere il 
tutto in C, Giorgio

 tutto in C, Giorgio
 
Scusate faccio la parte del rompiballe che non sa niente ma che vuole 
capire e soprattutto imparare.. quindi ti rompo un pò le scatole ma ti 
chiedo di spiegarmi come gira il discorso: perchè scrivi in delphi e poi 
traduci in C? Non potresti scrivere e compilare direttamente in C?
 
ciao



Nel C che usero' alla fine non esistono gli int64 e tantomeno il loro 
quoziente intero., al contrario di delphi 2005.
Creare l'algoritmo in Delphi porta a 2 vantaggi: che in un primo momento 
non ti devi preoccupare di usare solo interi a 32 bit, inoltre con una form
ed un po di tedit hai la verifica diretta sul risultato dell'algoritmo.
Trovato il codice in delphi e' una banalita' convertirlo in C, solo che 
ti rimane da maneggiare dove usa le 64 bit che andranno rimpiazzate da 2 
a 32 bit.
In sostanza il problema e' stato suddiviso in 2 sottoproblemi ognuno 
piu' semplice da risolvere rispetto l'accoppiata.
 
giorgio