Seite 1 von 3
Variablentyp Float macht Ärger...
Verfasst: 04.10.2004 15:33
von Ynnus
Hallöchen,
ich wollte gestern ein Programm von Word auf Float ändern, da teils genauere Werte mit Kommastellen benötigt werden. Allerdings trat dabei ein Fehler auf. Jetzt hab ich ein kleines Testprogramm geschrieben, dabei tritt der Fehler auch auf. Es macht einen Unterschied ob eine Variable vom Typ Float oder Word ist, egal ob der selbe Wert drinn gespeichert wird:
Code: Alles auswählen
Wert_1.w = 100
Wert_2.f = 50
Wert_3.w = 22
Wert_4.w = 10
If Wert_1 >= Wert_2 - (Wert_3 / 2) And Wert_4 <= Wert_2 + (Wert_3 / 2)
Debug "Test 1 mit Float anstelle von Word geht"
Else
Debug "Test 1 mit Float anstelle von Word geht NICHT!"
EndIf
Debug "---"
Wert_5.w = 100
Wert_6.w = 50
Wert_7.w = 22
Wert_8.w = 10
If Wert_5 >= Wert_6 - (Wert_7 / 2) And Wert_8 <= Wert_6 + (Wert_7 / 2)
Debug "Test 1 mit Word geht"
Else
Debug "Test 1 mit Word geht NICHT!"
EndIf
Einfach mal durchlaufen lassen. Dabei müsste das erste nicht gehen, das 2te schon. Dabei ist alles was ich geändert habe, den Typ Float in Word.
Wie kann das denn sein, dass es da nicht mehr geht? Das wird doch wohl kein Rundungsfehler sein, so grob muss die Float doch korrekt sein, oder? Ist ja nun keine spezielle Kommastellen-Berechnung bei der große Genauigkeit walten muss, sondern recht grob sodass auch kleine Fehler in den Nachkommastellen keinen Unterschied machen dürften. Aber dennoch geht's nicht.
Jemand eine Idee woran das liegen könnte?
Ach, übrigends, ändere ich Wert_1 von Word auf Float (im ersten Beispiel) dann funktioniert auch der erste Teil oben. Es spielt also eine Rolle, ob es word oder Float ist. Nur warum ist das so?
mfg.
Sunny
Verfasst: 04.10.2004 15:46
von bobobo
Äpfel und Birnen??
1 Apfel plus eine birne ergibt halt Apfelbirnenmus
Wandel die Werte erst in ein einheitliches Format und rechne dann damit
mal flott
und mit sowas soll das arme PB dann ein richtiges Ergebnis erzeugen können ?
Code: Alles auswählen
Wert_1.w = 100
Wert_2.f = 50
Wert_3.w = 22
Wert_4.w = 10
Debug "Variablen in echt"
Debug Wert_1
Debug wert_2
Debug wert_3
Debug wert_4
Debug "als Word ausgelesen"
Debug PeekW(@wert_1)
Debug PeekW(@wert_2)
Debug PeekW(@wert_3)
Debug PeekW(@wert_4)
Debug "als Float ausgelesen"
Debug PeekF(@wert_1)
Debug PeekF(@wert_2)
Debug PeekF(@wert_3)
Debug PeekF(@wert_4)
Debug ""
Debug "ergo ..eine Word-Variable als Float ausgelesen ergibt nichts was man haben möchte."
Verfasst: 04.10.2004 15:55
von freedimension
bobobo hat geschrieben:... und rechne dann damit
mal flott
Code: Alles auswählen
If ValF(Str(Wert_1)) >= Wert_2 - (ValF(Str(Wert_3)) / 2)
Flott in Verbindung mit diesem Code würde ich als ein Verbrechen bezeichnen
So hätte ich es durchgehen lassen:
Code: Alles auswählen
Wert_1.w = 100
Wert_2.f = 50
Wert_3.w = 22
Wert_4.w = 10
Wert_2_kopie.w = Wert_2
If Wert_1 >= Wert_2_kopie - (Wert_3 / 2) And Wert_4 <= Wert_2_kopie + (Wert_3 / 2)
Debug "Test 1 mit Float anstelle von Word geht"
Else
Debug "Test 1 mit Float anstelle von Word geht NICHT!"
EndIf
Debug "---"
Wert_5.w = 100
Wert_6.w = 50
Wert_7.w = 22
Wert_8.w = 10
If Wert_5 >= Wert_6 - (Wert_7 / 2) And Wert_8 <= Wert_6 + (Wert_7 / 2)
Debug "Test 1 mit Word geht"
Else
Debug "Test 1 mit Word geht NICHT!"
EndIf
Verfasst: 04.10.2004 16:32
von AndyMars
Schöne Beispiele habt Ihr da. Aber was bringt das - da kann man doch gleich bei Word bleiben. Ausserdem finde ich PB ist gar nicht so arm. Im Einzelnen ist es doch tatsächlich fähig, Float mit Word zu vergleichen:
Code: Alles auswählen
Wert_1.w = 100
Wert_2.f = 50 ;change here .w or .f
Wert_3.w = 22
Wert_4.w = 10
Debug Wert_1
Debug ">="
Debug Wert_2 - (Wert_3 / 2)
If Wert_1 >= Wert_2 - (Wert_3 / 2)
Debug "True"
Else
Debug "False"
EndIf
Debug ""
Debug Wert_4
Debug "<="
Debug Wert_2 + (Wert_3 / 2)
If Wert_4 <= Wert_2 + (Wert_3 / 2)
Debug "True"
Else
Debug "False"
EndIf
Debug ""
Debug "ALL TOGETHER (AND)"
If (Wert_1 >= Wert_2 - Wert_3 / 2) And (Wert_4 <= Wert_2 + Wert_3 / 2)
Debug "True"
Else
Debug "False"
EndIf
Code: Alles auswählen
Debugger output:
100
>=
39.000000
True
10
<=
61.000000
True
ALL TOGETHER (AND)
False
Nun erklärt mir doch mal bitte, weshalb das #False ergibt, obwohl man oben sehen kann, dass links und rechts vom AND ein #True raus kommt...
Verfasst: 04.10.2004 16:37
von Ynnus
Dann brauch ich also vorher immer eine Dummy-Variable vom Typ Word in die die Float Werte kommen bevor ich damit rechnen kann? Was aber wenn es Kommazahlen sein müssen? Wenn Wert_2.f = 50 in Wert_2.f = 50.2342 gewandelt wird. Das in eine Word und ich hab ungenaue Werte, da die Nachkommastellen wegfallen...
Gibts dafür auch eine Möglichkeit?
Verfasst: 04.10.2004 18:08
von bobobo
klar..
aus 123.56789 mach 123 und 56789
damit dann rumrechnen und wieder zusammenfügen zur Ausgabe.
Oder (wenn's reicht vom Zahlenraum her)
aus 123.56789 wird 12356789 (wenn Du nur im positiven rechnest kannst du den Bereich noch etwas ausdehnen indem Du die Zahlen in dem Zahlenbereich für Longs passend verschiebst.
Long -2147483648 bis +2147483647
12456789 wird dann 12456789-2147483647
Die anzuwendende Mathematik muss das halt berücksichten und für die Ausgabe wieder zurückwandeln.
ansonsten gibt es noch ein paar libs die sich mit floats beschäftigen.
siehe purearea.net und hier im Forum
Verfasst: 04.10.2004 21:34
von Lars
Also sorry Jungs, aber das sollte eine Programmiersprache nun wirklich
können, Variablen rational umzuformen sollte nun einmal zum Standard
gehören.
Konker muss ja eigentlich in einem Ausdruck der Wert des Ausdruckes
sowie sämtliche Einzelvariablen in den Typ der höchsten Genauigkeit, der
in dem Ausdruck vorkommt, umgewandelt werden.
Sprich:
Ausdruck: Work = Word * Byte * Float => Float * Float * Float = (Float => Word)
etc.
Verfasst: 05.10.2004 09:01
von bvc
Ich habe mich mit dem Problem auch schon rumgeärgert
Beispiel:
Code: Alles auswählen
wert.f=120
prozent.f=32
erg.f=wert*prozent/100
Debug erg ; --> 38.400002
str_erg.s=StrF(erg,2)
Debug str_erg ; --> 38.40
nachkomma.f= ValF("0."+StringField(str_erg,2,"."))
Debug nachkomma ; --> 0.400000
vorkomma.f=Val(StringField(str_erg,1,"."))
Debug vorkomma ; --> 38.000000
erg2.f=vorkomma+nachkomma
Debug erg2 ; --> 38.400002
Als einzige Lösung blieb mir zum Schluß das rechnen ohne nachkommastellen (werte vorher multiplizieren, rechnen, wieder teilen, strings zusammenbasteln, manuell runden) ergebnis dann als formatierten string wieder in die Datenbank.
Suchen nach Lösung hat als Ergebnis nur eine C-Lib ergeben, die zwar frei ist, aber auf deren Verwendung man hinweisen muss. --> für mich auch keine Lösung.
Verfasst: 05.10.2004 14:30
von coldarchon
Lars hat geschrieben:Also sorry Jungs, aber das sollte eine Programmiersprache nun wirklich
können, Variablen rational umzuformen sollte nun einmal zum Standard
gehören.
klar
und bitte auch Vergleichsoperationen wenn Zahlen in einer Stringvariable untergebracht sind ...
Es sollte zum Standard
wissen eines Programmierers gehören, welchen Variablen man welchen Typ verpasst und wie man dann damit arbeiten kann. Also sorry Jungs, bin sonst eigentlich nett, aber sowas ...
Verfasst: 05.10.2004 15:04
von freedimension
coldarchon hat geschrieben:klar
und bitte auch Vergleichsoperationen wenn Zahlen in einer Stringvariable untergebracht sind ...
Es sollte zum Standard
wissen eines Programmierers gehören, welchen Variablen man welchen Typ verpasst und wie man dann damit arbeiten kann. Also sorry Jungs, bin sonst eigentlich nett, aber sowas ...
Was hast du erwartet? Wo BASIC draufsteht muß auch BASIC drinne sein, so einfach ist das wohl. Meine Geduld mit den ewigen Float-Fragen geht hiermit so auch zu Ende. Jungs, könnt ihr bitte bitte bitte die Suchmaschine bemühen (auch altes Archiv) bevor ihr immer wieder das alte Thema auf den Tagesplan holt. Oder lest mal zur Abwechslung die Hilfe oder ein gutes Informatikbuch, den Programmieren ist mehr als nur Befehle schreiben, Programmieren ist vor allem eines: Verstanden haben
Vorschlag meinerseits: Intelligentes Vergleichen von Strukturen mit anderen Variablentypen. Bin mal gespannt ob Fred das hinbekommt so das jeder zufrieden ist