-
        

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 21

Thema: Rechnen mit Gleitkommazahlen

  1. #1
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    15.01.2008
    Ort
    Siegen, Germany, Germany
    Beiträge
    441

    Rechnen mit Gleitkommazahlen

    Anzeige

    SMARTPHONES & TABLETS-bis zu 77% RABATT-Kostenlose Lieferung-Aktuell | Cool | Unentbehrlich
    Hallo zusammen,

    ich habe einen Integer Wert, der den Bereich -255 bis 255 abdecken sollte. Der Wert soll sich aus folgender Rechnung ergeben:

    (100/65536)* wert * 100;

    Nun wird da ja eine Zahl raus kommen, die nicht in ein Integer passt, ich bin davon ausgegangen, dass die Nachkommastellen einfach weggelassen werden. Es kommt aber immer 0 raus?
    liebe Grüße
    Der Daniel
    -
    Meine Projektseite:
    http://projects.weber-itam.de

  2. #2
    Neuer Benutzer Öfters hier
    Registriert seit
    05.03.2011
    Ort
    Graz
    Beiträge
    29
    Probier mal Wert*10000/65536, das ist rundungstechnisch auf jeden Fall besser.
    Ohne Code ist es schwierig was zu sagen, aber bist du dir sicher, dass der Compiler bei der Rechnung auch intern Floats benutzt? Ich mir nämlich nicht

    mfg

  3. #3
    Erfahrener Benutzer Robotik Einstein Avatar von Felix G
    Registriert seit
    29.06.2004
    Ort
    49°32'N 8°40'E
    Alter
    34
    Beiträge
    1.780
    Die Division durch 65536 ist das Problem, denn der Compiler interpretiert alle Werte als Integer (es sei denn, wert ist ein float).

    Eine mögliche Lösung sähe so aus:
    Code:
    (int)((100.0f / 65536.0f) * (float)wert * 100.0f);
    oder
    (int)(((float)100 / (float)65536) * (float)wert * (float)100);
    Es gibt aber auch noch eine etwas elegantere Lösung, wenn man die Reihenfolge geringfügig ändert:
    Code:
    (100 * 100 * wert) >> 16;
    bzw.
    (10000 * wert) >> 16;
    Hier habe ich die rechenintensive Division durch einen einfachen Rechtsshift ersetzt, der wesentlich schneller ist (geht immer, wenn man durch 2^n dividieren möchte). Wichtig dabei ist aber, daß die Multiplikation vorher erfolgt, denn sonst entsteht wieder das selbe Problem wie bei deiner Variante.
    So viele Treppen und so wenig Zeit!

  4. #4
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    33
    Beiträge
    2.380
    100/65536 = 0 .... die nachkommazahlen werden abgeschnitten!

    und alles multipliziert mit null bleibt null ^^

    stell es doch ein wenig um, erst alles multiplizieren und DANN dividieren, aber achtung, pass auf dass bei dem multiplizieren der wert nicht überläuft!
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

  5. #5
    Erfahrener Benutzer Robotik Visionär
    Registriert seit
    26.11.2005
    Ort
    bei Uelzen (Niedersachsen)
    Beiträge
    7.942
    Damit es beim Multiplizieren keinen Überlauf gibt kann man die Berechnung mit 32 Bit Zahler erzwischen, indem man die Konstante 10000 als 10000L schreibt und so zu einem Long wert macht.

  6. #6
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    33
    Beiträge
    2.380
    wenn man auf den Zahlenbereich achtet, sollte man sich den Rechenvorteil der Prozessorarchitektur nicht durch Verwendung von long Werten zunichte machen finde ich, außerdem habe ich vergessen zu erwähnen, dass man am besten einen expliziten cast auf (signed int) der Formel voranstellt, damit der compiler auch das Vorzeichen mitnimmt!
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

  7. #7
    Erfahrener Benutzer Robotik Visionär
    Registriert seit
    26.11.2005
    Ort
    bei Uelzen (Niedersachsen)
    Beiträge
    7.942
    Um eine Rechnung mit 32 Bit kommt man in C kaum herum:
    Wenn das Ergebnis bis 255 gehen kann, passt das Ergebnis * 65536 gerade nicht mehr in 24 Bit, und schon gar nicht in 16 Bits.

    In die 24 Bit würde man es gerade noch bekommen indem man
    ((25*25)*wert) / (4096) rechnet.
    Aber 24 Bit Zahlen werden von GCC, wie fast allem C Compilern nicht unterstützt, das hilft einem also auch nicht weiter. Genauso fehlt die Multiplication 16 Bit * 16 Bit -> 32 Bit oder besser noch nach 24 Bit.

  8. #8
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    20.08.2008
    Ort
    Kandel
    Alter
    29
    Beiträge
    1.220
    Zitat Zitat von Felix G Beitrag anzeigen
    Code:
    (10000 * wert) >> 16;
    Hier habe ich die rechenintensive Division durch einen einfachen Rechtsshift ersetzt, der wesentlich schneller ist (geht immer, wenn man durch 2^n dividieren möchte). Wichtig dabei ist aber, daß die Multiplikation vorher erfolgt, denn sonst entsteht wieder das selbe Problem wie bei deiner Variante.
    ACHTUNG: Bei vorzeichenbehafteten Zahlen funktioniert der Rechtsshift nur in bestimmten Situationen (Vielfache von , da er NICHT zur Null hin rundet. Beispiel (für 3-Bit-Integer):
    Code:
    -1 >> 1 = -1 // Falsch
    -2 >> 1 = -1
    -3 >> 1 = -2 // Falsch
    -4 >> 1 = -2
    Allerdings kann man den entstehenden Fehler auch ausbügeln (in diesem Beispiel durch eine Addition von 1)

    mfG
    Markus

  9. #9
    Erfahrener Benutzer Roboter Experte Avatar von sternst
    Registriert seit
    07.07.2008
    Beiträge
    672
    Zitat Zitat von Felix G Beitrag anzeigen
    Es gibt aber auch noch eine etwas elegantere Lösung, wenn man die Reihenfolge geringfügig ändert:
    Code:
    (100 * 100 * wert) >> 16;
    bzw.
    (10000 * wert) >> 16;
    Hier habe ich die rechenintensive Division durch einen einfachen Rechtsshift ersetzt, der wesentlich schneller ist (geht immer, wenn man durch 2^n dividieren möchte).
    Dieser Unsinn ist wohl auch einfach nicht totzukriegen.

    Eine solche Simpelst-Optimierung macht natürlich auch der Compiler selber. Du gewinnst mit dieser Schreibweise also rein gar nichts. Du verlierst nur etwas, nämlich die Offensichtlichkeit der eigentlichen Absicht hinter dem Code.

    Also: wenn du eigentlich dividieren willst, dann benutze '/', und wenn du schieben willst, dann benutze '>>'. Das Eine durch das Andere zu ersetzen, weil es schneller ist (es gibt übrigens auch Prozessoren, wo die Division schneller ist), kannst du getrost dem Compiler überlassen.
    MfG
    Stefan

  10. #10
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    08.04.2009
    Ort
    an der Ostsee
    Beiträge
    334
    moin moin,

    warum so viel Aufwand?
    (100/65536)* wert * 100 -->> das ist doch 1Byte * ~1,52...

    Ich würde da eine kleine Tabelle nehmen, es sind 256 Werte zu 16Bit notwendig.

    so:
    ausWert = Tabelle[abs(einWert)]
    if Signum(einWert) then ausWert = - ausWert


    Warum soll da überhaupt was umgerechnet werden, was ist der Hintergrunf?

    Mit Gruß
    Peter

Seite 1 von 3 123 LetzteLetzte

Ähnliche Themen

  1. Zinsaufgabe rechnen (mit dem Boe-Bot)
    Von butt-bot im Forum Software, Algorithmen und KI
    Antworten: 4
    Letzter Beitrag: 28.03.2007, 22:14
  2. Gruppenschaltung rechnen
    Von Larzarus im Forum Elektronik
    Antworten: 7
    Letzter Beitrag: 28.07.2006, 17:55
  3. Rechnen mit Bascom
    Von atvler im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 12
    Letzter Beitrag: 22.05.2006, 22:50
  4. Rechnen mit 3 Registern
    Von Philipp83 im Forum Software, Algorithmen und KI
    Antworten: 9
    Letzter Beitrag: 10.05.2006, 11:46
  5. Rechnen mit Gleitkommazahlen in Bascom
    Von Stefan im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 9
    Letzter Beitrag: 10.03.2004, 21:39

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •