Algorithmus für's Zahlen zerlegen

Anonym_58cc8ab8c27e · 1. September 2006 um 10:48

Hallo,

ich versuche nun schon seit einigen Wochen dieses Problem zu lösen und sehe langsam nur noch Zahlen. Vielleicht könnt ihr mir ja helfen.

Eine Zahl wird in vier einzelne Teile zerlegt, die wiederum im Bereich von 0 bis 255 liegen.
Ich möchte nun einen Algorithmus finden der anhand dieser vier Einzelzahlen die dazu gehörige Zahl berechnet und umgekehrt.

Hiermal ein paar Bsp.:

Zahl; n1; n2; n3; n4

0,000000; 0; 0; 0; 0
0,100000; 205; 204; 204; 61
0,125000; 0; 0; 0; 62
0,200000; 205; 204; 76; 62
0,250000; 0; 0; 128; 62
0,300000; 154; 153; 153; 62
0,400000; 205; 204; 204; 62
0,500000; 0; 0; 0; 63
0,600000; 154; 153; 25; 63
0,700000; 51; 51; 51; 63
0,800000; 205; 204; 76; 63
0,900000; 102; 102; 102; 63
1,000000; 0; 0; 128; 63
2,000000; 0; 0; 0; 64
3,000000; 0; 0; 64; 64
4,000000; 0; 0; 128; 64
5,000000; 0; 0; 160; 64
6,000000; 0; 0; 192; 64
7,000000; 0; 0; 224; 64
8,000000; 0; 0; 0; 65
9,000000; 0; 0; 16; 65
10,00000; 0; 0; 32; 65
11,00000; 0; 0; 48; 65
12,00000; 0; 0; 64; 65

30,00000; 0; 0; 240; 65
31,00000; 0; 0; 248; 65
32,00000; 0; 0; 0; 66
33,00000; 0; 0; 4; 66
34,00000; 0; 0; 8; 66

126,0000; 0; 0; 252; 66
127,0000; 0; 0; 254; 66
128,0000; 0; 0; 0; 67
129,0000; 0; 0; 1; 67
130,0000; 0; 0; 2; 67

255,0000; 0; 0; 127; 67
256,0000; 0; 0; 128; 67
257,0000; 0; 128; 128; 67
258,0000; 0; 0; 129; 67
259,0000; 0; 128; 129; 67

510,0000; 0; 0; 255; 67
511,0000; 0; 128; 255; 67
512,0000; 0; 0; 0; 68
513,0000; 0; 64; 0; 68
514,0000; 0; 128; 0; 68

1022,000; 0; 128; 127; 68
1023,000; 0; 192; 127; 68
1024,000; 0; 0; 128; 68
1025,000; 0; 32; 128; 68
1026,000; 0; 64; 128; 68

2048,000; 0; 0; 0; 69
4096,000; 0; 0; 128; 69
8192,000; 0; 0; 0; 70
16384,00; 0; 0; 128; 70
32768,00; 0; 0; 0; 71
65536,00; 0; 0; 128; 71

33554432; 0; 0; 0; 76
67108864; 0; 0; 128; 76
99999999; 32; 188; 190; 76

Ich bin bis jetzt soweit gekommen, das ich folgendes berechnen kann:
-für alle Zahlen wo n1=0; n2=0; n3=0 -> Zahl = 4^(n4-64)*2
-für alle Zahlen wo n1=0; n2=0; n3 Zahl = n3/128 * 4^(n4-64)*2 + 4^(n4-64)*2
-für alle Zahlen wo n1=0; n2=0; n3>=128 -> Zahl = n3/64 * 4^(n4-64)*2

Bin für jeden Hinweis dankbar.
Gruß ZahlenKlaus

Anonym · 1. September 2006 um 12:26

Hallo,

Eine Zahl wird in vier einzelne Teile zerlegt, die wiederum im
Bereich von 0 bis 255 liegen.

Welche Zahlen kommen für die zerlegte zahl in Frage? Nach welcher Regel wird sie zerlegt? Besteht das Problem grade darin, diese Regel zu finden?
Gruß
loderunner

Anonym_58cc8ab8c27e · 1. September 2006 um 12:39

Servus,

genau das ist das Problem, ich weiß nicht nach welcher Regel die Zahl zerlegt wird. Ich hab nur die Zahl zur Verfügung und die vier Einzelzahlen die die Zahl nach irgendeinem Algorithmus beschreiben. In meiner Bsp. Tabelle beginnt jede Zeile mit der Zahl die zerlegt wird und danach kommen, durch Semikolon getrennt, die vier Zahlen (n1;n2;n3;n4) die die zerlegte Zahl nach dem von mir gesuchten Algorithmus beschreiben. Hoffe mal ich hab mein eigentliches Problem nicht noch komplizierter ausgedrückt.

Gruß ZahlenKlaus

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Anonym · 1. September 2006 um 13:31

Hallo,
schreib Dir doch die Zahlen mal als Binärform und als hexadezimalzahlen auf. Und dann schau, welche Stellen sich wann ändern. Mir fällt z.B. der Übergang 511,0->512,0 entspr. 67->68 auf.
Berücksichtige auch, dass auch die Position des Kommas irgendendwo enthalten sein muss. Dazu müsstest Du mal 1024 mit 10,24 und 102,4 vergleichen.
Wie groß ist denn Deine Beispieltabelle? Sind vielleicht sogar alle zahlen vorhanden? Und wozu wird der Algorithmus benötigt? Hausaufgabe? Mathetest? Intelligenztest? Rätsel?
Gruß
loderunner

Jo1_a88223 · 1. September 2006 um 14:11

Hallo,

ich habe eine Vermutung:

n4 ist ein Maß für die Position des Kommas in der Binärzahl.

n1 - n3 codieren je 8 Stellen der Bitfolge. Um die gesamte Bitfolge zu bekommen, müssen die 8-stelligen(! evtl. mit führenden Nullen!) Binärwerte aneinandergereiht werden, und zwar in der Reihenfolge n3,n2,n1.

Die Verschiebung dieser Bitfolge ergibt sich dann aus n4.

Beispiel für die Zahl 0.4:
Binärcode: 0,0110011001100110011001100110011001100110011…

n3 n2 n1
204 204 205
11001100 11001100 11001101

zusammengesetzter Binärcode: 110011001100110011001101
mit Verschiebung um +2 Dezimalstellen: 0,0110011001100110011001101
ergibt dezimal 0.400000…

Der Wert von n4=62 würde dann eine Verschiebung von +2 Dezimalstellen bedeuten.

So ungefähr haut das auch für die anderen zahlen hin: die Bitfolge ist immer in der Binärdarstellung der Zahl zu finden, allerdings ist das mit der Verschiebung nicht ganz so systematisch und machmal startet die Folge auch erst hinter bereits gesetzten Bits (zB. für 0.6 und 0.7). Außerdem kann ich die „glatten 4er“ (0.125, 0.5, 2,…) noch nicht erklären. Ich denke aber, die Lösung für beide Probleme liegt in der Interpretation von n4 (vielleicht steht ein Nibbel für die Verschiebung und ein anderes für etwas anderes).

LG
Jochen

Anonym_58cc8ab8c27e · 1. September 2006 um 15:07

Servus,

… is nix von alldem, das sind Zahlen die jeweils den Wert für eine Konstante beschreiben, die für die Maschinensteuerung einer Maschine bei mir auf Arbeit benötigt wird. Also zB. 2psi Druck auf Schlauch Nr. so und so oder zB. 3750 U/min ist die Drehzahl von Motor xyz. Diese Konstanten werden nach gesuchten Algorithmus zerlegt und in diesen 4er-Blöcken in einem Config-File abgelegt. Während diverser Wartungsarbeiten an diesen Maschinen, muss ich einige Konstanten verstellen und nach getaner Arbeit wieder zurücksetzen, was natürlich manchmal vergessen wird. Desterwegen möchte ich ein Programm schreiben, welches diese Konstanten überwacht und mir meldet wenn sie vom Wert her anders sind als sie sollen.
Die Konstanten kann ich direkt in der Maschinensteuerung ändern, und dann schaue ich mir die Änderung mit nem Hex-Editor direkt im Config-File an. Ich kann also jede mögliche Kombination von Zahlen liefern.

1,024 = hex: 6F 12 83 3F dez: 111; 18; 131; 63
10,24 = hex: 0A D7 23 41 dez: 10; 215; 35; 65
102,4 = hex: CD CC CC 42 dez: 205; 204; 204; 66
1024 = hex: 00 00 80 44 dez: 0; 0; 128; 68

Gruß ZahlenKlaus

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Semjon_Michailowitsch_580bb3 · 1. September 2006 um 15:19

Hallo ZahlenKlaus:

ich versuche nun schon seit einigen Wochen dieses Problem zu
lösen und sehe langsam nur noch Zahlen. Vielleicht könnt ihr
mir ja helfen.

Ist sehr simpel. Hätt’ste mal im Programmiererforum
gepostet, Antwort innerhalb 10 min

#include <u>float</u> tabelle[] = {
 0.000000, 
 0.100000,
 0.125000,

 33554432, 
 67108864, 
 99999999 
};

 int main()
{
 int i, n=sizeof(tabelle) / sizeof(float);
 <u>float</u>\* **fp** =tabelle;
 <u>unsigned int</u>\* **ip** ;

 for(i=0; iip = (unsigned int \*)fp;
 printf("%f, %d %d %d %d \n", \*fp, 
 ( **\*ip** \>\> 0) & 0xff, 
 ( **\*ip** \>\> 8) & 0xff,
 ( **\*ip** \>\>16) & 0xff,
 ( **\*ip** \>\>24) & 0xff);
 }
 return 0;
}

So kommen die „4-er-Gruppen“ zustande.
Alles klaro?

Grüße

CMБ

Anonym_58cc8ab8c27e · 1. September 2006 um 15:36

Servus,

… alles klaro wäre schön, das einzige was ich an Programmiersprachen halbwegs verstehe is VB, das was du hier geschrieben hast versteh’ ich leider nicht. Kannst’ du mir das mathematisch ein wenig näher erklären, so das ich das in VB-Code umsetzen kann?

Danke & Grüße
ZahlenKlaus

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Semjon_Michailowitsch_580bb3 · 1. September 2006 um 15:41

Hallo ZahlenKlaus

… alles klaro wäre schön, das einzige was ich an
Programmiersprachen halbwegs verstehe is VB, das was du hier
geschrieben hast versteh’ ich leider nicht. Kannst’ du mir das
mathematisch ein wenig näher erklären, so das ich das in
VB-Code umsetzen kann?

Die vier Zahlen als Bytes einfach aneinanderhängen

 [n1][n2][n3][n4]

und die 32-bit Integer-Zahl als 32bit Float-Zahl
interpretieren.

Grüße

CMБ

Anonym_58cc8ab8c27e · 1. September 2006 um 16:59

Hallo,

ich muss diesbezüglich nochmal nerven, weil ich versteh heut’ nur noch Bahnhof. Versuch mir das mal bitte an einem Bsp. zu erklären, denk mal dann versteh’ ich’s auch endlich mal.

Die Zahl 17,173 wird dargestellt hex: 4E 62 89 41 bzw. dec: 78; 98; 137; 65.
Wie komm ich nun rechnerisch von dem 4er-Paar wieder auf 17,173 ?

Danke & Grüße
ZahlenKlaus

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

Semjon_Michailowitsch_580bb3 · 2. September 2006 um 00:19

Hallo Klaus,

ich muss diesbezüglich nochmal nerven, weil ich versteh heut’
nur noch Bahnhof. Versuch mir das mal bitte an einem Bsp. zu
erklären, denk mal dann versteh’ ich’s auch endlich mal.

Das ist so simpel dass es schon schreit. Es ist lediglich
so, dass die selben 4 Bytes (hintereinander) jeweils
einmal als ‚single precision floating point‘ (IEEE single)
und einmal als 4 Bytes angesehen werden.

Die Zahl 17,173 wird dargestellt
hex: 4E 62 89 41 bzw. dec: 78; 98; 137; 65.
Wie komm ich nun rechnerisch von dem 4er-Paar wieder auf
17,173 ?

Indem Du eine ‚leere‘ Gleitkommazahl (4 Byte, single)
nimmst (DIM Wert AS SINGLE) und dort hinein
diese 4 Zahlen (als Bytes) schreibst - und dann hast
Du den Wert in der Variable stehen, wenn Du sie
als Single-Gleitkommawert (USING #.########) ausgibst.

Ich hab mal mein altes Power-Basic (3) ausgegraben,
da geht das so:

DIM By?(4) ' 4 Zahlen (bytes)

Wert! = 0.0 ' hier schreiben wir rein
Addr& = VARPTR(Wert!) ' Adresse dieser Zahl

FOR i% = 1 to 12 ' wir haben 12 DATA Zeilen unten,
 FOR k% = 1 to 4 : ' 4 Zahlen in byte-Arrays lesen
 READ By?(k%)
 POKE Addr&+k%-1, By?(k%) ' byte-Wert in Gleitkommawert
 NEXT k% ' reinschreiben (in Speicher)

**PRINT USING "#.######; "; Wert!** ; ' <u>Ausgabe float-Zahl</u>
 PRINT By?(1); By?(2); By?(3); By?(4) ' Ausgabe 4 byte-Werte
NEXT i%
END

DATA 0, 0, 0, 0
DATA 205, 204, 204, 61
DATA 0, 0, 0, 62
DATA 205, 204, 76, 62
DATA 0, 0, 128, 62
DATA 154, 153, 153, 62
DATA 205, 204, 204, 62
DATA 0, 0, 0, 63
DATA 154, 153, 25, 63
DATA 51, 51, 51, 63
DATA 205, 204, 76, 63
DATA 102, 102, 102, 63

Grüße

CMБ

Anonym · 2. September 2006 um 09:46

Anmerkung
Hallo,

und hier:
http://de.wikipedia.org/wiki/IEEE_754
findet man die Zusammenhänge. Besonders das bunte Bildchen mit der Darstellung der Bits ist deutlich.

Da hätte man auch früher drauf kommen können, wenn man nur genauer gewußt hätte, was das Problem ist.

Gruß
loderunner

Semjon_Michailowitsch_580bb3 · 2. September 2006 um 14:57

Hallo loderunner,

und hier: http://de.wikipedia.org/wiki/IEEE_754
findet man die Zusammenhänge. Besonders das bunte
Bildchen mit der Darstellung der Bits ist deutlich.

Genau.

Deshalb gehört das Topic in die Programmiererei
und eher nicht in Mathematik/Physik. Es sei denn,
ein Mathematiker hätte hier glaubwürdig das
„III754/Single-Format“ aus den 4 Byte-Beispielen
deduziert )

Da hätte man auch früher drauf kommen können,
wenn man nur genauer gewußt hätte, was das
Problem ist.

Warte mal. Der OP hat doch ursprünglich eine Spalte
„Gleitkommazahlen“ (mit gleitendem Dezimaltrenner!)
und rechts daneben je 4(!) korrespondierende „Zahlen“
die maximal 1 Byte benötigen, dazugeliefert

Was hätte es denn sonst sein sollen, worauf man
in der „Maschinentechnik“ heutzutage so stößt …

Grüße

CMБ

Anonym · 4. September 2006 um 08:34

Leider volle Zustimmung (ot)
Hallo,

Was hätte es denn sonst sein sollen, worauf man
in der „Maschinentechnik“ heutzutage so stößt …

Du hast recht: eigentlich hätte ich auch ohne weitere Hinweise drauf kommen sollen.
Vielleicht beim nächsten Mal.
Gruß
loderunner