//	logic.inc
//	from	scratch
//	Do 19990812
//	how well this works


//	nette art, die binäre stellenzahl zu berechnen
#macro	numbindigits(_float)

	(int(log(_float1)/log(2)))

#end


//	bitweise und
//	leider gibts keine integer in povray,
//	diese tatsache ignorieren wir aber ganz frech
#macro	and(_float1,	_float2)

	//	zähler für die bits
	//	damit alle getesteten bits an den rechten platz kommen
	#local	zaehler_bit	=	0;

	//	hilfsvariabeln: 
	#local	test_bit1	=	_float1;
	#local	test_bit2	=	_float2;

	//	und noch ein speicher für das ergebnis
	#local	ergebnis	=	0;


	//	solange nicht alle bits
	#while	((test_bit1>0)	&	(test_bit2>0))

		//	werfen wir mal das hinterste bit raus.
		//	das int() brauchen wir auch, weils sonst nicht abbricht
		#local	test_bit1	=	int(test_bit1)	/2;
		#local	test_bit2	=	int(test_bit2)	/2;

		//	nun ists gut, dass es floats sind
		//	das rausgeworfene bit zählt noch 1/2, falls es da war
		#local	bit1	=	2*(test_bit1-int(test_bit1));
		#local	bit2	=	2*(test_bit2-int(test_bit2));

		//	sooo, jetzt:
		#local	ergebnis	=	ergebnis	+	(	(bit1&bit2)	*	pow(2,zaehler_bit)	);

		//	nächste stelle
		#local	zaehler_bit	=	zaehler_bit+1;

	#end

	//	und der gewinner ist
	(ergebnis)
	
#end


//	bitweise oder
#macro	or(_float1,	_float2)

	//	zähler für die bits
	#local	zaehler_bit	=	0;

	//	hilfsvariabeln: 
	#local	test_bit1	=	_float1;
	#local	test_bit2	=	_float2;

	//	und noch ein speicher für das ergebnis
	#local	ergebnis	=	0;


	//	solange nicht alle bits
	#while	((test_bit1>0)	&	(test_bit2>0))

		//	werfen wir mal das hinterste bit raus.
		#local	test_bit1	=	int(test_bit1)	/2;
		#local	test_bit2	=	int(test_bit2)	/2;

		//	nun ists gut, dass es floats sind
		//	das rausgeworfene bit zählt noch 1/2, falls es da war
		#local	bit1	=	2*(test_bit1-int(test_bit1));
		#local	bit2	=	2*(test_bit2-int(test_bit2));

		//	der einzige unterschied zum and(): v
		#local	ergebnis	=	ergebnis	+	(	(bit1|bit2)	*	pow(2,zaehler_bit)	);

		//	nächste stelle
		#local	zaehler_bit	=	zaehler_bit+1;

	#end

	//	und der gewinner ist
	(ergebnis)
	
#end


//	bitweise not
//	problem: wir brauchen eine länge zum invertieren,
//	also ist die funktion zweiwertig
#macro	not(_float,	_len)

	//	zähler für die bits
	#local	zaehler_bit	=	0;

	//	hilfsvariabel: 
	#local	test_bit	=	_float;

	//	und noch ein speicher für das ergebnis
	#local	ergebnis	=	0;


	//	solange nicht alle bits
	#while	(zaehler_bit<_len)

		//	werfen wir mal das hinterste bit raus.
		#local	test_bit	=	int(test_bit)	/2;

		//	bla bla bla und schon invertiert
		#local	bit	=	1-(2*(test_bit-int(test_bit)));

		//	der einzige unterschied zum and():
		#local	ergebnis	=	ergebnis	+	(	bit	*	pow(2,zaehler_bit)	);

		//	nächste stelle
		#local	zaehler_bit	=	zaehler_bit+1;

	#end

	//	und der gewinner ist
	(ergebnis)
	
#end


//	bitweise exklusiv-oder mit länge
//	der ist jetzt natürlich billig,
//	es fehlt aber wie beim not() die länge der binären werte
//	nimm den, wenn du weisst, wie lang
#macro	xorl(_float1,	_float2,	_len)

	//	der rest ist simpel
	(or(
		and(
			_float1,	not(_float2,	_len)
		),	
		and(
			not(_float1,	_len),	_float2
		)
	))

#end


//	bitweise exklusiv-oder ohne länge
//	berechnen wirs halt
#macro	xor(_float1,	_float2)

	//	die maximale länge beider binären werte
	#local	bit_laenge	=	max(numbindigits(_float1),	numbindigits(_float2));

	//	noch simpler
	(xorl(_float1,	_float2,	bit_laenge))

#end