[Instrumentarium] Floats

**Milky-Way** · 27.01.2011 19:24

Zitat von Sektenspinner

Deine Beobachtung war dagegen, dass mkf(100/60) etwas ganz großes sei, was aber nicht so sein sollte (und wohl auch nicht so ist, oder?).

Ich habe es jetzt nochmal mit der damaligen Anwendung ausprobiert und die Zeit verging mit der richtigen Geschwindigkeit (soweit ich das abschätzen kann); damals raste die Zeit nur so, weshalb es "etwas ganz großes" gewesen sein müsste. Wie damals von dir vermutet vermutlich irgendein Fehler, den ich gemacht hatte, da ich den Code anschließend geändert habe, lässt es sich jetzt weder rekonstruieren, noch reproduzieren.

Zitat von Sektenspinner

Dein Ergebnis von TestFloats ist ebenfalls absolut nachvollziehbar und dokumentationsgetreu. mkf(1/2) soll zum Null-Float auswerten, divf(mkf(1),mkf(2)) zum 0.5-Float.

Das liegt einfach daran, dass der Term 1/2 zu Null ausgewertet wird und erst dann in mkf eingesetzt wird.

Alles funktioniert wie es sein soll.

Ja, so hatte ich es mir auch gedacht. Bis zu meinem PS hatte ich nur deine damalige Aussage falsch verstanden.

Zitat von Lehona

100/60 ist 1 (Bei der Ganzzahldivision).

Danke, das war mir ja bekannt.

**Lehona** · 27.01.2011 19:36

Wollte nur deine Annahme bestätigen, habe mich etwas knapp ausgedrückt (Kommt davon, wenn man nebenher zum Zocken ins Forum tabbt).

**orcwarriorPL** · 05.02.2011 15:29

Hi, I maded some simple function based on this package, maybe someone else find them useful.

Fraction: Nothing special, but you don't have to always do divf(mkf(1),mkf(2)) to have 0.5 etc. :P

Code:

// Example: fractionF(9,10) = 0.9 (float)
func int fractionF(var int d,var int c)
{
	d = mkf(d);
	c = mkf(c);
	return divf(d,c);	
};

Random Float: This one is rather experimental, I tested it couple of times and it looks to be working, but I guess it could be done in some nicer way, but anyway, here's the code:
It needs fractionf to work properly, but it could be simply changed by editing this line:
f = fractionf(Hlp_Random(possibilities),possibilities);
f = divf(mkf(Hlp_Random(possibilities)),mkf(possibilities));

Code:

// **************************************************
// RandF: Function returns random value from
// [range_start,range)
// * range should be greater than range_start
//   but even if not, func should still work properly.
// * range_start and range have to be a zfloat
// **************************************************
func int RandF(var int range_start,var int range)
{                                                                                                             
	// -I made only small research, but it looks like bigger numbers generate                                                                                                                
	//  errors when dividing (floats don't have endless accuracy :-P)                                                                                                                        
	// When I tried possibilities = 65536, it don't looked like returns 
	// were proper, numbers bigger than half of range was never returned...                                                                                                                                                           
	// Unfortunaly this is an random function so I don't have idea 
	// how to check it, it only possibly to check it theoretically ;-(. 
	// But as you can see on instance it looks to be working OK.
	// Unfortunaly low possibilities value, means returned floats                                                                                                                            
	// could have big step/"jumps", if rDiff>posibilities it means                                                                                                                           
	// step will be more than 1.0.  
	
	const int possibilities = 10000;                                                                                                                                                         
									
	var int f; // fe[0,1)
	var int rDiff; //range difference
	rDiff = subf(range,range_start);

	f = fractionf(Hlp_Random(possibilities),possibilities);//0.0-0.999..
	f = mulf(f,rDiff);
	
	return addf(range_start,f);	
};

Here's a instance of use: