v / vlib / math / vec / vec4_test.v
151 lines · 131 sloc · 3.23 KB · a8a5e80f416a09fa60279eea521351a54451bb40
Raw 


1import math { tolerance }


2import math.vec


3


4fn test_vec4_int() {


5    mut v1 := vec.vec4(0, 0, 0, 0)


6    mut v2 := vec.vec4(0, 0, 0, 0)


7    assert v1 == v2


8    v1.one()


9    v2.one()


10    assert v1.x == 1


11    assert v1.y == 1


12    assert v1.z == 1


13    assert v1.w == 1


14    assert v1 == v2


15


16    v3 := v1 + v2


17    assert typeof(v3).name == 'vec.Vec4[int]'


18    assert v3.x == 2


19    assert v3.y == 2


20    assert v3.z == 2


21    assert v3.w == 2


22}


23


24fn test_vec4_f32() {


25    mut v1 := vec.vec4(f32(0), 0, 0, 0)


26    mut v2 := vec.vec4(f32(0), 0, 0, 0)


27    assert v1 == v2


28    v1.one()


29    v2.one()


30    assert v1.x == 1


31    assert v1.y == 1


32    assert v1.z == 1


33    assert v1.w == 1


34    assert v1 == v2


35


36    v3 := v1 + v2


37    assert typeof(v3).name == 'vec.Vec4[f32]'


38    assert v3.x == 2


39    assert v3.y == 2


40    assert v3.z == 2


41    assert v3.w == 2


42}


43


44fn test_vec4_f64() {


45    mut v1 := vec.vec4(0.0, 0, 0, 0)


46    mut v2 := vec.vec4(0.0, 0, 0, 0)


47    assert v1 == v2


48    v1.one()


49    v2.one()


50    assert v1.x == 1


51    assert v1.y == 1


52    assert v1.z == 1


53    assert v1.w == 1


54    assert v1 == v2


55


56    v3 := v1 + v2


57    assert typeof(v3).name == 'vec.Vec4[f64]'


58    assert v3.x == 2


59    assert v3.y == 2


60    assert v3.z == 2


61    assert v3.w == 2


62}


63


64fn test_vec4_f64_utils_1() {


65    mut v1 := vec.vec4(2.0, 3.0, 1.5, 3.0)


66    mut v2 := vec.vec4(1.0, 4.0, 1.5, 3.0)


67


68    mut zv := vec.vec4(5.0, 5.0, 5.0, 5.0)


69    zv.zero()


70


71    v3 := v1 + v2


72    assert v3.x == 3


73    assert v3.y == 7


74    assert v3.z == 3


75    assert v3.w == 6


76


77    assert v3.unit().magnitude() == 1


78


79    mut ctv1 := vec.vec4(0.000001, 0.000001, 0.000001, 0.000001)


80    ctv1.clean_tolerance(0.00001)


81    assert ctv1 == zv


82}


83


84fn test_vec4_f64_utils_2() {


85    mut v1 := vec.vec4(4.0, 4.0, 8.0, 2.0)


86    assert v1.unit().magnitude() == 1


87


88    v2 := v1.mul_scalar(0.5)


89    assert v2.x == 2


90    assert v2.y == 2


91    assert v2.z == 4


92    assert v2.w == 1


93    assert v2.unit().magnitude() == 1


94


95    invv2 := v2.inv()


96    assert invv2.x == 0.5


97    assert invv2.y == 0.5


98    assert invv2.z == 0.25


99    assert invv2.w == 1.0


100}


101


102// sample tests for vec4 projection


103fn test_vec4_project_onto_basic() {


104    v := vec.vec4(5.0, 6.0, 0.0, 0.0) // magnitude ~7.81 vector


105    u := vec.vec4(3.0, 4.0, 0.0, 0.0) // magnitude 5 vector


106    // hand-computed:


107    // v·u = 5*3 + 6*4 + 0*0 + 0*0 = 39


108    // |u|^2 = 3^2 + 4^2 +0^2 +0^2 = 25


109    proj := v.project(u)


110    assert proj.x == 4.68


111    assert proj.y == 6.24


112    assert proj.z == 0.0


113    assert proj.w == 0.0


114}


115


116// Test for Vec4 projection onto zero vector


117//


118fn test_vec4_project_onto_zero() {


119    v := vec.vec4(0.0, 0.0, 0.0, 0.0)


120    u := vec.vec4(3.0, 4.0, 0.0, 0.0)


121    proj := v.project(u)


122    assert proj.x == 0.0


123    assert proj.y == 0.0


124    assert proj.z == 0.0


125    assert proj.w == 0.0


126}


127


128// Test for perpendicularity


129// 'u' and 'v' are already perpendicular so it must return v


130fn test_vec4_perpendicularity_angle() {


131    u := vec.vec4(1.0, 0.0, 0.0, 0.0)


132    v := vec.vec4(0.0, 3.0, 2.0, 0.0)


133


134    per := v.perpendicular(u)


135    assert tolerance(per.x, v.x, vec.vec_epsilon)


136    assert tolerance(per.y, v.y, vec.vec_epsilon)


137    assert tolerance(per.z, v.z, vec.vec_epsilon)


138    assert tolerance(per.w, v.w, vec.vec_epsilon)


139}


140


141// 'u' and 'v' are collinear so it must return the null vector


142fn test_vec4_collinear() {


143    u := vec.vec4(1.0, 0.0, 0.0, 0.0)


144    v := vec.vec4(3.0, 0.0, 0.0, 0.0)


145


146    per := v.perpendicular(u)


147    assert tolerance(per.x, 0.0, vec.vec_epsilon)


148    assert tolerance(per.y, 0.0, vec.vec_epsilon)


149    assert tolerance(per.z, 0.0, vec.vec_epsilon)


150    assert tolerance(per.w, 0.0, vec.vec_epsilon)


151}


152