hedgewars: comparison hedgewars/uFloat.pas

equal deleted inserted replaced

-:6ea838b8dcd5
+:13ac59499066
 function cstr(const z: hwFloat): shortstring; // Returns a shortstring representations of the hwFloat.
 function hwRound(const t: hwFloat): LongInt; inline; // Does NOT really round but returns the integer representation of the hwFloat without fractional digits. (-_0_9 -> -0, _1_5 -> _1)
 function hwAbs(const t: hwFloat): hwFloat; inline; // Returns the value of t with positive sign.
 function hwSqr(const t: hwFloat): hwFloat; inline; // Returns the square value of parameter t.
 function hwPow(const t: hwFloat; p: LongWord): hwFloat; inline; // Returns the power of the value
-function hwSqrt(const t: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t.
+function hwSqrt1(const t: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t.
+function hwSqrt(const x: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t.
 function Distance(const dx, dy: hwFloat): hwFloat; // Returns the distance between two points in 2-dimensional space, of which the parameters are the horizontal and vertical distance.
 function DistanceI(const dx, dy: LongInt): hwFloat; // Same as above for integer parameters.
 function AngleSin(const Angle: Longword): hwFloat;
 function AngleCos(const Angle: Longword): hwFloat;
 function vector2Angle(const x, y: hwFloat): LongInt;
 z.isNegative:= z1.isNegative;
 z.QWordValue:= z1.QWordValue + z2.QWordValue
 end
 end;
 function isZero(const z: hwFloat): boolean; inline;
 begin
 isZero := z.QWordValue = 0;
 end;
 operator < (const z1, z2: hwFloat) b : boolean; inline;
 b:= z1.isNegative
 else
 if z1.QWordValue = z2.QWordValue then
 b:= false
 else
-b:= not((z1.QWordValue = z2.QWordValue) or ((z2.QWordValue < z1.QWordValue) <> z1.isNegative))
+b:= (z2.QWordValue < z1.QWordValue) = z1.isNegative
 end;
 operator > (const z1, z2: hwFloat) b : boolean; inline;
 begin
 if z1.isNegative xor z2.isNegative then
 z.isNegative:= z1.isNegative xor (z2 < 0);
 z.QWordValue:= z1.QWordValue * abs(z2)
 end;
 operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; inline;
-var t: hwFloat;
+var t: QWord;
 begin
 z.isNegative:= z1.isNegative xor z2.isNegative;
 z.Round:= z1.QWordValue div z2.QWordValue;
-t:= z1 - z2 * z.Round;
+t:= z1.QWordValue - z2.QWordValue * z.Round;
-if t.QWordValue = 0 then
+z.Frac:= 0;
-z.Frac:= 0
-else
+if t <> 0 then
 begin
-while ((t.QWordValue and $8000000000000000) = 0) and ((z2.QWordValue and $8000000000000000) = 0) do
+while ((t and $FF00000000000000) = 0) and ((z2.QWordValue and $FF00000000000000) = 0) do
 begin
-t.QWordValue:= t.QWordValue shl 1;
+t:= t shl 8;
-z2.QWordValue:= z2.QWordValue shl 1
+z2.QWordValue:= z2.QWordValue shl 8
 end;
 if z2.Round > 0 then
-z.Frac:= (t.QWordValue) div (z2.Round)
+inc(z.QWordValue, t div z2.Round);
-else
-z.Frac:= 0
 end
 end;
 operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
 begin
 hwPow.QWordValue:= QWord(hwPow.Round) * t.Frac + QWord(hwPow.Frac) * t.Round + ((QWord(hwPow.Frac) * t.Frac) shr 32);
 dec(p)
 end
 end;
-function hwSqrt(const t: hwFloat): hwFloat;
+function hwSqrt1(const t: hwFloat): hwFloat;
 const pwr = 8; // even value, feel free to adjust
 rThreshold = 1 shl (pwr + 32);
 lThreshold = 1 shl (pwr div 2 + 32);
 var l, r: QWord;
 c: hwFloat;
 begin
-hwSqrt.isNegative:= false;
+hwSqrt1.isNegative:= false;
 if t.Round = 0 then
 begin
 l:= t.QWordValue;
 r:= $100000000
 r:= c.QWordValue
 else
 l:= c.QWordValue
 until r - l <= 1;
-hwSqrt.QWordValue:= l
+hwSqrt1.QWordValue:= l
 end;
+function hwSqrt(const x: hwFloat): hwFloat;
+var r, t, s, q: QWord;
+i: integer;
+begin
+hwSqrt.isNegative:= false;
+t:= $4000000000000000;
+r:= 0;
+q:= x.QWordValue;
+for i:= 0 to 31 do
+begin
+s:= r + t;
+r:= r shr 1;
+if s <= q then
+begin
+dec(q, s);
+inc(r, t);
+end;
+t:= t shr 2;
+end;
+hwSqrt.QWordValue:= r shl 16
+end;
 function Distance(const dx, dy: hwFloat): hwFloat;
-begin
+var r: QWord;
-Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy))
+begin
+r:= dx.QWordValue or dy.QWordValue;
+if r < $10000 then
+begin
+Distance.QWordValue:= r;
+Distance.isNegative:= false
+end else
+Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy))
 end;
 function DistanceI(const dx, dy: LongInt): hwFloat;
 begin
 DistanceI:= hwSqrt(int2hwFloat(sqr(dx) + sqr(dy)))

branch	0.9.19
changeset 8924	13ac59499066
parent 8921	e5db2a42e7e8
child 9080	9b42757d7e71