Binäre Abfrage

[kodela]

Hallo,

wer kann mir helfen? Ich stehe momentan auf dem Schlauch.

Über die Bit-Operatoren soll ein Integerwert darauf geprüft werden, ob in ihm Bits gesetzt sind, welche in einer Maske nicht gesetzt sind.

Beispiel:

Testwert: 0 0 1 0 1 1 0 0
Maske   : 0 0 1 1 0 1 0 0

Erwartetes Ergebnis: true, da zwar zwei Bits gesetzt sind, welche auch in der Maske gesetzt sind. Es ist aber mit dem Bit 3 auch ein Bit vorhanden, welches in der Maske nicht vertreten ist.

oder:

Testwert: 0 0 1 0 0 1 0 0
Maske   : 0 0 1 1 0 1 0 0

Erwartetes Ergebnis: false, da im Testwert nur Bits vorkommen, welche auch in der Maske verteten sind.

Wie kann eine Abfrage formuliert werden, die mir das gewünschte Ergebnis liefert?

Danke im Voraus. Bitte nicht wundern, wenn ich auf eine Antwort nicht sofort reagiere. Ich bin für einige Tage auswärts.

MfG, kodela

 

[Robat]

Du könntest den Testwert mit der Maske Oder-verknüpfen. Wenn am Ende wieder die Maske heraus kommt weißt du auf jeden Fall dass im Testwert keine Einsen vorkommen, die es in der Maske nicht gibt.

 

[Flown]

Oder anders: Du machst ein UND auf Testwert und Maske und schaust nach ob Testwert wieder rauskommt.

 

[kodela]

Hallo und danke!

Das ODER ist es, das ich bei meinen Überlegungen unverständlicherweise nicht berücksichtigt habe. Mit dem UND würde es nur dann gehen, wenn im Testwert auch alle Bits der Maske gesetzt wären. Oder sehe ich da etwas falsch?

MfG, kodela

 

[Flown]

Testwert: 0 0 1 0 1 1 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 1 0 0 1 0 0

Testwert: 0 0 1 0 0 1 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 1 0 0 1 0 0

Siehst du es?

 

[Flown]

Wenn du wissen willst ob dein Testwert der Bitmaske entspricht (ich nehme an es sind ints) dann mach einfach testwert == maske.
Wenn du die Unterschiede wissen möchtest, dann einfach ein XOR.

 

[Meniskusschaden]

Und wenn du genau die gesetzten Bits des Testwerts wissen willst, die in der Maske fehlen, kannst du ein AND auf die invertierte Maske machen: t&~m

 

[kodela]

Hallo zusammen,

bin wieder zurück und bedanke mich erst einmal für all Eure Hinweise.

Nach wie vor kann ich allerdings nur die Lösung über eine OR-Verknüpfung als zielführend sehen. Zur Erinnerung noch einmal die Problembeschreibung:

Über die Bit-Operatoren soll ein Integerwert darauf geprüft werden, ob in ihm Bits gesetzt sind, welche in einer Maske nicht gesetzt sind.

Es kommt also nicht darauf an, ob der Testwert der Bitmaske entspricht, ich möchte auch nicht die Unterschiede zwischen einem Testwert und einer Bitmaske feststellen, auch nicht, welche Bits einer Maske im Testwert gesetzt sind. Es soll festgestellt werden, ob im Testwert Bits gesetzt sind, die in der Maske nicht gesetzt sind. Oder anders herum, ob im Testwert ausschließlich, aber nicht zwingend alle Bits gesetzt sind, welche auch in der Maske gesetzt sind.

Dazu hier noch einige Beispiele:

// Im Testwert Bits, die in der Maske nicht vertreten sind:

Testwert: 0 0 1 0 1 1 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 1 0 0 1 0 0   // Ergebnis != Maske

// Im Testwert nur Bits, die auch in der Maske vertreten sind:

Testwert: 0 0 1 0 0 1 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 1 0 0 1 0 0   // Ergebnis != Maske

Was wäre, wenn:

// Im Testwert Bits, die in der Maske nicht vertreten sind:

Testwert: 0 1 0 0 1 0 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 0 0 0 1 0 0   // Ergebnis != Maske


Testwert: 0 1 1 0 0 1 0 1
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 1 0 0 1 0 0   // Ergebnis != Maske

// Im Testwert nur all die Bits, die auch in der Maske vertreten sind:

Testwert: 0 0 1 1 0 1 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 1 1 0 1 0 0   // Ergebnis == Maske

Mit OR geht es jedoch

// Im Testwert nur Bits, die auch in der Maske vertreten sind:

Testwert: 0 0 1 1 0 1 0 0
Maske   : 0 0 1 1 0 1 0 0
T | M   : 0 0 1 1 0 1 0 0   // Ergebnis == Maske

Testwert: 0 0 0 1 0 0 0 0
Maske   : 0 0 1 1 0 1 0 0
T | M   : 0 0 1 1 0 1 0 0   // Ergebnis == Maske

// Im Testwert Bits, die in der Maske nicht vertreten sind:

Testwert: 0 1 1 1 1 1 0 0
Maske   : 0 0 1 1 0 1 0 0
T | M   : 0 1 1 1 1 1 0 0   // Ergebnis != Maske

Testwert: 0 1 0 0 0 0 0 1
Maske   : 0 0 1 1 0 1 0 0
T | M   : 0 1 1 1 0 0 0 1   // Ergebnis != Maske

Mit

if (maske | testwert ==  maske)

kann ich also die Fälle behandeln, bei denen im Testwert ausschließlich Bits gesetzt sind, welche auch in der Make gesetzt sind und bei einer Negierung der Abfrage einfach die gegenteilige Situation.

MfG, kodela

 

[Meniskusschaden]

Mit

if (maske | testwert ==  maske)

kann ich also die Fälle behandeln, ...

Fehlt da nicht ein Klammernpaar: if ((maske | testwert) == maske)?

Nach wie vor kann ich allerdings nur die Lösung über eine OR-Verknüpfung als zielführend sehen.

Die drei genannten Lösungsvorschläge sind äquivalent:

(testwert|maske) == maske
(testwert&maske) == testwert
(testwert&~maske) == 0

 

[kodela]

Doppelter Eintrag, kann gelöscht werden. Ursprünglicher Inhalt im nächsten Beitrag.
Eintrag wurde nach dem Absenden nicht angezeigt. Daraufhin nahm ich noch eine kleine Änderung vor und sandte die Antwort noch einmal ab. Da hatte ich dann plötzlich zwei Beiträge.

MfG, kodela

 

[kodela]

Fehlt da nicht ein Klammernpaar: if ((maske | testwert) == maske)?
Ja, dieser Ausdruck muss so geklammert werden, wie Du es zeigst.

Die drei genannten Lösungsvorschläge sind äquivalent:

(testwert|maske) == maske
(testwert&maske) == testwert
(testwert&~maske) == 0

Das sehe ich leider nicht so. In diesem Fall:

Testwert: 0 1 0 0 1 0 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 0 0 0 1 0 0

entspricht das Ergebnis beispielsweise nicht dem Testwert. Das wäre doch nur dann der Fall, wenn alle Bits des Testwertes auch in der Maske vertreten sind. Oder sehe ich da etwas falsch?

MfG, kodela

 

[Meniskusschaden]

In folgendem Beispiel arbeitet die Methode check1 nach dem Verfahren, dass du bereits für geeignet befunden hast (habe nur den Klammerfehler beseitigt, damit es kompiliert). Die beiden anderen Methoden liefern dasselbe Ergebnis:

public class BitOperatorTest {
    private static boolean check1(int testwert, int maske) {
        return (testwert|maske) == maske;
    }
  
    private static boolean check2(int testwert, int maske) {
        return (testwert&maske) == testwert;
    }
  
    private static boolean check3(int testwert, int maske) {
        return (testwert&~maske) == 0;
    }

    public static void main(String[] args) {
        int testwert = 0b01001000;
        int maske    = 0b00110100;
        System.out.println(check1(testwert, maske));
        System.out.println(check2(testwert, maske));
        System.out.println(check3(testwert, maske));
    }
}

Ausgabe:

false
false
false

Es wird bei allen Verfahren false ausgegeben, wenn im Testwert gesetzte Bits existieren, deren Pendant in der Maske nicht gesetzt ist. Das willst du wahrscheinlich genau anders herum haben, müsstest es also noch negieren. Mir ging es aber erst einmal um die Äquivalenz der drei Ausdrücke.

In diesem Fall:

Testwert: 0 1 0 0 1 0 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 0 0 0 1 0 0

entspricht das Ergebnis beispielsweise nicht dem Testwert.

Das müsste so aussehen:

Testwert: 0 1 0 0 1 0 0 0
Maske   : 0 0 1 1 0 1 0 0
T & M   : 0 0 0 0 0 0 0 0

Es stimmt zwar trotzdem, dass das Ergebnis nicht dem Testwert entspricht, aber wie eben beschrieben bedeutet das ja gerade, dass mindestens eines der gesuchten Bits existiert.

 

[kodela]

Hallo Meniskusschaden,

Du hast absolut Recht. Heute Nacht ist bei mir der Groschen gefallen. Herzlichen Dank für Dein Bemühen!

MfG, kodela