Skip to content

Commit 5a052e6

Browse files
elect86elect86
committed
- frexp
- increased core fun common coverage
1 parent dade97a commit 5a052e6

File tree

14 files changed

+1751
-301
lines changed

14 files changed

+1751
-301
lines changed

‎src/main/kotlin/glm_/epsilon.kt‎

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ import glm_.quat.Quat
88
import glm_.quat.QuatD
99
import glm_.vec1.Vec1
1010
import glm_.vec1.Vec1bool
11+
import glm_.vec1.Vec1d
1112
import glm_.vec2.*
1213
import glm_.vec3.*
1314
import glm_.vec4.*
@@ -36,6 +37,24 @@ interface epsilon {
3637

3738
fun epsilonEqual(a: Vec1, b: Vec1, epsilon: Float, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1(epsilon), res)
3839
fun epsilonEqual(a: Vec1, b: Vec1, epsilon: Vec1, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), epsilon)
40+
// TODO
41+
// fun epsilonEqual(a: Vec1b, b: Vec1b, epsilon: Byte, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1b(epsilon), res)
42+
// fun epsilonEqual(a: Vec1b, b: Vec1b, epsilon: Int, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1b(epsilon), res)
43+
// fun epsilonEqual(a: Vec1b, b: Vec1b, epsilon: Vec1b, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), epsilon)
44+
45+
fun epsilonEqual(a: Vec1d, b: Vec1d, epsilon: Double, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1d(epsilon), res)
46+
fun epsilonEqual(a: Vec1d, b: Vec1d, epsilon: Vec1d, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), epsilon)
47+
48+
// fun epsilonEqual(a: Vec1i, b: Vec1i, epsilon: Int, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1i(epsilon), res)
49+
// fun epsilonEqual(a: Vec1i, b: Vec1i, epsilon: Vec1i, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), epsilon)
50+
//
51+
// fun epsilonEqual(a: Vec1l, b: Vec1l, epsilon: Long, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1l(epsilon), res)
52+
// fun epsilonEqual(a: Vec1l, b: Vec1l, epsilon: Vec1l, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), epsilon)
53+
//
54+
// fun epsilonEqual(a: Vec1s, b: Vec1s, epsilon: Short, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1s(epsilon), res)
55+
// fun epsilonEqual(a: Vec1s, b: Vec1s, epsilon: Int, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), Vec1s(epsilon), res)
56+
// fun epsilonEqual(a: Vec1s, b: Vec1s, epsilon: Vec1s, res: Vec1bool = Vec1bool()) = lessThan(abs(a - b), epsilon)
57+
3958

4059
fun epsilonEqual(a: Vec2, b: Vec2, epsilon: Float, res: Vec2bool = Vec2bool()) = lessThan(abs(a - b), Vec2(epsilon), res)
4160
fun epsilonEqual(a: Vec2, b: Vec2, epsilon: Vec2, res: Vec2bool = Vec2bool()) = lessThan(abs(a - b), epsilon)
@@ -100,6 +119,27 @@ interface epsilon {
100119
fun epsilonEqual(a: Vec4s, b: Vec4s, epsilon: Vec4s, res: Vec4bool = Vec4bool()) = lessThan(abs(a - b), epsilon)
101120

102121

122+
fun epsilonNotEqual(a: Vec1, b: Vec1, epsilon: Float, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1(epsilon), res)
123+
fun epsilonNotEqual(a: Vec1, b: Vec1, epsilon: Vec1, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), epsilon)
124+
125+
// fun epsilonNotEqual(a: Vec1b, b: Vec1b, epsilon: Byte, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1b(epsilon), res)
126+
// fun epsilonNotEqual(a: Vec1b, b: Vec1b, epsilon: Int, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1b(epsilon), res)
127+
// fun epsilonNotEqual(a: Vec1b, b: Vec1b, epsilon: Vec1b, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), epsilon)
128+
129+
fun epsilonNotEqual(a: Vec1d, b: Vec1d, epsilon: Double, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1d(epsilon), res)
130+
fun epsilonNotEqual(a: Vec1d, b: Vec1d, epsilon: Vec1d, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), epsilon)
131+
132+
// fun epsilonNotEqual(a: Vec1i, b: Vec1i, epsilon: Int, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1i(epsilon), res)
133+
// fun epsilonNotEqual(a: Vec1i, b: Vec1i, epsilon: Vec1i, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), epsilon)
134+
//
135+
// fun epsilonNotEqual(a: Vec1l, b: Vec1l, epsilon: Long, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1l(epsilon), res)
136+
// fun epsilonNotEqual(a: Vec1l, b: Vec1l, epsilon: Vec1l, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), epsilon)
137+
//
138+
// fun epsilonNotEqual(a: Vec1s, b: Vec1s, epsilon: Short, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1s(epsilon), res)
139+
// fun epsilonNotEqual(a: Vec1s, b: Vec1s, epsilon: Int, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), Vec1s(epsilon), res)
140+
// fun epsilonNotEqual(a: Vec1s, b: Vec1s, epsilon: Vec1s, res: Vec1bool = Vec1bool()) = greaterThan(abs(a - b), epsilon)
141+
142+
103143
fun epsilonNotEqual(a: Vec2, b: Vec2, epsilon: Float, res: Vec2bool = Vec2bool()) = greaterThan(abs(a - b), Vec2(epsilon), res)
104144
fun epsilonNotEqual(a: Vec2, b: Vec2, epsilon: Vec2, res: Vec2bool = Vec2bool()) = greaterThan(abs(a - b), epsilon)
105145

‎src/main/kotlin/glm_/func/common/func_common.kt‎

Lines changed: 116 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@ import unsigned.Uint
1919
import unsigned.Ulong
2020
import kotlin.math.absoluteValue
2121
import kotlin.math.sign
22+
import kotlin.reflect.KMutableProperty0
2223
import kotlin.math.ceil as _ceil
2324
import kotlin.math.floor as _floor
2425
import kotlin.math.max as _max
@@ -55,8 +56,23 @@ interface func_common {
5556
fun trunc(a: Double) = if (a < 0) -floor(-a) else floor(a)
5657

5758

58-
fun round(a: Float) = Math.round(a).f //if (a < 0) -floor(-a) else floor(a)
59-
fun round(a: Double) = Math.round(a).d//if (a < 0) -floor(-a) else floor(a)
59+
fun round(a: Float) = when {
60+
a >= 0 -> Math.round(a).f
61+
else -> {
62+
val i = floor(a) // integer portion
63+
val f = a - i // fractional portion
64+
if (f <= 0.5f) i else i + 1f // round integer portion based on fractional portion
65+
}
66+
}
67+
68+
fun round(a: Double) = when {
69+
a >= 0 -> Math.round(a).d
70+
else -> {
71+
val i = floor(a) // integer portion
72+
val f = a - i // fractional portion
73+
if (f <= 0.5) i else i + 1.0 // round integer portion based on fractional portion
74+
}
75+
}
6076

6177

6278
fun roundEven(a: Float) = _round(a)
@@ -71,11 +87,20 @@ interface func_common {
7187
fun fract(a: Double) = a - floor(a)
7288

7389

74-
fun mod(a: Float, b: Float) = a % b
75-
fun mod(a: Double, b: Double) = a % b
90+
fun mod(a: Float, b: Float) = a - b * floor(a / b)
91+
fun mod(a: Double, b: Double) = a - b * floor(a / b)
7692

93+
fun modf(a: Float, b: KMutableProperty0<Float>): Float {
94+
val res = a % 1f
95+
b.set(a - res)
96+
return res
97+
}
7798

78-
// TODO modf
99+
fun modf(a: Double, b: KMutableProperty0<Double>): Double {
100+
val res = a % 1.0
101+
b.set(a - res)
102+
return res
103+
}
79104

80105

81106
fun min(a: Float, b: Float) = _min(a, b)
@@ -146,7 +171,92 @@ interface func_common {
146171
fun fma(a: Double, b: Double, c: Double) = a * b + c
147172

148173

149-
// TODO frexp, ldexp
174+
fun frexp(a: Float, exp: KMutableProperty0<Int>): Float {
175+
176+
val bits = a.toIntBits
177+
var realMant = 1f
178+
179+
// Test for NaN, infinity, and zero.
180+
return when {
181+
a.isNaN || a + a == a || a.isInfinite -> {
182+
exp.set(0)
183+
a
184+
}
185+
else -> {
186+
val neg = bits < 0
187+
var exponent = (bits ushr 23) and 0xff
188+
var mantissa = bits and 0xffffff
189+
190+
if (exponent == 0)
191+
exponent++
192+
else
193+
mantissa = mantissa or (1 shl 23)
194+
195+
/* bias the exponent - actually biased by 127.
196+
we are treating the mantissa as m.0 instead of 0.m so subtract another 23. */
197+
exponent -= 150
198+
realMant = mantissa.f
199+
200+
// normalize
201+
while (realMant > 1f) {
202+
mantissa = mantissa ushr 1
203+
realMant /= 2f
204+
exponent++
205+
}
206+
207+
if (neg)
208+
realMant *= -1
209+
210+
exp.set(exponent)
211+
realMant
212+
}
213+
}
214+
}
215+
216+
fun frexp(a: Double, exp: KMutableProperty0<Int>): Double {
217+
218+
val bits = a.toLongBits
219+
var realMant = 1.0
220+
221+
// Test for NaN, infinity, and zero.
222+
return when {
223+
a.isNaN || a + a == a || a.isInfinite -> {
224+
exp.set(0)
225+
a
226+
}
227+
else -> {
228+
val neg = bits < 0
229+
var exponent = ((bits ushr 52) and 0x7ffL).i
230+
var mantissa = bits and 0xfffffffffffffL
231+
232+
if (exponent == 0)
233+
exponent++
234+
else
235+
mantissa = mantissa or (1L shl 52)
236+
237+
/* bias the exponent - actually biased by 1023.
238+
we are treating the mantissa as m.0 instead of 0.m so subtract another 52. */
239+
exponent -= 1075
240+
realMant = mantissa.d
241+
242+
// normalize
243+
while (realMant > 1.0) {
244+
mantissa = mantissa ushr 1
245+
realMant /= 2.0
246+
exponent++
247+
}
248+
249+
if (neg)
250+
realMant *= -1
251+
252+
exp.set(exponent)
253+
realMant
254+
}
255+
}
256+
}
257+
258+
259+
// TODO ldexp
150260
}
151261

152262

0 commit comments

Comments
 (0)