Zur Frage der Transformationen und anderer Operationen

Blue Caterpillar: Nun, Sie werden uns nicht unterkriegen. Wir sitzen uns, wir wissen: Sie warten auf unsere Transformation. Und was? Aber nichts! Wir sitzen, rauchen, warten ...
Alice Puppe: Was?
Blaue Raupe: Was, warum! Von Transformationen. Das Haus in Rauch, der Rauch in eine Dame und die Dame in eine Mutter. Los geht's. Nicht stören, nicht nach vorne springen, sonst verwandeln Sie sich vorzeitig in eine Art Schmetterling.

Beim Durchsehen des Codes in einem der Arduino gewidmeten Foren fand ich eine unterhaltsame Möglichkeit, mit einer Gleitkommazahl (PT) zu arbeiten. Der zweite gebräuchliche Name für Zahlen in diesem Format ist Gleitkomma, aber die Abkürzung (PP), die in diesem Fall persönlich auftritt, verursacht für mich völlig andere Assoziationen, daher werden wir diese Option verwenden. Der erste Eindruck (aus dem Code, den ich gesehen habe) ist, welche Art von Müll hier geschrieben ist (ich muss sagen, dass der zweite derselbe ist, obwohl es Nuancen gibt, aber dazu später mehr), aber die Frage stellt sich - wie ist es wirklich notwendig - die Antwort, auf die in gegeben wird weiterer Text.

Erster Teil - Fragen

Wir formulieren das Problem - wir müssen eine Gleitkommazahl auf der Konsole drucken (in eine symbolische Darstellung verwandeln), ohne die Druckoptionen zu verwenden, die für diesen Zweck vorgesehen sind. Warum wollen wir das alleine machen -

1. Die Verwendung des% f-Formats erfordert das Verbinden der Bibliothek für die Arbeit mit einem Gleitkomma und einer erweiterten Version der prntf-Funktion (oder macht es vielmehr unmöglich, die abgeschnittene Version zu verwenden), was zu einer signifikanten Vergrößerung des ausführbaren Moduls führt.
2. Eine Standardlösung benötigt viel Zeit (sie arbeitet immer mit einer doppelten Genauigkeit), was in dieser speziellen Situation möglicherweise nicht akzeptabel ist.
3. Nun (zu guter Letzt), es ist einfach interessant.

Betrachten Sie zunächst die Option, die im obigen Material vorgeschlagen wurde, etwa:

for (float Power10=10000.0; Power10>0.1; Power10/=10.0; ) {char c=(int)(Fdata/Power10); Fdata -=Power10*c; }; 

und wir sind uns einig, dass er das Problem vollständig löst. Darüber hinaus ist dies keine schlechte Option, da die Geschwindigkeit durchaus akzeptabel sein kann. Schauen wir uns diesen Moment genauer an - wir sehen die Aufteilung der PT-Zahlen, aber wenn wir tiefer in das Wesentliche des Problems eintauchen, stellt sich heraus, dass es fast so schnell ist wie die Aufteilung von ganzen Zahlen der entsprechenden Bittiefe. Bevor Sie die Leistung des Algorithmus bewerten, sollten Sie die Leistung verschiedener Elementaroperationen bewerten, die wir ausführen werden.

Teil zwei - Leistungsbewertung elementarer Operationen

Die erste interessante Operation ist die Addition (Subtraktion im Sinne der aufgewendeten Zeit, sie sind äquivalent) von ganzen Zahlen, und wir können davon ausgehen, dass eine Zeiteinheit (Taktzyklus) mit der folgenden Einschränkung benötigt wird - dies gilt nur für "native" Daten. Für AVR der MK-Serie ist es beispielsweise ein 8-Bit-Wort, für MSP430 ein 16-Bit-Wort (und natürlich kleiner), für Cortex-M ein 32-Bit-Wort und so weiter. Dann kann die Operation des Hinzufügens von Zahlen mit einer Länge von H-mal mehr als der nativen als H-Zyklen geschätzt werden. Es gibt Ausnahmen, z. B. AddW in AVR-Controllern, die Regel wird jedoch nicht aufgehoben.

Die nächste Operation ist die Multiplikation von ganzen Zahlen (aber nicht die Division, sie unterscheidet sich in Bezug auf die Geschwindigkeit) und für ihn ist nicht alles so einfach. Erstens kann die Multiplikation in Hardware implementiert werden und erfordert beispielsweise in AVR MEGA 2 Taktzyklen und in den verbesserten 51 sogar 6 (zum Multiplizieren nativer Zahlen).

Betrachten Sie jedoch den Fall, in dem keine Hardware-Implementierung vorhanden ist und die Multiplikation in Form einer Unterroutine implementiert werden muss. Da beim Multiplizieren von H-Bit-Zahlen ein 2H-Bit-Produkt erhalten wird, kann die Schätzung der klassischen Version mit Verschiebungen wie folgt gefunden werden: Wir benötigen H-Verschiebungen des Faktors mit 1 Taktzyklus pro Verschiebung, H-Verschiebungen des zweiten Faktors 2H lang mit 2 Taktzyklen pro Verschiebung, dann trifft H Entscheidungen und im Durchschnitt N / 2 Additionen von Zahlen mit einer Länge von 2H, abschließend die Organisation eines Zyklus von 2 Maßnahmen. Insgesamt + 2 + + 2 / 2 + 2 = 7 Ticks, und das tatsächliche Ausführen von Rechenoperationen erfordert nur N Ticks (Wow-Effizienz, obwohl wir es geschafft haben, den Motor zu umgehen).

Das heißt, um zwei 8p-Zahlen mit 8p MK zu multiplizieren, sind 56 Zyklen erforderlich, und um 16p-Zahlen zu multiplizieren, gibt es bereits 112 Zyklen (etwas weniger, aber wir vernachlässigen den genauen Wert), was etwas mehr ist, als wir wollten. Glücklicherweise kann die Richtung der Verschiebungen geändert werden, und es gibt eine einzigartige Art der Multiplikation, die nur H-Verschiebungen der Anzahl von 2H-Ziffern und H / 2-Additionen von nativen Zahlen erfordert, was die Betriebszeit des Multiplikationsalgorithmus auf 0 + 2 + 1 + 1/2 verbessert + 2 = 5,5 - natürlich kann es nicht mit der Hardware-Implementierung verglichen werden, aber zumindest ein gewisser Gewinn ohne Funktionsverlust. Es gibt Verbesserungen an diesem Algorithmus, zum Beispiel die Analyse von 2 Bits pro Zyklus, aber sie ändern die Situation nicht drastisch - die Zeit der Multiplikation mit Größenordnungen überschreitet die Zeit der Addition.

Bei der Division ist die Situation jedoch schlimmer - selbst die durch Hardware implementierte Division verliert fast doppelt so viel durch Multiplikation, und es gibt MKs mit Hardware-Multiplikation, jedoch ohne Hardware-Division. Unter bestimmten Bedingungen kann die Division durch Multiplikation mit dem Kehrwert ersetzt werden. Diese Bedingungen sind jedoch spezifisch und ergeben ein ähnliches Ergebnis. Es sind zwei Multiplikationsiterationen erforderlich, gefolgt von der Summe, sodass ein zweifacher Verlust entsteht. Wenn wir die Division als Unterprogramm implementieren, sind H-Verschiebungen des Divisors 2H lang, H-Subtraktionen von der teilbaren 2H-Länge, H-Verschiebungen des Ergebnisses, 2H-Organisation des Zyklus erforderlich, aber all dies geht eine Ausrichtung voraus, die weitere 5H-Zyklen benötigt, sodass die Gesamtzahl 2 beträgt + 2 + 1 + 2 + 5 = 12, was ungefähr 2 mal schlechter ist als die Multiplikation.

Nun, schauen wir uns die PT-Operationen an, und hier ist die Situation etwas paradox - die Multiplikationsoperation benötigt fast so viel Zeit wie für ganze Zahlen (entsprechend der Bitkapazität, in der Regel 24 Bit), da wir die Mantisse multiplizieren und nur die Ordnungen addieren müssen, die Normalisierung nicht erforderlich. Wenn die Division auch gut ist, teilen Sie die Mantisse und subtrahieren Sie die Ordnungen, eine Normalisierung ist wiederum nicht erforderlich. Daher ist für diese beiden Operationen der Verlust im Vergleich zu ganzen Zahlen nicht zu signifikant, obwohl er einen Platz hat.

Die Operation der Addition und Subtraktion erfordert jedoch zunächst die Ausrichtung der Ordnungen (und dies sind Verschiebungen und es kann viele geben, obwohl es Nuancen gibt), dann die Operation selbst und (beim Subtrahieren) die Normalisierung (auch beim Addieren, aber es dauert nicht mehr als eine Verschiebung ), was zeitaufwändig ist, daher sind die Operationen dieser Klasse für PT viel langsamer als für ganze Zahlen, insbesondere relativ gesehen.

Kehren wir zu unseren Schafen zurück und stimmen zu, dass die vorgeschlagene Methode auf der Grundlage der vorherigen Schätzungen möglicherweise nicht zu lang ist, zumal sie sofort das Ergebnis liefert, aber eine erhebliche Einschränkung aufweist - sie ist auf einen sehr begrenzten Bereich von PT-Eingabewerten anwendbar. Daher wird nach einer universellen (mehr oder weniger) Lösung gesucht.

Machen Sie sofort einen Vorbehalt, dass unsere Lösung im Allgemeinen keine Gleitkommaoperationen (vom Wort her) verwenden sollte, um die Vorzüge unserer Option hervorzuheben. Und auf die verblüffte Frage, wie dann eine Nummer dieses Typs angezeigt wird, wenn die Operationen nicht verfügbar sind, antworten wir - dies kann beispielsweise beim Lesen von Informationen von einem Lichtsensor (wie im ursprünglichen Beispiel) auftreten, der Daten im PT-Format erzeugt.

Wie genau die Anzahl der PTs angeordnet ist, können Sie leicht auf zahlreichen Websites finden, es gab einen kürzlich erschienenen Artikel über Habré, es sollte keine Probleme damit geben. Dennoch sind eine Reihe von Fragen für das PT-Format im Stil „Wenn ich der Regisseur wäre“ von Interesse - warum dies so ist und nicht anders. Ich werde einigen von ihnen meine Antworten geben. Wenn jemand mehr richtig weiß, bitte kommentieren.

Die erste Frage ist, warum die Mantisse im direkten Code und nicht im zusätzlichen Code gespeichert ist. Meine Antwort ist, weil es einfacher ist, mit einer normalisierten Mantisse mit einem versteckten (optionalen) Bit zu arbeiten.

Die zweite Frage ist, warum die Bestellung mit einem Offset gespeichert wird und nicht anders. Meine Antwort ist, weil es in diesem Fall einfach ist, die Module von zwei PTs als ganze Zahlen zu vergleichen, mit anderen Methoden ist es komplizierter.

Die dritte Frage ist, warum das negative Vorzeichen eher durch Eins als durch Null codiert wird, weil es dann möglich wäre, die beiden Punkte einfach als ganze Zahlen zu vergleichen. Meine Antwort lautet: Ich weiß es nicht. Es ist nur "hier wird es so akzeptiert".

Dritter Teil - Erforderliche Erklärungen

Im vorigen Absatz konnte ich unverständliche Begriffe nennen, also ein wenig über die Darstellung von Zahlen. Natürlich sind sie unterschiedlich, sonst wäre es nicht nötig, sie zu diskutieren. Wir stellen sofort fest, dass es im Speicher von MK (dasselbe gilt für Computer, obwohl ich die modernsten Architekturen nicht so kategorisch finde - sie sind so kompliziert, dass alles zu erwarten ist) keine Zahlen gibt, sondern nur elementare Speichereinheiten - Bits, die in Gruppen zusammengefasst sind Bytes und weiter in Worte. Wenn wir über die Darstellung einer Zahl sprechen, bedeutet dies, dass wir einen Satz von Bits einer bestimmten Länge auf die eine oder andere Weise interpretieren, dh ein Gesetz festlegen, nach dem wir eine bestimmte Zahl finden können, die einem bestimmten Satz von Bits entspricht, und nicht mehr.

Es können unzählige solcher Gesetze erfunden werden, aber einige von ihnen haben eine Reihe nützlicher Eigenschaften hinsichtlich der Durchführung verschiedener Operationen, so dass sie in der Praxis häufiger angewendet werden. Eine dieser Eigenschaften, die beispielsweise implizit impliziert wird, ist Determinismus, und die andere ist die Unabhängigkeit von der Umwelt - Eigenschaften, die auf den ersten Blick offensichtlich sind, obwohl es Nuancen gibt. Andere Eigenschaften der Art der Eins-zu-Eins-Korrespondenz sind bereits Gegenstand der Diskussion und finden nicht immer in einer konkreten Darstellung statt. Das Thema der Darstellung von Zahlen an sich ist ungewöhnlich faszinierend: Für Knut (in Band 2) ist es vollständig offenbart, so dass es über die Tiefen hinausgeht und wir über die Oberfläche gehen.

Unter der Annahme, dass die Menge der Bits eine Länge n hat (wir nummerieren sie in einer Reihe von 0 bis n-1) und einheitlich mit einem Schritt von 2 gewichtet werden und das niedrigstwertige Bit (mit der Nummer 0) eine Gewichtung von 1 hat (was im Allgemeinen überhaupt nicht notwendig ist, wir nur Wir haben uns an solche Dinge gewöhnt und sie scheinen uns offensichtlich zu sein. Wir erhalten eine binäre Darstellung der Zahl, in der die Reduktionsformel so aussieht: die Zahl, die durch die Menge der Bits (2) = (0)*2^0 + (1)*2^1 + ... + (-1)*2^(-1) angezeigt wird (2) = (0)*2^0 + (1)*2^1 + ... + (-1)*2^(-1) oder in kaskadierter Form 2() = (0)+2*((1)+2*(...+2*((-1))..))) , im Folgenden bezeichnet B (k) ein Bit mit der Nummer k Eine andere Darstellung legt keine Einschränkungen für die Position der Bytes der Zahl im Speicher fest, aber es wäre logischer, das niedrige Byte in den unteren Adressen zu platzieren (so einfach und natürlich habe ich das „ewige Argument der Slawen untereinander“ gelöst, welches Ende bequemer ist, um ein Ei zu zerbrechen).

Mit dieser Interpretation eines Satzes von Bits der Länge n (= 8) erhalten wir eine Darstellung für Zahlen von 0 bis (2 ^ n) -1 (= 255) (im Folgenden wird in Klammern ein spezifischer Wert für einen Satz von 8 Bits angegeben), der eine bemerkenswerte Anzahl aufweist und nützliche Eigenschaften, weshalb es weit verbreitet ist. Leider hat es auch eine Reihe von Nachteilen, von denen einer darin besteht, dass wir in einem solchen Datensatz im Prinzip keine negativen Zahlen darstellen können.

Sie können eine Vielzahl von Lösungen für dieses Problem anbieten (die Darstellung negativer Zahlen), von denen es auch praktische Bedeutung gibt. Sie sind unten aufgeführt.

Eine Darstellung mit einem Versatz wird durch die Formel H = N2 (n) - Versatz (C) beschrieben, wobei N2 die in binärer Notation mit n Bits erhaltene Zahl ist und C ein vorgewählter Wert ist. Dann stellen wir Zahlen von 0-C bis 2 ^ (n) -1-C dar, und wenn wir C = 2 ^ (n-1) -1 (= 127) wählen (dies ist völlig optional, aber sehr praktisch), dann wir erhalten den Bereich von 0- (2 ^ (n-1) -1) (= - 127) bis 2 ^ (n-1) (= 128). Der Hauptvorteil dieser Darstellung ist die Monotonie (darüber hinaus Zunahme) über das gesamte Intervall. Es gibt auch Nachteile, unter denen wir die Asymmetrie hervorheben (es gibt andere, die mit der Komplexität der Durchführung von Operationen an der Zahl in dieser Darstellung zusammenhängen), aber die Entwickler des IEEE 457-Standards (dies ist der Standard für) PT) hat diesen Fehler in eine Tugend verwandelt (indem ein zusätzlicher Wert verwendet wurde, um die Situation nan zu kodieren), was erneut die Treue des coolen Sprichworts unterstreicht: „Wenn Sie höher als der Gegner sind, dann ist dies Ihr Vorteil. Wenn der Gegner größer ist als Sie, ist dies auch Ihr Vorteil. “

Da die Gesamtzahl der möglichen Kombinationen einer beliebigen Anzahl von Bits gerade ist (wenn Sie keine aus religiösen Gründen verbotenen Kombinationen haben), ist die Symmetrie zwischen positiven und negativen darstellbaren Zahlen grundsätzlich nicht erreichbar (oder vielmehr erreichbar, aber unter bestimmten zusätzlichen Bedingungen, über die mehr) .

Darstellung in Form eines direkten Codes, wenn eines der Bits (höchstwertig) das codierte Vorzeichen der Zahl H = (-1) ^ B (n-1) * P2 (n-1) darstellt, hat einen Bereich von 0- (2 ^ (n-1) -1) (= -127) bis 2 ^ (n-1) -1 (= 127). Es ist interessant festzustellen, dass ich gerade die grundsätzliche Unmöglichkeit der Symmetrie erklärt habe, und hier ist es klar: Die maximal darstellbare positive Zahl ist gleich dem Modul der minimal darstellbaren negativen Zahl. Dieses Ergebnis wird durch zwei Darstellungen für Null (00 ... 00 und 10 ... 00) erreicht, was normalerweise als Hauptnachteil dieser Methode angesehen wird. Dies ist wirklich ein Nachteil, aber nicht so schrecklich, wie allgemein angenommen wird, da es bedeutendere gibt, die seine Verwendung einschränken.

Die inverse Codedarstellung, wenn wir in der direkten Darstellung alle Bits des Wertes für negative Zahlen H = (1-B (n-1)) * P2 (n-1) + B (n-1) * (2 ^ (n) invertieren -1) -CH2 (n-1)) - dies ist aus der Definition, Sie können eine viel verständlichere Formel machen H = Ch2 (n-1) -B (n-1) * (2 ^ (n-1) -1), Dies erlaubt uns, Zahlen von 0-2 ^ (n-1) +1 (= - 127) bis 2 ^ (n-1) -1 (= 127) darzustellen. Es ist ersichtlich, dass diese Darstellung verschoben ist, aber die Verschiebung sich schrittweise ändert, was diese Darstellung nicht monoton macht. Wieder haben wir zwei Nullen, was nicht sehr beängstigend ist. Das Auftreten einer zirkulären Übertragung während der Addition ist viel schlimmer, was bestimmte Probleme bei der Implementierung von ALU verursacht.

Um den letzten Nachteil der vorherigen Darstellung zu beseitigen, ist es ungewöhnlich einfach, den Versatz um eins zu ändern. Dann erhalten wir = = 22 (n-1) -B (n-1) * 2 ^ (n-1) und können Zahlen von 0-2 ^ ( n-1) (= - 128) bis 2 ^ (n-1) -1 (= 127). Es ist leicht zu erkennen, dass die Darstellung asymmetrisch ist, aber Null ist eindeutig. Wesentlich interessanter ist die folgende Eigenschaft: "Es ist völlig offensichtlich, dass" keine Ringübertragung für eine Operation vom Additionstyp auftritt, was (zusammen mit anderen angenehmen Merkmalen) der Grund für die universelle Verteilung dieser speziellen Methode zum Codieren negativer Zahlen ist.

Lassen Sie uns eine Tabelle mit interessanten Werten für verschiedene Methoden zur Codierung von Zahlen erstellen, die mit H den Wert 2 ^ (n-1) (128) bezeichnen.

Bits	00..00	11/01	10..00	11.11
H (n)	0	H-1 (127)	H (128)	2 * H-1 (255)
H (n-1)	0	H-1 (127)	0	H-1 (127)
Offset. N.	-H + 1 (-127)	0	1	H (128)
Direkt	0	H-1 (127)	0	-H + 1 (-127)
Umkehren	0	H-1 (127)	-H + 1 (-127)	0
Ergänzung	0	H-1 (127)	-H (-128)	-1

Zum Abschluss des Themas geben wir Grafiken für die aufgelisteten Darstellungen, aus denen ihre Vor- und Nachteile sofort ersichtlich sind (natürlich erinnert nicht alles, was einen an das interessante Sprichwort erinnert: „Der Vorteil der grafischen Darstellung von Informationen ist visuell, es hat keine anderen Vorteile“).

Teil 4 - Das ursprüngliche Problem tatsächlich lösen (besser spät als nie).

Kleiner Exkurs

Zunächst wollte ich den PT im Hexadezimalformat drucken (und letztendlich habe ich es getan), aber ganz unerwartet / völlig unerwartet (ich musste ihn ersetzen) stieß ich auf das folgende Ergebnis. Was wird Ihrer Meinung nach als Ergebnis der Ausführung der Operatoren gedruckt:

 printf("%f %x", 1.0,1.0); printf("%f %x",2.0,2.0); printf("%x %d",1.0,1.0); printf("%x %d",2.0,2.0); 

Beachten Sie auch die folgende Konstruktion und deren Ergebnis:

 printf("%x %x %f",1.0,1.0); 

Ich werde dieses Phänomen nicht erklären, "klug genug".

Wie drucken wir jedoch die hexadezimale Darstellung von PT korrekt? Die erste Lösung liegt auf der Hand - Vereinigung, die zweite ist jedoch für einzeilige Fans printf ("% x", * ((int *) (& f))); (Ich entschuldige mich, wenn jemand durch zusätzliche Klammern beleidigt wurde, aber ich konnte und wollte mich nie an die Prioritäten von Operationen erinnern, insbesondere wenn man bedenkt, dass die Klammern keinen Code generieren, also werde ich das Gleiche tun). Und hier ist die Lösung der Aufgabe: Wir sehen eine Zeichenfolge, 0x45678, die die gewünschte Nummer für uns eindeutig bestimmt, aber so, dass wir (ich weiß definitiv nichts über Sie) nichts Verständliches über diese Nummer sagen können. Ich denke, dass der Akademiker Karnal, der auf einen Fehler im Lochband mit dem Quellcode hätte hinweisen können, sich mit dieser Aufgabe befasst hätte, aber nicht jeder ist so weit fortgeschritten, also werden wir fortfahren.

Wir werden versuchen, Informationen in verständlicherer Form zu erhalten.

Dazu kehren wir zum Format des PT zurück (im Folgenden betrachte ich nur float), bei dem es sich um eine Menge von Bits handelt, aus denen Sie (nach bestimmten Regeln) drei Sätze von Bits extrahieren können, um drei Zahlen darzustellen - Vorzeichen, Mantisse (m) und Reihenfolge (p) und die gewünschte Zahl, die durch diese Zahlen codiert wird, wird durch die folgende Formel bestimmt: Cs * Chm * Chn. Hier bezeichnen die Symbole die Zahlen, die durch den entsprechenden Satz von Bits dargestellt werden. Um die gewünschte Zahl zu finden, müssen wir daher die Gesetze kennen, nach denen wir diese drei Sätze aus dem ursprünglichen Satz von Bits extrahieren, sowie die Art der Codierung für jeden von ihnen.

Bei der Lösung dieses Problems wenden wir uns dem IEEE-Standard zu und stellen fest, dass das Vorzeichen ein (älteres) Bit der ursprünglichen Menge und der Formel für die Codierung von Cs = (- 1) ^ B (0) ist. Die Reihenfolge belegt die nächsten 8 hohen Bits, wird in Code mit einem Versatz von 127 geschrieben und stellt eine Zweierpotenz dar, dann ist Cn = 2 ^ (C2 (8) -127). Mantisse nimmt die nächste Reihenfolge von 23 Stellen an und repräsentiert die Zahl Chm = 1 + Ch2 (23) / 2 ^ 23.

Jetzt haben wir alle notwendigen Daten und können die Aufgabe vollständig lösen - eine Zeichenfolge mit Zeichen zu erstellen, die bei einer bestimmten Lesart eine Zahl darstellt, die der codierten entspricht. Dazu sollten wir durch einfache Operationen die obigen Zahlen extrahieren und sie dann ausdrucken und die erforderlichen Attribute bereitstellen. Wir gehen davon aus, dass wir eine Ganzzahl mit nicht mehr als 32 Bit in eine Zeichenfolge konvertieren können, dann ist dies völlig unkompliziert.

Leider stehen wir erst am Anfang der Reise, da nur wenige Leser dieses Beitrags im Datensatz „+ 1.625 * 2 ^ 3“ die unglückliche Zahl erkennen, die durch die häufigere Dezimalstelle „13“ codiert wird, und im Datensatz „1.953125 * 2“ raten ^ 9 “die einfachen" 1E3 "oder" 1 * 10 ^ 3 "oder die sehr vertrauten" 1000 "sind in der Lage, Einheiten von Menschen im Allgemeinen, ich gehöre definitiv nicht zu ihnen. Es ist seltsam, wie es passiert ist, denn wir haben die erste Aufgabe abgeschlossen, die erneut zeigt, wie sorgfältig Sie die Formulierungen behandeln sollten. Und der Punkt ist nicht, dass die Dezimalschreibweise besser oder schlechter ist als die Binärschreibweise (in diesem Fall basiert Deuce auf dem Grad), sondern dass wir es gewohnt sind, seit der Kindheit zu dezimalisieren und Menschen neu zu erstellen, viel schwieriger als das Programm, also werden wir unsere geben Eintritt in das Vertraute.

Aus mathematischer Sicht haben wir eine einfache Operation - es gibt einen Datensatz PT = (- 1) ^ s * m * 2 ^ n, und wir müssen ihn in die Form PT = (-1) s '* m' * 10 ^ n 'konvertieren. Wir setzen die Lösungen s '= s', m '= m, n' = n * log (2) gleich, transformieren und erhalten (eine der möglichen Optionen). Wenn wir die Klammern weglassen, dass mit einer explizit irrationalen Zahl multipliziert werden muss (dies kann geschehen, wenn die Zahl rationalisiert ist, aber wir werden später darüber sprechen), scheint das Problem gelöst zu sein, bis wir die Antwort sehen, denn wenn der Datensatz „+1.953125“ lautet * 2 ^ 9 "scheint uns dunkel, der Rekord" + 1.953125 * 10 ^ 2.70927 "ist noch weniger akzeptabel, obwohl es anscheinend nirgendwo schlimmer war.

— 10 '= * 10^{ * lg(2)}, '= [ * lg(2)], . (1.953125*10^0.7 0927)*10^2=«10*10^2», , , .

, :

1. () (lg(2)) ( );
2. ( );
3. (10) (...);
4. (« , ...»).

, , , 1. , * lg(2), «» , =0 ( =/lg(10)). , « », « ». . , , ' = * lg(2) * [lg(2) *256 + 1/2] / 256 , 1/2/77 = 1/144, , 1/100. — , . [4.501]=5, [4.499]=4 , , 0.002/4.5=0.04%, 1/4=25%. , , . , , , , , , .

'=*77/256

, . 24 , 2^-24=2^-4*2^-20=16^-1*(2^10)^-2~(10)^-1*(10^3)^-2=10^-7, 7 . 24 ( ). , 32 ( ) , 100 (256) , .



' = * 10^{ * lg(2)}

— 1) , 2) , , , , , . — , , , .

« , , »

q(10^x) = Δ(10^x)/10^x = (10^(x +Δx) — 10^x)/10^x = 10^Δx -1 = 10^(x*qx)-1,
10^(x*qx) >~ 10^(x*0) + (10^(x*0))'*qx = 1 + x*ln(10)*10^(0)*qx = 1+x*ln(10)*qx,

$$

$$q(10^x) = x*ln(10)*qx.$$

— , , =127, 292 , , .

, 24 32 ( , ), , (*lg(2)) 32 , , 1'292'914'005/2^32. , , (int)((lg(2)*float(2^32))+0.5), 04d104d42, , .

, , , , .
10 0 1 . , , , , , ''=lg(2)*i+(''-lg(2)*i), 2 , ( ), lg(2) 10^'' ( ).

, lg(2) , , . , , , , 10-7 9 , 1+9*2=19 32- , . '=*lg(2) , .

32- 1+19+1=21

— , — , . , — ( ) , , .

— — (2^8=256) ['] ( 10) {'} ( ), . — =*2^=*10^'*(2^/10^')=(*(2^/10^'))*10^'.

256*3 ( 24 , ) + 256*1 ( 10 2) = 1 . 24*24 ( 32*32), .

, ( , ). , , ( 256 10) . , ,

2^-/10^-' = 1/(2^/10^') != 2^/10^',

. , . , — 18 , , , , 512 . — , , , , .

- , ( ) . ( )

=*2^=*2^(0+1)=*10^'*(2^(0+1)/10^')=*(2^0/10^')*2^1*10^',

0- , 1=-0. , .

— , 0 ? , — 10 . — 32*32, 24 , 8 8 . 256/8*4=32*4=128 — 8 .

0, , 32/2=16 , , ( ) .

, adafruit

 const UINT8 Bits[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; ... data = data | Bits[n]; 

, 1 << n AVR . , , .

, , , ( godbolt, , , ) , .

( , 1 )

  ldi r18,lo8(4) sbrs r25,1 ldi r18,lo8(1) sbrc r25,0 lsl r18 sbrs r25,2 swap r18 

, , 8:7 8 (, , 16 — — « , , , »). — , : « „ 12 “ (» ", , ).



= * 2^=( * [/8]) * 2^(%8) * 10^[/8],

- - . , 32*32(24*24) . 32 10 , ( , ) .

— ,

const uint32_t Data[32] PROGMEM = { 0xF82345,… }

, , , . , , , ( )

 #define POWROUD(pow) ((uint8_t)((pow & 0x07)*log(2)+0.5)) #define MULT(pow) (2^pow / 10^POWROUND(pow)) #define MULTRAW(pow) (uint32_t((MULT(pow) << 24) +0.5)) #define BYTEMASK 0xFF #define POWDATA(pow) ((POWROUND(pow) & BYTEMASK)| (MULTRAW(pow) & (~BYTEMASK))) const uint32_t Data[(BYTEMASK/8)+1] = { POWDATA(0x00),POWDATA(0x08), ..POWDATA(0xF8)} 

, , , .

, , , , . . :

1.953125*2^9=1.953125*2^(8+1)=1.953125*42949673/256/256/256(2.56)*2*10^2=10*10^2

1000. , , , , , , , .