# Bit Operationen NOR!



## Tsa (8. November 2009)

Hey, 
ich soll eine Java Methode schreiben, die nur mit & und ~ eine Zahl "Nor"t  
Jetzt bin ich auch ganz gut weit nur der letzte schliff fehlt noch und ich kam nach mehreren Stunden intensiven grübelns nicht drauf.
Bisher sieht das so aus: (~a&~b) 
so nach der Logik funktionierts ja auch, nur bleiben halt in Java die doofen Einsen vorne übrig. Ich hab beim besten Willen keine Idee wie ich die wegbekomme! 
Wenn ich das jetzt negiere hab ich halt das negierte von dem ergebnis was ich will... und dann? 

Hoffe mir kann wer helfen, auch wenn es nicht nur um Java geht!! 
Liebe Grüße,
Jens


----------



## Thomas Darimont (9. November 2009)

Hallo,

schau mal hier:

```
package de.tutorials;

public class NOR {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*
a   b	OUT
0	0	1
0	1	0
1	0	0
1	1	0
		 */

		byte[] a = { 
				0, 
				0, 
				1, 
				1 
				};

		byte[] b = { 
				0, 
				1, 
				0, 
				1
				};

		for (int i = 0; i < a.length; i++) {
			System.out.println(nor(a[i], b[i]));
		}

	}

	private static byte nor(byte a, byte b) {
		// Siehe: http://de.wikipedia.org/wiki/NOR-Gatter
		return (byte) nand(nand(nand(a, a), nand(b, b)), nand(nand(a, a), nand(b, b)));
	}

	private static byte nand(byte a, byte b) {
		return (byte) not(and(a, b));
	}

	private static byte and(byte a, byte b) {
		return (byte) (a & b);
	}

	private static byte not(byte a) {
		return (byte) (~(a) & 1); //invert only the last bit
	}

}
```

Ausgabe:

```
1
0
0
0
```

Gruß Tom


----------



## Tsa (9. November 2009)

Hey,
das ist sehr nett, aber das bringt mich nicht wirklcih weiter.
Ich brauche alles als Integer. Und für Integer klappts nicht 
Außerdem hab ich es noch nicht richtig verstanden, was du da machst. 
Also insbesondere die Methode not ist mir total unklar.
1 als bit ist ja: 00000001 wenn ich das jetzt mit UND mit irgendeiner beliebigen Zahl
verknüpfe, dann hab ich ja maximal 00000001!  
Mal kurz was ich bisher habe als Java Quelltext und wo mein Problem dabei liegt.

```
public class LogischeOperationen
{
	public static int bitNor(int x, int y)
	{
		return ((~x) & (~y));
	}
	
	public static int bitXor(int x, int y)
	{
		return ~((~(x&~y))&(~(~x&y)));
	}
	
	public static void main(String[] args)
	{
		System.out.println(bitNor(8,2));
		System.out.println(bitXor(2,4));
	}
}
```

Jetzt habe ich zwar das richtige Ergebnis in der Zahl stehen. für die Integer 2,4 wäre das NOR-Ergebnis ja 1, dann steht in meiner Zahl auch 001 drin. 
Aaaaaaaaaaber: ein Integer hat ja 32 Bit und die ersten 29 sind mit 1 belegt in diesem Fall also irgendwie so:
11111111[...]1001
Da ich ja eine allgemeingültige Lösung will, kann ich die auch nicht einfahc wegshiften... leider  
Wie bekomme ich die weg mit den Operatoren & und ~? 
Liebe Grüße


----------



## Thomas Darimont (9. November 2009)

Hallo,

das klappt doch auch mit int wunderbar:

```
package de.tutorials;

public class NOR {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*
		 * IN1 IN2 OUT 0 0 1 0 1 0 1 0 0 1 1 0
		 */

	  int[] a = { 
				0, 
				0, 
				1, 
				1 
				};

		int[] b = { 
				0, 
				1, 
				0, 
				1
				};

		for (int i = 0; i < a.length; i++) {
			System.out.println(nor(a[i], b[i]));
		}

	}

	private static int nor(int a, int b) {
		return nand(nand(nand(a, a), nand(b, b)), nand(nand(a, a), nand(b, b)));
	}

	private static int nand(int a, int b) {
		return not(and(a, b));
	}

	private static int and(int a, int b) {
		return (a & b);
	}

	private static int not(int a) {
		return (~(a) & 1);
	}

}
```

Ausgabe:

```
1
0
0
0
```

Mit ~ invertierst du alle bits. d.h. aus 000....0001 wird -> 111....1110 -> Wenn du hier nur am letzten bit interessiert bist kannst du das ganze Ergebnis wieder mit 1 ver-unden ( .... & 00000001 -> ... & 1)  dann werden die "führenden" 1en ausgelöscht.

Gruß Tom


----------



## Tsa (9. November 2009)

Ok, aber ich hab ja beliebige Zahlen! Also ich weiß ja erstmal gar nicht welche bits richtig sind und welche nur führende 1 die durchs invertieren entstanden sind. Also bei dem Beispiel klappt das so, aber wenn ich 16,8 NOR nehmen würde, wäre ja 111, aber wenn ich dann mit deiner methode arbeite, dann kommt 1 raus, weil nur das letzte Bit "gesichert" wird. Wie sowas funktioniert weiß ich eigentlich ganz gut, dazu mussten wir im Studium grade sehr viel machen 
Aber was mir halt nicht klar ist, wie ich jetzt beim beispiel 16,8 nach meiner Methode mit nor => 111111[...]100111 die 1 wegbekomme bis auf hinten die 7 :|
Also klar könnt ich mit &7 die 1 vorne wegbekommen, aber das wäre mir zu manuell, es soll ja per bitoperation gemacht werden.


----------



## Thomas Darimont (9. November 2009)

Hallo,

achso... ich dachte du wolltest nur ein Beispiel für NOR mit 0/1.

Schau mal hier:

```
package de.tutorials;

import static java.lang.Integer.highestOneBit;
import static java.lang.Integer.toBinaryString;

public class NOR {
  public static void main(String[] args) {
    int a = 16;
    int b = 8;
    int result = (~a & highestOneBit(a) - 1) & (~b & highestOneBit(b) - 1);

    System.out.println(toBinaryString(a));
    System.out.println(toBinaryString(b));
    System.out.println(toBinaryString(result));
  }
}
```

Ausgabe:

```
10000
1000
111
```

Gruß Tom


----------



## Tsa (10. November 2009)

Danke das ist es wohl  Das mit den highestOneBits hat mir gefehlt. Habs auch verstanden *juhu*  Danke!


----------

