mal ein beispiel:
ich habe ein WORD, indem bit 4 und bit 8 gesetzt sind... (beim ersten word also bspw Zustand 5 und 9 der maschine)
also 2^4+2^8=272 als integerwert
wenn man sich den dualen logarithmus davon ausrechnet kommt wie zu erwarten immer der größeren der beiden exponenten raus... also 8,087...
wenn man den teil nach dem komma auswertet, weiß man, ob es mehrere gesetzte bits gibt, der teil vor dem komma gibt (innerhalb des wortes) das höchstwertigste gesetzte bit an.
müsste ich dann nicht, um das nächste gesetzte bit zu finden, eine 1 in den akku laden, diese in einer schleife so oft, wie der gefundene größte exponent war, nach links verschieben (SLW akzeptiert keine variable), dann das ursprungs-WORD XOR mit akku 1 verknüpfen bzw subtrahieren und dann das ganze nochmal machen, solange der Nachkommateil des exponenten nicht 0 ist, es also noch weitere gesetzte bits gibt?
alternativ könnte man den gefundenen größten exponenten natürlich auch auf nen pointer addieren, der auf einen vergleichsinteger zeigt und das bit dann 0 setzen... kann ich gerade nicht abschätzen, was günstiger ist.
---------------------------------
habe mir mal das Real-format angeschaut...
wenn 1 bit gesetzt ist, habe ich also immer eine mantisse von 1
ich müsste demnach nicht den exponenten, sondern die mantisse überprüfen, ob sie glatt 1 ist
aber das problem bleibt doch: wie berechne ich weitere bits, wenn die mantisse ungleich 1 ist?
das höchste gesetzte bit ist immernoch das was im exponenten steht, aber den rest muss ich ja trotzdem gesondert behandeln
mal zurück zum beispiel von vorhin: 2^4+2^8=272
wenn ich jetzt 272 in eine real-zahl wandle, bekomme ich vermutlich 1,0625*2^8 als real-zahl, wenn ich den datentyp richtig verstanden habe
ich müsste doch also 2^8 von den 272 abziehen und dann das ganze nochmal machen, oder? und zwar solange, bis meine mantisse mal 1,0 wäre bzw ich alle gesetzten bits in dem wort gefunden habe
so langsam bekomme ich auch zweifel, ob der ursprüngliche ansatz so schlecht war... denn ich bekomme hier ja wieder die verschachtelte schleife aus post #2, nur dass die innere schleife hier mit den exponenten rumrechnet, statt bitweise zu prüfen
bitte korrigier mich, wenn ich mich irre...
LG
P.S.:
wie sieht eigentlich 0.0 als REAL-Zahl aus?
da man die Vorkommastelle nicht beeinflussen kann, wäre das ja 1,X*2^Y
1,X kann nicht 0 werden, 2^Y kann auch nicht 0 werden... mhhhh
------------------------------------------
habs mal schnell zusammengetippert:
über Exponenten auswerten:
(nur der
rot markierte teil hat sich geändert)
Code:
TAR1 #AR1Merker
TAR2 #AR2Merker
//IN nach TEMP
L #QuellDB //IN-Var... DB-Nummer Quelle
T #QDB //TEMP-Var... DB-Nummer Quelle
L #ZielDB //IN-Var... DB-Nummer Ziel
T #ZDB //TEMP-Var... DB-Nummer Ziel
// --- initialisieren ---
//Zaehler/Merker initialisieren
L 0
T #GefundeneZst
//Offset der aeusseren Schleife 0 setzen
L 0
T #OffsetAussen
//Zst-Ints im Ziel-DB 0 setzen
AUF DB [#ZDB]
L #ZielAnfang //IN-Var... Byteposition des ersten Zst-Ints im Ziel-DB
SLD 3
LAR1
L #AnzahlInteger
nw1a: T #SchleifeInnen
L 0
T W [AR1,P#0.0]
+AR1 P#2.0
L #SchleifeInnen
LOOP nw1a
// --- Pruefschleifen ---
//*** Pruefschleife aussen: testet je 16 bits, ob überhaupt eins davon gesetzt ist ***
L #HoechsterZustand //Anzahl Bits
SRW 4
+ 1 //Anzahl Woerter
nw1b: T #SchleifeAussen
AUF DB [#QDB]
L #OffsetAussen //Anzahl gepruefter Bytes
L #QuellAnfang
+I
SLD 3
T #QPointer //Pointer auf aktuell zu testenden Quellbereich
LAR1
L W [AR1,P#0.0]
L 0
==I
SPB nw1e //wenn kein bit true ist, muss man auch nicht schauen, welches true ist
[COLOR=red]//***Innere Schleife***[/COLOR]
[COLOR=red]//hoechstes gesetztes Bit ermitteln[/COLOR]
[COLOR=red] L W [AR1,P#0.0] //das gerade zu pruefende WORD[/COLOR]
[COLOR=red]nw1c: T #WORDMerker //gemerkt (noetig bei mehreren Durchlaeufen)[/COLOR]
[COLOR=red] DTR //als REAL[/COLOR]
[COLOR=red] T #REALMerker //merken[/COLOR]
[COLOR=red] SLD //Vorzeichen weg[/COLOR]
[COLOR=red] SRD 24 //bleibt nur noch der Exponent bzw das hoechste gesetzte bit[/COLOR]
[COLOR=red] T #Exponent[/COLOR]
[COLOR=red]//noch weitere Bits gesetzt?[/COLOR]
[COLOR=red] L #REALMerker //REAL wieder Laden[/COLOR]
[COLOR=red] SLD 9 //Vorzeichen und Exponent weg... [/COLOR]
[COLOR=red] SRD 9 //bleiben noch 23 Bit Nachkommastelle der Mantisse[/COLOR]
[COLOR=red] L 0[/COLOR]
[COLOR=red] ==D //wenn Nachkommastellen ==0 wurde das letzte gesetzte Bit gefunden[/COLOR]
[COLOR=red] = #MerkerLetzteStelle[/COLOR]
[COLOR=red]//Zielposition im Ziel-DB laden[/COLOR]
[COLOR=red] AUF DB [#ZDB][/COLOR]
[COLOR=red] L #GefundeneZst //Anzahl gefundener Zustaende[/COLOR]
[COLOR=red] SLD //*2 um 2 Bytes bzw 1 Int weiterzuspringen[/COLOR]
[COLOR=red] L #ZielAnfang //IN-Var... Byteposition des ersten Zst-Ints im Ziel-DB[/COLOR]
[COLOR=red] +D //im akku 1 steht die Byte-Nummer des Ints, in das der Zustand gespeichert wird[/COLOR]
[COLOR=red] SLD 3[/COLOR]
[COLOR=red] LAR1 [/COLOR]
[COLOR=red]//gefundenen Zustand abspeichern[/COLOR]
[COLOR=red] L #OffsetAussen //Anzahl durchsuchter Bytes[/COLOR]
[COLOR=red] SLW 3 //Anzahl durchsuchter Bits[/COLOR]
[COLOR=red] L #Exponent //Position innerhalb des aktuell durchsuchten Wortes[/COLOR]
[COLOR=red] +I [/COLOR]
[COLOR=red] + 1 //Nummer des dem Bit zugewiesenen Zustands[/COLOR]
[COLOR=red] T W [AR1,P#0.0][/COLOR]
[COLOR=red]//Zaehler erhoehen[/COLOR]
[COLOR=red] L #GefundeneZst[/COLOR]
[COLOR=red] + 1[/COLOR]
[COLOR=red] T #GefundeneZst[/COLOR]
[COLOR=red]//Abbruchbedingung: speicherplatz fuer Zustandsnummern ist voll[/COLOR]
[COLOR=red] L #GefundeneZst[/COLOR]
[COLOR=red] L #AnzahlInteger //IN-Var... Vorgabe der maximal gleichzeitig gesetzten Zst bzw die Anzahl Speicherplaetze[/COLOR]
[COLOR=red] ==I [/COLOR]
[COLOR=red] BEB [/COLOR]
[COLOR=red]// ggf. das gefundene Bit vom zu pruefenden WORD abziehen und die ganze Show nochmal[/COLOR]
[COLOR=red] SET [/COLOR]
[COLOR=red] U #MerkerLetzteStelle[/COLOR]
[COLOR=red] SPB nw1e //Innere Schleife verlassen[/COLOR]
[COLOR=red]//wenns noch ein weiteres gesetztes bit gibt:[/COLOR]
[COLOR=red] SET //VKE auf 1[/COLOR]
[COLOR=red] L P##WORDMerker[/COLOR]
[COLOR=red] L #Exponent[/COLOR]
[COLOR=red] +D [/COLOR]
[COLOR=red] LAR1 [/COLOR]
[COLOR=red] R [AR1,P#0.0] //Das gefundene Bit wird zurueckgesetzt[/COLOR]
[COLOR=red] L #WORDMerker[/COLOR]
[COLOR=red] SPA nw1c //und nochn Durchlauf der inneren Schleife[/COLOR]
[COLOR=red]//Ende innere Schleife[/COLOR]
//Ende aeussere Schleife
nw1e: L #OffsetAussen
+ 2
T #OffsetAussen //Anzahl durchsuchter Bytes um 2 erhoehen
L #SchleifeAussen
LOOP nw1b
LAR1 #AR1Merker
LAR2 #AR2Merker
