efl

1
/* EINA - EFL data type library
2
 * Copyright (C) 2016 Sergey Osadchy
3
 *
4
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * This library is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library;
16
 * if not, see <http://www.gnu.org/licenses/>.
17
 */
18

19
#ifdef HAVE_CONFIG_H
20
# include "config.h"
21
#endif
22

23
#include <math.h>
24
#include <float.h>
25
#include <limits.h>
26

27
#include <Eina.h>
28

29
#include "eina_suite.h"
30

31
EFL_START_TEST(eina_test_vector2_operations)
32
{
33
   Eina_Vector2 v1;
34
   Eina_Vector2 v2;
35
   Eina_Vector2 v3;
36
   Eina_Matrix2 m2;
37
   Eina_Matrix3 m3;
38
   double x = 1;
39
   double y = 2;
40
   double res = 0;
41
   const double arr[] = {5, 5};
42

43

44
   eina_vector2_set(&v1, x, y);
45
   fail_if(!EINA_DBL_EQ(v1.x, 1) || !EINA_DBL_EQ(v1.y, 2));
46

47
   eina_vector2_array_set(&v2, arr);
48
   fail_if(!EINA_DBL_EQ(v2.x, 5) || !EINA_DBL_EQ(v2.y, 5));
49

50
   eina_vector2_copy(&v1, &v2);
51
   fail_if(!EINA_DBL_EQ(v1.x, 5) || !EINA_DBL_EQ(v1.y, 5));
52

53
   eina_vector2_negate(&v1, &v2);
54
   fail_if(!EINA_DBL_EQ(v1.x, -5) || !EINA_DBL_EQ(v1.y, -5));
55

56
   eina_vector2_set(&v1, x, y);
57
   eina_vector2_add(&v3, &v1, &v2);
58
   fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 7));
59

60
   eina_vector2_subtract(&v3, &v2, &v1);
61
   fail_if(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 3));
62

63
   eina_vector2_scale(&v3, &v1, y);
64
   fail_if(!EINA_DBL_EQ(v3.x, 2) || !EINA_DBL_EQ(v3.y, 4));
65

66
   res = eina_vector2_dot_product(&v1, &v2);
67
   fail_if(!EINA_DBL_EQ(res, 15));
68

69
   res = eina_vector2_length_get(&v2);
70
   fail_if((res - sqrt(50)) > DBL_EPSILON);
71

72
   res = eina_vector2_length_square_get(&v2);
73
   fail_if(!EINA_DBL_EQ(res, 50));
74

75
   res = eina_vector2_distance_get(&v2, &v1);
76
   fail_if((res - sqrt(25)) > DBL_EPSILON);
77

78
   res = eina_vector2_distance_square_get(&v2, &v1);
79
   fail_if(!EINA_DBL_EQ(res, 25));
80

81
   eina_vector2_normalize(&v3, &v2);
82
   fail_if((v3.x - v2.x / sqrt(50)) > DBL_EPSILON ||
83
           (v3.y - v2.y / sqrt(50)) > DBL_EPSILON);
84

85
   eina_matrix2_values_set(&m2,
86
                          2, 2,
87
                          2, 2);
88
   eina_vector2_transform(&v3, &m2, &v1);
89
   fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 6));
90

91
   eina_vector2_transform(&v3, &m2, &v3);
92
   fail_if(!EINA_DBL_EQ(v3.x, 24) || !EINA_DBL_EQ(v3.y, 24));
93

94
   eina_matrix3_values_set(&m3,
95
                          2, 2, 2,
96
                          2, 2, 2,
97
                          2, 2, 2);
98

99
   eina_vector2_homogeneous_position_transform(&v3, &m3, &v1);
100
   fail_if(!EINA_DBL_EQ(v3.x, 1) || !EINA_DBL_EQ(v3.y, 1));
101

102

103
   eina_vector2_homogeneous_direction_transform(&v3, &m3, &v1);
104
   fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 6));
105

106
   eina_vector2_homogeneous_direction_transform(&v3, &m3, &v3);
107
   fail_if(!EINA_DBL_EQ(v3.x, 24) || !EINA_DBL_EQ(v3.y, 24));
108

109
}
110
EFL_END_TEST
111

112
EFL_START_TEST(eina_test_vector3_operations)
113
{
114
   Eina_Vector3 v1;
115
   Eina_Vector3 v2;
116
   Eina_Vector3 v3;
117
   Eina_Matrix3 m3;
118
   Eina_Matrix4 m4;
119
   Eina_Quaternion q;
120
   double x = 1;
121
   double y = 2;
122
   double z = 3;
123
   double res = 0;
124
   Eina_Bool res2 = EINA_FALSE;
125
   const double arr[] = {5, 5, 5};
126

127

128
   eina_vector3_set(&v1, x, y, z);
129
   fail_if(!EINA_DBL_EQ(v1.x, 1) || !EINA_DBL_EQ(v1.y, 2) || !EINA_DBL_EQ(v1.z, 3));
130

131
   eina_vector3_array_set(&v2, arr);
132
   fail_if(!EINA_DBL_EQ(v2.x, 5) || !EINA_DBL_EQ(v2.y, 5) || !EINA_DBL_EQ(v2.z, 5));
133

134
   eina_vector3_copy(&v1, &v2);
135
   fail_if(!EINA_DBL_EQ(v1.x, 5) || !EINA_DBL_EQ(v1.y, 5) || !EINA_DBL_EQ(v1.z, 5));
136

137
   eina_vector3_negate(&v1, &v2);
138
   fail_if(!EINA_DBL_EQ(v1.x, -5) || !EINA_DBL_EQ(v1.y, -5) || !EINA_DBL_EQ(v1.z, -5));
139

140
   eina_vector3_set(&v1, x, y, z);
141
   eina_vector3_add(&v3, &v1, &v2);
142
   fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 7) || !EINA_DBL_EQ(v3.z, 8));
143

144
   eina_vector3_subtract(&v3, &v2, &v1);
145
   fail_if(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 3) || !EINA_DBL_EQ(v3.z, 2));
146

147
   eina_vector3_scale(&v3, &v1, y);
148
   fail_if(!EINA_DBL_EQ(v3.x, 2) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, 6));
149

150
   eina_vector3_multiply(&v3, &v2, &v1);
151
   fail_if(!EINA_DBL_EQ(v3.x, 5) || !EINA_DBL_EQ(v3.y, 10) || !EINA_DBL_EQ(v3.z, 15));
152

153
   res = eina_vector3_dot_product(&v1, &v2);
154
   fail_if(!EINA_DBL_EQ(res, 30));
155

156
   eina_vector3_cross_product(&v3, &v1, &v2);
157
   fail_if(!EINA_DBL_EQ(v3.x, -5) || !EINA_DBL_EQ(v3.y, 10) || !EINA_DBL_EQ(v3.z, -5));
158

159
   eina_vector3_cross_product(&v3, &v1, &v3);
160
   fail_if(!EINA_DBL_EQ(v3.x, -40) || !EINA_DBL_EQ(v3.y, -10) || !EINA_DBL_EQ(v3.z, 20));
161

162

163
   res = eina_vector3_length_get(&v2);
164
   fail_if((res - sqrt(75)) > DBL_EPSILON);
165

166
   res = eina_vector3_length_square_get(&v2);
167
   fail_if(!EINA_DBL_EQ(res, 75));
168

169
   res = eina_vector3_distance_get(&v2, &v1);
170
   fail_if((res - sqrt(29)) > (DBL_EPSILON * 2.0));
171

172
   res = eina_vector3_distance_square_get(&v2, &v1);
173
   fail_if(!EINA_DBL_EQ(res, 29));
174

175
   eina_vector3_normalize(&v3, &v2);
176
   fail_if((v3.x - v2.x / sqrt(75)) > DBL_EPSILON ||
177
           (v3.y - v2.y / sqrt(75)) > DBL_EPSILON ||
178
           (v3.z - v2.z / sqrt(75)) > DBL_EPSILON);
179

180
   res = eina_vector3_angle_get(&v1, &v2);
181
   fail_if((res - (30 / (sqrt(14) * sqrt(75)))) > DBL_EPSILON);
182

183
   eina_matrix3_values_set(&m3,
184
                          2, 2, 2,
185
                          2, 2, 2,
186
                          2, 2, 2);
187
   eina_vector3_transform(&v3, &m3, &v1);
188
   fail_if(!EINA_DBL_EQ(v3.x, 12) || !EINA_DBL_EQ(v3.y, 12) || !EINA_DBL_EQ(v3.z, 12));
189

190
   eina_vector3_transform(&v3, &m3, &v3);
191
   fail_if(!EINA_DBL_EQ(v3.x, 72) || !EINA_DBL_EQ(v3.y, 72) || !EINA_DBL_EQ(v3.z, 72));
192

193
   eina_matrix4_values_set(&m4,
194
                          2, 2, 2, 2,
195
                          2, 2, 2, 2,
196
                          2, 2, 2, 2,
197
                          2, 2, 2, 2);
198
   eina_vector3_homogeneous_position_transform(&v3, &m4, &v1);
199
   fail_if(!EINA_DBL_EQ(v3.x, 1) || !EINA_DBL_EQ(v3.y, 1) || !EINA_DBL_EQ(v3.z, 1));
200

201
   eina_quaternion_set(&q, 2, 2, 2, 0);
202
   eina_vector3_quaternion_rotate(&v3, &v1, &q);
203
   fail_if(!EINA_DBL_EQ(v3.x, 25) || !EINA_DBL_EQ(v3.y, 2) || !EINA_DBL_EQ(v3.z, -21));
204

205
   eina_vector3_orthogonal_projection_on_plane(&v3, &v1, &v2);
206
   fail_if(!EINA_DBL_EQ(v3.x, -1) || !EINA_DBL_EQ(v3.y, 0) || !EINA_DBL_EQ(v3.z, 1));
207

208
   eina_vector3_plane_by_points(&q, &v3, &v1, &v2);
209
   fail_if(!EINA_DBL_EQ(q.x, -2) || !EINA_DBL_EQ(q.y, 4) || !EINA_DBL_EQ(q.z, -2) || (q.z > DBL_EPSILON));
210

211
   eina_vector3_homogeneous_direction_set(&v3, &q);
212
   fail_if(!EINA_DBL_EQ(v3.x, -2) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, -2));
213

214
   eina_quaternion_set(&q, 2, 2, 2, 0.5);
215
   eina_vector3_homogeneous_position_set(&v3, &q);
216
   fail_if(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, 4));
217

218
   res2 = eina_vector3_equivalent(&v1, &v2);
219
   fail_if(res2 != EINA_FALSE);
220

221
   res2 = eina_vector3_equivalent(&v1, &v1);
222
   fail_if(res2 != EINA_TRUE);
223

224
   res2 = eina_vector3_triangle_equivalent(&v1, &v2, &v3,
225
                                           &v2, &v3, &v1);
226
   fail_if(res2 != EINA_FALSE);
227

228
   res2 = eina_vector3_triangle_equivalent(&v1, &v2, &v3,
229
                                           &v1, &v2, &v3);
230
   fail_if(res2 != EINA_TRUE);
231

232
   eina_vector3_homogeneous_direction_transform(&v3, &m4, &v1);
233
   fail_if(!EINA_DBL_EQ(v3.x, 12) || !EINA_DBL_EQ(v3.y, 12) || !EINA_DBL_EQ(v3.z, 12));
234

235
   eina_vector3_homogeneous_direction_transform(&v3, &m4, &v3);
236
   fail_if(!EINA_DBL_EQ(v3.x, 72) || !EINA_DBL_EQ(v3.y, 72) || !EINA_DBL_EQ(v3.z, 72));
237

238
}
239
EFL_END_TEST
240

241
void
242
eina_test_vector(TCase *tc)
243
{
244
   tcase_add_test(tc, eina_test_vector2_operations);
245
   tcase_add_test(tc, eina_test_vector3_operations);
246
}
247