Binärdarstellung?

[Manfred]

Hi,

es gibt die Technik mit Zahlen zu arbeiten:

1 für dies
2 für da
4 für jenes

es kann jede Zahl einzeln, oder aber auch in Summe übergeben werden:

1+2
oder 3
1+2+4
oder 7

1. wie nennt man das Verfahren?
2. hat jemand eine Ahnung, wie das ausgewertet wird?
3. sind die 3 Zahlen die Standardauswahl, oder geht es auch weiter?

Ich überlege mir, wie man sowas umsetzen kann, wenn man z.B. etliche XbParts hat, die man aber unterschiedlich aktivieren oder deaktivieren will/muß. Es wird "eine" Zahl als Parameter übergeben und dann kann ermittelt werden, was mit welchem Part gemacht werden muß.

[Martin Altmann]

Hallo Manfred,
das sieht mir sehr nach binärarithmetik aus - ein Bit kann an oder aus sein.
Du hast also x Bits und somit eine Zahl 2^x.
Einfach die einzelnen Zustände ORen...

Viele Grüße,
Martin

[Manfred]

Hi Martin,



ich verstehe kein Wort.

[Martin Altmann]

Hallo Manfred,
schau mal in Wikipedia unter dem Schlagwort Binärdarstellung
Wenn Du also vier verschiedene "Schalter" hast, von denen jeder ein oder aus sein kann, so würde das Dual (oder binär) so aussehen:
0000 -> Alle sind aus
1111 -> Alle sind an
Man liest jetzt beim Rechnen von recht nach links - die Basis ist 2, da es zwei Zustände gibt (0 oder 1) und der Exponent beginnt bei 0.
Ergo:

Code: Alles auswählen

  1    1    1    1   <- Zustände
2^3  2^2  2^1  2^0   <- Dual
  8    4    2    1   <- Dezimal

1111 bedeutet somit in dezimaler Schreibweise 15.
Wenn Du jetzt das Gesamtergebnis numerisch in der Variablen nZustand hättest, könntest Du einfach prüfen, ob das vierte Bit (von rechts) gesetzt ist, indem Du einfach mittels

Code: Alles auswählen

if nZustand[ 4 ]...

prüfst.

Viele Grüße,
Martin

[Manfred]

Nun, die Lösung ist klar, aber der Weg dahin, da stellt sich die Frage, ob der jetzt zu kompliziert ist?

Also es wird angenommen, ich habe 5 Buttons:

1
2
4
8
16

Wenn alle aktiv sein sollen, dann würde das heißen 1+2+4+8+16 = 31
Das ist einfach zu ermitteln, weil

31 - 16 = 15 -->5
15 - 8 = 7 -->4
7 - 4 = 3 -->3
3 - 2 = 1 --> 2
1 - 1 = 0 --> 1

wenn ich die Nummer 3 NICHT haben will, dann ergäbe 1+2+8+16 = 27

27 - 16 = 11 -->5
11 - 8 = 3 -->4
3- 4 = - 1 -->3 = falsch
3-2 = 1 --> 2
1-1 = 0 -->1

Dafür muß es doch eine Formel geben, die am Ende ausspuckt was rauskommt. Oder muß man das hier von Hand machen? Vor allen Dingen wäre ja wichtig für die Funktion, wenn sie automatisch wüßte, welcher max. Wert am Anfang genommen werden muß beim Abziehen.

Der einfachste oder auch blödeste Weg wäre, alle Parts, die in Frage kommen in ein Array zu packen. Ein Len zu ermitteln und dann von unten anfangen hochzuzählen also 1,2,4,8 usw. Und dann von oben wieder runter das obige Beispiel zu durchlaufen.

[Rolf Ramacher]

Hi Manfred,

ich habe immer noch nicht verstanden, was du machen möchtest. So du hast 5 buttons- davon können/sollten einige nicht akiv sein.

Habe ich dich soweit verstanden ?? Woran soll denn erkannt werden, welche Buttons nicht aktiv sein sollen ? Legt dies der User fest ?

Die Function in der du die Buttons definierst wird vermutlich aus einer anderen maske aufgerufen. Vielleicht kannst du hier festlegen welche Buttons aktiv sind und welche nicht und übergibst an die Function
die Zahlen 1,2, oder 3 die deaktiviert werden sollen

[Tom]

Vermutlich geht es nicht um Buttons, sondern um Checkboxen oder ähnliches. Mehrere Optionen können unabhängig voneinander gewählt werden, und es soll ein Wert (oder ähnliches) entstehen, dem man ablesen kann, welche Optionen gewählt wurden. Das ginge ziemlich einfach, wenn die Arrayfähigkeit von Strings auch umgekehrt gegeben wäre, also z.B.:

Code: Alles auswählen

cOptions := "00000"
? cOptions[2] // "0"
cOptions[2] := "1" // z.B. in der Checkbox
* funzt leider nicht, cOptions ist noch immer "00000"

Dann könnte man abfragen, ob die Optionen 1 und 4 gesetzt sind. Aber man kann ja hantieren. Statt cOptions[2] := "1" geht ja auch:

Code: Alles auswählen

cOptions := Left(cOptions,nOption-1) + "1" + Right(cOptions,nOption-1)

Wobei "nOptions" dann die Position/Nummer der Checkbox wäre.

[Manfred]

Hi,

das mit den Checkboxen, muß ich mir mal überlegen.

Was ich meine ist, ich möchte über eine Zahl jedwede Möglichkeit haben, unter 10 Pushbutton eine beliebige Kombination von aktiven oder nicht aktiven Pushbuttons zu erzeugen.

Ich habe 10 Buttons, die für:

Eingeben
Finden
Edit
Zurück
vor
Ende
Anfang
Speichern
Löschen
beenden

stehen. Jedesmal einzeln die Buttons zu enablen oder disablen, weil nicht alle immer und zu jeder zeit aktiv sein dürfen, finde ich aufwändig. Also schreibe ich eine Funktion, die enabled oder disabled.
Nun, es scheint so auszusehen, dass es keine mathematische Formel dafür gibt, also mache ich es nach dem Muster wie oben beschrieben.

In wie weit das für andere Parts geht, werde ich mal dabei ausprobieren.

[Tom]

Hallo, Manfred.

Wenn Du so was hast:

1
2
4
8
16

dann gibt es diese Summierungsmöglichkeiten:

1
2
3
4
5
..
31

also alle Einzelsummen zwischen 1 und 31. Jede Summe steht für eine Anzahl ausgewählter Optionen. Wenn Du jetzt von oben nach unten (also von 16 beginnend bis 1) alle möglichen Summanden abziehst, ist der jeweilige Wert enthalten, wenn die Differenz nicht kleiner als Null ist. Also:

nWert := 17
nWert - 16 = 1 // 16 ist enthalten
nWert -= 16 // 1
nWert - 8 = -7 // 7 ist NICHT enthalten
usw.

[Manfred]

Hi Tom,

mein Reden. Ich dachte nur es gäbe da schon irgendwas fertiges, oder eine Formel, mit der das kurz und knapp geht.
Naja, dann frickel ich eben selbst was....

[Tom]

Ergänzung: Diese Auswertung kann man natürlich auch schön in eine Funktion umwandeln und diese über einen Parameter ermitteln lassen, ob der jeweilige Wert (z.B. "4" bei der dritten Option ) enthalten ist.

[Tom]

Code: Alles auswählen

FUNCTION isOption(nOption,nSelected) 
* nOption ist der Wert, dessen Existenz geprüft werden soll
* nSelected ist Gesamtwert, z.B. 27
LOCAL nValue := 16 // im Beispiel höchster Binärwert
DO WHILE nSelected > 0
  IF nSelected - nValue > 0
   IF nValue = nOption
      RETURN .T.
   ENDIF
   nSelected -= nValue
  ENDIF
  nValue := nValue / 2
ENDDO
RETURN .F.

Ungetestet und ins Blaue getippt. Geht sicher auch noch eleganter.

[Tom]

Nur mal so am Rande: Was macht dieser Thread eigentlich im Raucherraum?

[Manfred]

Tja,

mir fiel die Frage halt bei einer Tasse Kaffee und einem Glimmstengel ein. Sollte nur Klön sein, war aber mal wieder klar, dass es was größeres werden könnte. Es gab auch zu Anfang keinen Titel. Also etliche Bedingungen auf einmal.

Wenn Du willst, dann verschiebe ihn. Aber wohin? Das bleibt Dir überlassen.

[Manfred]

Nicht schön, aber selten....

Code: Alles auswählen

/// <summary>
///  <para>
///     <bold>disableXbp:</bold>enabled oder disabled XbParts
///  </para>
///  <para>
///     <bold>oXbp:</bold>Objekt mit den Parts, die dis/enabled werden sollen
///  </para>
///  <para>
///     <bold>lDisable:</bold>.T. = disable (default = .F.)
///  </para>
///  <para>
///     <bold>nChecksum:</bold> Wert eingeben für die Menge der Parts die geändert werden sollen
///  </para>
/// </summary>
METHOD DialogFenster:disableXbp(oXbp,lDisable,nCheckSum)
       LOCAL aXbp       := oXbp:childList()
       LOCAL nXbp       := Len(aXbp)
       LOCAL nI
       LOCAL nWert

       DEFAULT lDisable  TO .T.
       DEFAULT nChecksum TO 0

       IF lDisable
          IF nChecksum = 0                                            // es soll wirklich nur disbled werden
             AEval(aXbp, {|o,i| o:disable()})
          ELSE
             AEval(aXbp, {|o,i| o:enable()})                      // erstmal alles enablen
             FOR nI := nXbp TO 1 STEP -1                         // jetzt geht es rückwärts mit dem Prüfen
                 nWert := INT(2^(ni-1))
                 IF nChecksum -  nWert >= 0
                    aXbp[nI]:disable()
                    nChecksum -= nWert                               // Rest berechnen
                 ENDIF
             NEXT
          ENDIF
       ELSE
          IF nChecksum = 0                                                // es soll wirklich nur enabled werden
             AEval(aXbp, {|o,i| o:enable()})
          ELSE
             AEval(aXbp, {|o,i| o:disable()})                          // erstmal alles disablen
             FOR nI := nXbp TO 1 STEP -1                             // jetzt geht es rückwärts mit dem Prüfen
                 nWert := INT(2^(ni-1))
                 IF nChecksum - nWert >= 0
                    aXbp[nI]:enable()
                    nChecksum -= nWert
                 ENDIF
             NEXT
          ENDIF
       ENDIF
RETURN

nCheckSum = 390 bewirkt, das Button 2,3,8,9 deaktiviert werden

[Martin Altmann]

Hmmm,
warum machst Du nicht, was ich oben schrieb?

Code: Alles auswählen

nOptions := 0 //alle Buttons aus
nOptions[4] := 1
nOptions[3] := 1
? nOptions
? nOptions[2]
? nOptions[3]

Viele Grüße,
Martin

[Manfred]

auf Anhieb eine Antwort?

ich denke mal, weil ich nicht verstanden habe, was Du meinst

[Martin Altmann]

Hallo Manfred,
ich habe es jetzt selber mal versucht - war aus der Erinnerung heraus, mal was dazu gelesen gehabt zu haben.
War leider falsch! Man kann so nicht bitweise setzen, aber bitweise abfragen!!
Sieh Dir mal die Hilfe an zum Thema []Operator (-> Beispiel 3) und $Operator (-> Beispiel 3)!
Wenn Du eine Zahl hast, kannst Du bitweise prüfen, ob das jeweilige Bit gesetzt ist oder nicht!

Also bei Deinem Beispiel oben:

Code: Alles auswählen

10 Buttons:
2^0 =   1
2^1 =   2
2^2 =   4
2^3 =   8
2^4 =  16
2^5 =  32
2^6 =  64
2^7 = 128
2^8 = 256
2^9 = 512

Wären alle gesetzt, käme als Summe also 1023 heraus.
Um jetzt zu prüfen, ob ein einzelner Schalter an ist, reicht folgendes Konstrukt:

Code: Alles auswählen

FOR nI := 1 to 10
  IF nOptions[ nI ]
    ...
  ENDIF
NEXT

Viele Grüße,
Martin

[Martin Altmann]

Ha,
es geht doch - habe noch ein wenig gespielt...
Man darf jedoch nicht bitweise setzen mit 1 oder 0, sondern mit .t. oder .f.!
Also:

Code: Alles auswählen

nOptions := 0
nOptions[4] := .t.
nOptions[3] := .t.
? nOptions 
? nOptions[2] 
? nOptions[3]

ACHTUNG!! Das geht nur, wenn nOptions auch definiert wurde - als local oder static! Private und public gehen nicht!

Viele Grüße,
Martin

[Manfred]

Hi Martin,

ich bin ganz ehrlich, das ist mir im Moment nicht verständlich. Laß uns am Samstag darüber reden. Dann liegt der Quellcode auch vor und ihr könnt sehen, was ich warum wie mache.

[brandelh]

Hi,

ganz ehrlich habe ich mich die ganze Zeit gefragt, warum du den Aufwand mit BITs treiben willst. Bei den heutigen Speicherausstattungen (und früher auch schon) habe ich sowas immer in einem String erledigt:

Code: Alles auswählen

Ich brauche 12 Stellen ... und nehme 12 Byte:

cVar := StrZero(0,12,0) // 12 Schalter ausgeschaltet.

if cVar[4]="1" // 4. Schalter ein ?
   ...
else
   ...
etc.

aber was ich da von Martin lese haut mich direkt vom Hocker, dass man auf die einzelnen BITs direkt zugreifen kann ist mir absolut neu. Wo hast du das wieder gefunden

Martins Lösung ist natürlich wesentlich eleganter und sicher auch schneller.

[Manfred]

Leute,

ich klinke mich jetzt hier aus.
Ich verstehe immer weniger......

Ich verstehe immer weniger, was eure Vorschläge mit meiner Lösung gemeinsam haben sollen? Mit anderen Worten:

ICH BLICKE NICHT MEHR DURCH!!!

[Martin Altmann]

Hallo Hubert,
ist wohl auch "relativ" frisch - erst seit einigen Jahren möglich, glaube ich!
Hatte ich mal in der Newsgroup gelesen...
Aber es gibt halt die Einschränkungen, die ich oben schrieb (Variablentyp).

Viele Grüße,
Martin

[brandelh]

@Manfred,

was gibt es daran nicht zu verstehen ?

nZahl := 0 erzeugt eine Integer Variable (da keine Nachkommastellen angegeben bzw. nötig.)
nZahl[0] oder nZahl[1] (weiß ich jetzt gar nicht) greift auf des erste Bit zu etc.

wenn bei nZahl := 0 das erste Bit gesetzt wird, wird der Wert der Zahl 1.
Wird nur das 2. Bit gesetzt, wird es 2, wenn das erste und das 2. Bit gesetzt sind, gibt es 3 ...

Nur Rechnen sollte man nicht mit solchen Zahlen, denn dann könnte es eventuell passieren dass es keine Integer mehr ist sondern eine Gleitkommazahl wird. Wie die sich verhalten weiß ich auch nicht.

Eine Integer von Xbase++ hat immer 32 bit zur Verfügung.

[Martin Altmann]

Äh, Manfred,

Ich verstehe immer weniger, was eure Vorschläge mit meiner Lösung gemeinsam haben sollen?

- ganz einfach: Alles
Du wolltest die einzelnen Schalter mit Zahlen darstellen (1, 2, 4, 8, ...) und die angeschalteten Schalter durch die Summe der jeweiligen Zahlen (9 = Schalter 1 und Schalter 4).
Dies ist einfache Binärdarstellung.
Schalter 1 ist 2^0 - also das erste Bit (von rechts)
Schalter 4 ist 2^3 - also das vierte Bit (von rechts)

Code: Alles auswählen

nOptions[1]:=1
nOptions[4]:=1

entspricht dem o.g. Einschalten der beiden Bits. In nOptions steht dann das Ergebnis 9 (wenn vorher alles aus war).
Aber gerne weiteres am Samstag nach div. Bierchen...

Viele Grüße,
Martin