Bits genau setzen ?

Pelle

so wie x +=1 schreiben kann für x = x +1 wie mache ich dies für untenstehenden code?

p[(Nr-1)/32] |= (1<<( (Nr-1)%32 ));

Das kann ja nicht stimmen oder?

p[(Nr-1)/32] = p[(Nr-1)/32] | (1<<( (Nr-1)%32 ));

CStoll

Pelle schrieb:

1. Zuerst (128-1) = 127 // "-" kommt zwar nach % doch "-" ist in der Klammer...
2. 127 % 32 = 3 mal gehts rein Rest = 31
3. Dieser Rest 31 bedeutet, dass dass 1 Bit der variablen "Nr" 31 mal nach links geshiftet wird: 1 << 31 wäre das. Rechts von dem 32. bit dann wird alles mit 0 aufgefüllt so: 10000000 00000000 00000000 00000000 <---

Bis hierhin sieht's richtig aus.

Variable "Nr" nach der kompletten rechtsseitigen Berechnung: Nun muss nur noch linksseitige Berechnung vorgenommen werden und da habe ich noch ein kleines Problem:
p[(Nr-1)/32]
gleiches Beispiel: (128-1)= 127, 127/32 = 3,96

Wie kann ich einen index von 3,96 in dem Array p[3,96] ansprechen? Ich nehme an es liegt daran, dass die Nachkommastelle(n) bei einer int division einfach abgeschnitten werden.

Richtig erkannt - wir reden hier von Ganzzahldivision und dabei werden nachkommastellen einfach weggelassen (127/32==3).

Das "Nr-1" ist übrigens nötig, weil da jemand den Index von 1 an gezählt hat - ein erfahrener C-Programmierer hätte die Lagerplätze von 0 bis 127 nummeriert.

Pelle schrieb:

so wie x +=1 schreiben kann für x = x +1 wie mache ich dies für untenstehenden code?
p[(Nr-1)/32] |= (1<<( (Nr-1)%32 ));
Das kann ja nicht stimmen oder?
p[(Nr-1)/32] = p[(Nr-1)/32] | (1<<( (Nr-1)%32 ));

Klar stimmt das so, warum auch nicht?

Das kann ja nicht stimmen oder?
p[(Nr-1)/32] = p[(Nr-1)/32] | (1<<( (Nr-1)%32 ));

Klar stimmt das so, warum auch nicht? [/quote]

p[(Nr-1)/BITS] &= ~(1<<((Nr-1)%BITS));

das wäre dann auch richtig?

p[(Nr-1)/BITS] = p[(Nr-1)/BITS] & ~(1<<((Nr-1)%BITS));

CStoll

Wenn ich jetzt keinen Tippfehler übersehen habe, ja.

pointercrash**

Pelle schrieb:

unsigned int iLagerplaetze[4]; // 128 Bits
int temp;

Na, mit Sicherheit NICHT 128 Bit ... eher hatte da jemand 128 Bit intus
Was machst Du Dir Gedanken um den Platz von 128 Bit oder Byte und willst an Bits frickeln, wenn Du dann auf diese Weise Speicher vergeudest.
Mit den Mehrfachdivisionen

p[(Nr-1)/32] = p[(Nr-1)/32] | (1<<( (Nr-1)%32 ));

verläßt man sich auf die Optimierung des Compilers, aber es gibt wirklich welche, die (Nr-1)/32 mehrfach ausrechnen.:p

Performance dahin, kaum Platz gespart ... *keine gute Idee*, nur um nicht Schwachsinn sagen zu müssen

pointercrash() schrieb:

Performance dahin, kaum Platz gespart ... *keine gute Idee*, nur um nicht Schwachsinn sagen zu müssen

eben drum, ich hatte weiter oben ein paar schicke macros gepostet (zwar mit flüchtigkeitsfehlern drin), aber davon will ja keiner was wissen.

macro-troll schrieb:

eben drum, ich hatte weiter oben ein paar schicke macros gepostet (zwar mit flüchtigkeitsfehlern drin), aber davon will ja keiner was wissen.

doch, ich !

und zwar wieso &3 den selben wert wie %4 liefert.
kann man das irgendwie mathematisch zeigen ?
also im moment komme ich nicht drauf wie.

macro-troll-fan schrieb:

kann man das irgendwie mathematisch zeigen ?

ich kanns zwar nicht mathematisch zeigen, aber im binärsystem funzt dieses speed-modulo auch nur mit zweierpotenzen. alle stellen rechts vom teiler müssen 0 sein, dann isses ohne rest teilbar. in anderen zahlensystemen ist es ja so ähnlich, also im zehnersystem bei allen teilern, die selber glatt durch die basis teilbar sind usw...

pointercrash**

macro-troll-fan schrieb:

macro-troll schrieb:

eben drum, ich hatte weiter oben ein paar schicke macros gepostet (zwar mit flüchtigkeitsfehlern drin), aber davon will ja keiner was wissen.

doch, ich !
und zwar wieso &3 den selben wert wie %4 liefert.
kann man das irgendwie mathematisch zeigen ? ...

ÖÄhmm, im Prinzip schon, aber es will ja keiner was davon wissen, so why ...

pointercrash() schrieb:

macro-troll-fan schrieb:

macro-troll schrieb:

eben drum, ich hatte weiter oben ein paar schicke macros gepostet (zwar mit flüchtigkeitsfehlern drin), aber davon will ja keiner was wissen.

doch, ich !
und zwar wieso &3 den selben wert wie %4 liefert.
kann man das irgendwie mathematisch zeigen ? ...

ÖÄhmm, im Prinzip schon, aber es will ja keiner was davon wissen, so why ...

wenn es niemand wissen wollte, dann würde auch niemand danach fragen.

pointercrash**

der wissbegierige schrieb:

wenn es niemand wissen wollte, dann würde auch niemand danach fragen.

Dachte, Du willst mich veralbern
mit %4 führst Du eine Modulo- Division durch. Bei /4 würdest Du im Binärsystem zweimal rechts shiften, also /2 /2. Was da überbleibt, ist das Ergebnis der Integer- Division, was Du nach rechts rausgeshiftet hast, ist der Modulo- Rest. Das sind die unteren beiden Bits und die kannst Du genausogut (naja, zumeist schneller) durch Verundung gewinnen. Daß bei 3 die unteren beiden Bits gesetzt sind, muß ich nicht gesondert erklären, oder?
Genügt die anschauliche Erklärung, oder soll ich den Bronstein zücken und von dort aus dem Abschnitt Zahlensysteme rezitieren?

pointercrash() schrieb:

Daß bei 3 die unteren beiden Bits gesetzt sind, muß ich nicht gesondert erklären, oder?

nööööööööö

pointercrash() schrieb:

Genügt die anschauliche Erklärung, oder soll ich den Bronstein zücken und von dort aus dem Abschnitt Zahlensysteme rezitieren?

Nö, nicht nötig, die Erklärung ist spitze
Danke dafür.

Also ich es mir aufgeschrieben und mit diversen Zahlen probiert habe, hab ich es auch geblickt *stolz*

Also, wenn ich %4 haben will, schreibe ich &3.
Möchte ich %8, schreibe ich &7.
Will ich %16 kann ich dafür &15 setzen.
%32 -> &31 usw.

Also ist immer %(2^x) gleichwertig mit &(2^x-1)

Jetzt hab auch ich es kapiert