Newsgroup: it.comp.lang.visual-basic
Titolo: compatibilità variabili (help pls)

il problema è:
in 1 tabella di access il campo ID_codice_persona è un contatore di tipo
long, nel codice io dichiaro "codice" come long però quando nel codice
faccio il confronto
IF codice = tab!id_codice_persona THEN
(...)
esce fuori un errore di compatibilità tra i tipi di dati
potete aiutarmi ???
grazie mille

 IF codice = tab!id_codice_persona THEN
prova
IF CDbl(codice) = CDbl(tab!id_codice_persona) THEN
giuseppeD

 ha scritto nel messaggio
news:EBi09.125290$Jj7.2...@news1.tin.it...

grande, ho provato e funziona. GRAZIE MILLE


puoi provare anche cosi':
IF codice = CLng(tab!id_codice_persona) THEN
perche' il confronto tra Double e' soggento ad altri problemi,
che e' meglio tenere lontani.
bye
R


Questa me la devi spiegare!
Perchè dovrebbe essere necessaria una conversione ad un tipo di dato "meno
nobile" per far funzionare un confronto?
Le operazioni "empiriche" non mi sono mai piaciute... evidentemente il
problema è da un'altra parte.
Ciao

 ha scritto nel messaggio
news:D1u09.147069$vm5.4...@news2.tin.it...

Daccordo pienamente.
Il CLng , come presentato da Nerone , è meglio.
Considera l'ora della risposta 22,49
Ho pensato che con Funzione di conversione numerica CDbl risolveva sia se i
numeri da confrontare erano con o senza virgola .
Daccordo CDbl occupa 8 byte ; CLng 4 byte.
Era da aggiungere alla risposta : " guarda guida in linea 'Funzioni di
conversione del tipo' "
giuseppeD

 conversione del tipo' "
Continuo a non capire... la variabile č long, il campo č long... che motivo
c'č di convertirle?
Anche se una fosse stata long e l'altra double non ci sarebbe stato motivo!
Le virgole darebbero fastidio solo se una delle due fosse una stringa
contenente un valore numerico decimale e non mi sembra il caso.
Continuo a credere che il motivo sia da ricercare da altre parti.
Ciao

 Continuo a credere che il motivo sia da ricercare da altre parti.
Penso di aver capito il tuo dubbio.
Giovanni asserisce:
1- campo ID_codice_persona è un contatore di tipo long,
2- nel codice io dichiaro "codice" come long
quindi  es. se ID=8 e codice=8
quindi
if ID=codice then
non  deve dare "errore di compatibilità tra i tipi di dati" , perchè i dati
a confronto sono dello stesso tipo.
Strano che il tutto torna se confronto: CDbl(ID)=CDbl(codice)
Il che fa pensare che un dato o non è stato dichiarato come long o come dici
esiste una variante che non si conosce.
giuseppeD

 Il CLng , come presentato da Nerone , č meglio.
no, la mia soluzione e' una 'pezza'  che in un programma serio non
ci deve essere!
i problemi a cui mi riferisco sono dovuti a come i numeri double sono
memorizzati, 4 o 8 byte non ha importanza.
per spigare quello che voglio dire ho fatto un piccolo esempio,
basta creare un form e metterci un command e
copia il codice che segue.
====================================
Private Sub Command1_Click()
Dim A As Double
Dim B As Double
Dim C As Variant
Dim I As Integer
    C = Array(19.2, 6#, 144.24, 10#, 30.16, 4.34, 32.23, 22#)
    For I = 0 To UBound(C)
        A = A + C(I)
    Next I
    B = 268.17
Debug.Print A
Debug.Print B
    If A = B Then
        Debug.Print "="
    Else
        Debug.Print "<>"
    End If
End Sub
====================================
il vero problema non e' come si comportano i numeri di tipo Double,
quello e' insito nella loro natura, bensi' sono i camuffamenti operati
dal VB che impediscono al programmatore quello che sta succedendo!
in pratica non c'e' modo di vedere il VERO valore di A
spero di essermi spiegato
bye
R


anche a me sembra cosi', peccato che non si riesca ad
indagare meglio.
bye
R

 in pratica non c'e' modo di vedere il VERO valore di A
Sono completamente d'accordo a metà con te :)
Ciao


Ho voluto testare l'esempio con altri tipi.
Sono rimasto perplesso del comportamento diverso da quello che uno si
aspetta.
Private Sub Command1_Click()
Dim A As Double
Dim B As Double
Dim C As Variant
Dim I As Integer
Dim s As Single
Dim t As Currency
    'C = Array(19.2, 6#, 144.24, 10#, 30.16, 4.34, 32.23, 22#)
     C = Array(19.2, 6, 144.24, 10, 30.16, 4.34, 32.23, 22)
    For I = 0 To UBound(C)
        A = A + C(I)
        t = t + C(I)
        s = s + C(I)
    Next I
    B = 268.17
Debug.Print A
Debug.Print B
Debug.Print s
Debug.Print t
    If A = B Then
        Debug.Print "="
    Else
        Debug.Print "<>"
    End If
    If (s) = (B) Then
        Debug.Print "="
    Else
        Debug.Print "<>"
    End If
    If (t) = (B) Then
        Debug.Print "="
    Else
        Debug.Print "<>"
    End If
     If CSng(A) = B Then
        Debug.Print "="
    Else
        Debug.Print "<>"
    End If
End Sub
Mi chiedo : detto comportamento è standard per qualsiasi coppia di numeri o
potrebbe esistere una accoppiata che come risultato da una risposta
differente ?
Sono preoccupato.
giuseppeD


spiego meglio, lo stesso esempio in java sarebbe cosi:
============================
public class TestFloat {
  public static void main(String Argv[]) {
    double v[] = { 19.2, 6.0, 144.24, 10.0, 30.16, 4.34, 32.23, 22.0 };
    double a, b = 268.17, c;
    a = (v[0] + v[1] + v[2] + v[3] + v[4] + v[5] + v[6] + v[7]);
    c = (v[7] + v[6] + v[5] + v[4] + v[3] + v[2] + v[1] + v[0]);
    System.out.println("a = " + a);
    System.out.println("b = " + b);
    System.out.println("c = " + c);
  }
}
============================
ma l'output prodotto e' questo:
a = 268.16999999999996
b = 268.17
c = 268.17
ci sono gli  stessi problemi di calcolo, ma non sono
nascosti, li vedi e ti puoi comportare di conseguenza,
in VB lo devi immaginare che il problema e' quello!
bye
R

 differente ?
no, non e' standard per fortuna, ma non e' prevedibile!
bye
R

 c = 268.17
Mah... tra i due (java vs VB) non so quale sia il peggiore :)
VB fa le somme corrette ma i confronti errati, java sbaglia adirittura i
conti...
D'altronde i confronti con valori decimali (che comunque non c'entra niente
con il prost iniziale del trhead) dovrebbero essere fatti così (specifiche
IEEE, proprio per evitare questi problemi):
Const TOLLERANCE = 0.000000000000001 ' tolleranza a discrezione
abs(a - b) < TOLLERANCE ' a = b
Ciao

 abs(a - b) < TOLLERANCE ' a = b
questa e' una informazione molto utile.
hai un link? grazie
bye
R

 abs(a - b) < TOLLERANCE ' a = b
Mi sfugge qualcosa:
es:
Const TOLLERANCE = 0.0000000001
Dim a As Single, b As Single, c As Double
a = 150.34
b = 22.125
c = (Abs(a / b)) 'il risultato deve essere :< TOLLERANCE
Debug.Print c
come limitare il risultato della divisione confrontandola con la constante ?
giuseppeD

 hai un link? grazie
Non ricordo il link esatto, ricordo solo che era un articolo della sun.
ma cerca pure su google "ieee specifications floating" e divertiti :)
Ciao

 come limitare il risultato della divisione confrontandola con la constante
?
Questa ancora meno :)
Ciao