Variablentyp Float macht Ärger...

[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

[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

Code: Alles auswählen

siehe freedimensions beitrag unten

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."

[freedimension]

... 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

[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...

[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?

[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

[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.

[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.

[coldarchon]

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 Standardwissen 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 ...

[freedimension]

klar

und bitte auch Vergleichsoperationen wenn Zahlen in einer Stringvariable untergebracht sind ...

Es sollte zum Standardwissen 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