1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 // Flags: --simd_object --allow-natives-syntax
30 function testConstructor() {
31 var f4 = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
32 assertEquals(1.0, f4.x);
33 assertEquals(2.0, f4.y);
34 assertEquals(3.0, f4.z);
35 assertEquals(4.0, f4.w);
37 f4 = SIMD.float32x4(1.1, 2.2, 3.3, 4.4);
38 assertEquals(1.100000023841858, f4.x);
39 assertEquals(2.200000047683716, f4.y);
40 assertEquals(3.299999952316284, f4.z);
41 assertEquals(4.400000095367432, f4.w);
46 %OptimizeFunctionOnNextCall(testConstructor);
49 function test1ArgumentConstructor() {
50 var f4 = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
51 var f4_new = SIMD.float32x4(f4);
52 assertEquals(f4_new.x, f4.x);
53 assertEquals(f4_new.y, f4.y);
54 assertEquals(f4_new.z, f4.z);
55 assertEquals(f4_new.w, f4.w);
57 f4 = SIMD.float32x4(1.1, 2.2, 3.3, 4.4);
58 f4_new = SIMD.float32x4(f4);
59 assertEquals(f4_new.x, f4.x);
60 assertEquals(f4_new.y, f4.y);
61 assertEquals(f4_new.z, f4.z);
62 assertEquals(f4_new.w, f4.w);
65 test1ArgumentConstructor();
66 test1ArgumentConstructor();
67 %OptimizeFunctionOnNextCall(test1ArgumentConstructor);
68 test1ArgumentConstructor();
70 function testZeroConstructor() {
71 var z4 = SIMD.float32x4.zero();
72 assertEquals(0.0, z4.x);
73 assertEquals(0.0, z4.y);
74 assertEquals(0.0, z4.z);
75 assertEquals(0.0, z4.w);
78 testZeroConstructor();
79 testZeroConstructor();
80 %OptimizeFunctionOnNextCall(testZeroConstructor);
81 testZeroConstructor();
83 function testSplatConstructor() {
84 var z4 = SIMD.float32x4.splat(5.0);
85 assertEquals(5.0, z4.x);
86 assertEquals(5.0, z4.y);
87 assertEquals(5.0, z4.z);
88 assertEquals(5.0, z4.w);
91 testSplatConstructor();
92 testSplatConstructor();
93 %OptimizeFunctionOnNextCall(testSplatConstructor);
94 testSplatConstructor();
96 function testTypeof() {
97 var z4 = SIMD.float32x4.zero();
98 assertEquals(typeof(z4), "object");
100 var new_z4 = new SIMD.float32x4(0, 0, 0, 0);
101 assertEquals(typeof(new_z4), "object");
102 assertEquals(typeof(new_z4.valueOf()), "object");
103 assertEquals(Object.prototype.toString.call(new_z4), "[object Object]");
108 function testSignMaskGetter() {
109 var a = SIMD.float32x4(-1.0, -2.0, -3.0, -4.0);
110 assertEquals(0xf, a.signMask);
111 var b = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
112 assertEquals(0x0, b.signMask);
113 var c = SIMD.float32x4(1.0, -2.0, -3.0, 4.0);
114 assertEquals(0x6, c.signMask);
117 testSignMaskGetter();
118 testSignMaskGetter();
119 %OptimizeFunctionOnNextCall(testSignMaskGetter);
120 testSignMaskGetter();
122 function testSIMDAbs() {
123 var a4 = SIMD.float32x4(1.0, -1.0, 1.0, -1.0);
124 var b4 = SIMD.float32x4.abs(a4);
126 assertEquals(1.0, b4.x);
127 assertEquals(1.0, b4.y);
128 assertEquals(1.0, b4.z);
129 assertEquals(1.0, b4.w);
134 %OptimizeFunctionOnNextCall(testSIMDAbs);
137 function testSIMDNeg() {
138 var a4 = SIMD.float32x4(1.0, -1.0, 1.0, -1.0);
139 var b4 = SIMD.float32x4.neg(a4);
141 assertEquals(-1.0, b4.x);
142 assertEquals(1.0, b4.y);
143 assertEquals(-1.0, b4.z);
144 assertEquals(1.0, b4.w);
149 %OptimizeFunctionOnNextCall(testSIMDNeg);
152 function testSIMDAdd() {
153 var a4 = SIMD.float32x4(1.0, 1.0, 1.0, 1.0);
154 var b4 = SIMD.float32x4(2.0, 2.0, 2.0, 2.0);
155 var c4 = SIMD.float32x4.add(a4, b4);
157 assertEquals(3.0, c4.x);
158 assertEquals(3.0, c4.y);
159 assertEquals(3.0, c4.z);
160 assertEquals(3.0, c4.w);
165 %OptimizeFunctionOnNextCall(testSIMDAdd);
168 function testSIMDSub() {
169 var a4 = SIMD.float32x4(1.0, 1.0, 1.0, 1.0);
170 var b4 = SIMD.float32x4(2.0, 2.0, 2.0, 2.0);
171 var c4 = SIMD.float32x4.sub(a4, b4);
173 assertEquals(-1.0, c4.x);
174 assertEquals(-1.0, c4.y);
175 assertEquals(-1.0, c4.z);
176 assertEquals(-1.0, c4.w);
181 %OptimizeFunctionOnNextCall(testSIMDSub);
184 function testSIMDMul() {
185 var a4 = SIMD.float32x4(1.0, 1.0, 1.0, 1.0);
186 var b4 = SIMD.float32x4(2.0, 2.0, 2.0, 2.0);
187 var c4 = SIMD.float32x4.mul(a4, b4);
189 assertEquals(2.0, c4.x);
190 assertEquals(2.0, c4.y);
191 assertEquals(2.0, c4.z);
192 assertEquals(2.0, c4.w);
197 %OptimizeFunctionOnNextCall(testSIMDMul);
200 function testSIMDDiv() {
201 var a4 = SIMD.float32x4(1.0, 1.0, 1.0, 1.0);
202 var b4 = SIMD.float32x4(2.0, 2.0, 2.0, 2.0);
203 var c4 = SIMD.float32x4.div(a4, b4);
205 assertEquals(0.5, c4.x);
206 assertEquals(0.5, c4.y);
207 assertEquals(0.5, c4.z);
208 assertEquals(0.5, c4.w);
213 %OptimizeFunctionOnNextCall(testSIMDDiv);
216 function testSIMDClamp() {
217 var m = SIMD.float32x4(1.0, -2.0, 3.0, -4.0);
218 var lo = SIMD.float32x4(0.0, 0.0, 0.0, 0.0);
219 var hi = SIMD.float32x4(2.0, 2.0, 2.0, 2.0);
220 m = SIMD.float32x4.clamp(m, lo, hi);
221 assertEquals(1.0, m.x);
222 assertEquals(0.0, m.y);
223 assertEquals(2.0, m.z);
224 assertEquals(0.0, m.w);
229 %OptimizeFunctionOnNextCall(testSIMDClamp);
232 function testSIMDMin() {
233 var m = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
234 var n = SIMD.float32x4(1.0, 0.0, 2.5, 5.0);
235 m = SIMD.float32x4.min(m, n);
236 assertEquals(1.0, m.x);
237 assertEquals(0.0, m.y);
238 assertEquals(2.5, m.z);
239 assertEquals(4.0, m.w);
244 %OptimizeFunctionOnNextCall(testSIMDMin);
247 function testSIMDMax() {
248 var m = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
249 var n = SIMD.float32x4(1.0, 0.0, 2.5, 5.0);
250 m = SIMD.float32x4.max(m, n);
251 assertEquals(1.0, m.x);
252 assertEquals(2.0, m.y);
253 assertEquals(3.0, m.z);
254 assertEquals(5.0, m.w);
259 %OptimizeFunctionOnNextCall(testSIMDMax);
262 function testSIMDReciprocal() {
263 var m = SIMD.float32x4(1.0, 4.0, 9.0, 16.0);
264 m = SIMD.float32x4.reciprocal(m);
265 assertTrue(Math.abs(1.0 - m.x) <= 0.001);
266 assertTrue(Math.abs(0.25 - m.y) <= 0.001);
267 assertTrue(Math.abs(0.1111111 - m.z) <= 0.001);
268 assertTrue(Math.abs(0.0625 - m.w) <= 0.001);
271 testSIMDReciprocal();
272 testSIMDReciprocal();
273 %OptimizeFunctionOnNextCall(testSIMDReciprocal);
274 testSIMDReciprocal();
276 function testSIMDReciprocalSqrt() {
277 var m = SIMD.float32x4(1.0, 0.25, 0.111111, 0.0625);
278 m = SIMD.float32x4.reciprocalSqrt(m);
279 assertTrue(Math.abs(1.0 - m.x) <= 0.001);
280 assertTrue(Math.abs(2.0 - m.y) <= 0.001);
281 assertTrue(Math.abs(3.0 - m.z) <= 0.001);
282 assertTrue(Math.abs(4.0 - m.w) <= 0.001);
285 testSIMDReciprocalSqrt();
286 testSIMDReciprocalSqrt();
287 %OptimizeFunctionOnNextCall(testSIMDReciprocalSqrt);
288 testSIMDReciprocalSqrt();
290 function testSIMDScale() {
291 var m = SIMD.float32x4(1.0, -2.0, 3.0, -4.0);
292 m = SIMD.float32x4.scale(m, 20.0);
293 assertEquals(20.0, m.x);
294 assertEquals(-40.0, m.y);
295 assertEquals(60.0, m.z);
296 assertEquals(-80.0, m.w);
301 %OptimizeFunctionOnNextCall(testSIMDScale);
304 function testSIMDSqrt() {
305 var m = SIMD.float32x4(1.0, 4.0, 9.0, 16.0);
306 m = SIMD.float32x4.sqrt(m);
307 assertEquals(1.0, m.x);
308 assertEquals(2.0, m.y);
309 assertEquals(3.0, m.z);
310 assertEquals(4.0, m.w);
315 %OptimizeFunctionOnNextCall(testSIMDSqrt);
318 function testSIMDShuffle() {
319 var m = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
320 var xxxx = SIMD.float32x4.shuffle(m, SIMD.XXXX);
321 assertEquals(1.0, xxxx.x);
322 assertEquals(1.0, xxxx.y);
323 assertEquals(1.0, xxxx.z);
324 assertEquals(1.0, xxxx.w);
325 var yyyy = SIMD.float32x4.shuffle(m, SIMD.YYYY);
326 assertEquals(2.0, yyyy.x);
327 assertEquals(2.0, yyyy.y);
328 assertEquals(2.0, yyyy.z);
329 assertEquals(2.0, yyyy.w);
330 var zzzz = SIMD.float32x4.shuffle(m, SIMD.ZZZZ);
331 assertEquals(3.0, zzzz.x);
332 assertEquals(3.0, zzzz.y);
333 assertEquals(3.0, zzzz.z);
334 assertEquals(3.0, zzzz.w);
335 var wwww = SIMD.float32x4.shuffle(m, SIMD.WWWW);
336 assertEquals(4.0, wwww.x);
337 assertEquals(4.0, wwww.y);
338 assertEquals(4.0, wwww.z);
339 assertEquals(4.0, wwww.w);
340 var wzyx = SIMD.float32x4.shuffle(m, SIMD.WZYX);
341 assertEquals(4.0, wzyx.x);
342 assertEquals(3.0, wzyx.y);
343 assertEquals(2.0, wzyx.z);
344 assertEquals(1.0, wzyx.w);
345 var wwzz = SIMD.float32x4.shuffle(m, SIMD.WWZZ);
346 assertEquals(4.0, wwzz.x);
347 assertEquals(4.0, wwzz.y);
348 assertEquals(3.0, wwzz.z);
349 assertEquals(3.0, wwzz.w);
350 var xxyy = SIMD.float32x4.shuffle(m, SIMD.XXYY);
351 assertEquals(1.0, xxyy.x);
352 assertEquals(1.0, xxyy.y);
353 assertEquals(2.0, xxyy.z);
354 assertEquals(2.0, xxyy.w);
355 var yyww = SIMD.float32x4.shuffle(m, SIMD.YYWW);
356 assertEquals(2.0, yyww.x);
357 assertEquals(2.0, yyww.y);
358 assertEquals(4.0, yyww.z);
359 assertEquals(4.0, yyww.w);
364 %OptimizeFunctionOnNextCall(testSIMDShuffle);
367 function testSIMDShuffleMix() {
368 var a = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
369 var b = SIMD.float32x4(5.0, 6.0, 7.0, 8.0);
370 var xxxx = SIMD.float32x4.shuffleMix(a, b, SIMD.XXXX);
371 assertEquals(1.0, xxxx.x);
372 assertEquals(1.0, xxxx.y);
373 assertEquals(5.0, xxxx.z);
374 assertEquals(5.0, xxxx.w);
375 var yyyy = SIMD.float32x4.shuffleMix(a, b, SIMD.YYYY);
376 assertEquals(2.0, yyyy.x);
377 assertEquals(2.0, yyyy.y);
378 assertEquals(6.0, yyyy.z);
379 assertEquals(6.0, yyyy.w);
380 var zzzz = SIMD.float32x4.shuffleMix(a, b, SIMD.ZZZZ);
381 assertEquals(3.0, zzzz.x);
382 assertEquals(3.0, zzzz.y);
383 assertEquals(7.0, zzzz.z);
384 assertEquals(7.0, zzzz.w);
385 var wwww = SIMD.float32x4.shuffleMix(a, b, SIMD.WWWW);
386 assertEquals(4.0, wwww.x);
387 assertEquals(4.0, wwww.y);
388 assertEquals(8.0, wwww.z);
389 assertEquals(8.0, wwww.w);
390 var wzyx = SIMD.float32x4.shuffleMix(a, b, SIMD.WZYX);
391 assertEquals(4.0, wzyx.x);
392 assertEquals(3.0, wzyx.y);
393 assertEquals(6.0, wzyx.z);
394 assertEquals(5.0, wzyx.w);
395 var wwzz = SIMD.float32x4.shuffleMix(a, b, SIMD.WWZZ);
396 assertEquals(4.0, wwzz.x);
397 assertEquals(4.0, wwzz.y);
398 assertEquals(7.0, wwzz.z);
399 assertEquals(7.0, wwzz.w);
400 var xxyy = SIMD.float32x4.shuffleMix(a, b, SIMD.XXYY);
401 assertEquals(1.0, xxyy.x);
402 assertEquals(1.0, xxyy.y);
403 assertEquals(6.0, xxyy.z);
404 assertEquals(6.0, xxyy.w);
405 var yyww = SIMD.float32x4.shuffleMix(a, b, SIMD.YYWW);
406 assertEquals(2.0, yyww.x);
407 assertEquals(2.0, yyww.y);
408 assertEquals(8.0, yyww.z);
409 assertEquals(8.0, yyww.w);
412 testSIMDShuffleMix();
413 testSIMDShuffleMix();
414 %OptimizeFunctionOnNextCall(testSIMDShuffleMix);
415 testSIMDShuffleMix();
417 function testSIMDSetters() {
418 var f = SIMD.float32x4.zero();
419 assertEquals(0.0, f.x);
420 assertEquals(0.0, f.y);
421 assertEquals(0.0, f.z);
422 assertEquals(0.0, f.w);
423 f = SIMD.float32x4.withX(f, 4.0);
424 assertEquals(4.0, f.x);
425 f = SIMD.float32x4.withY(f, 3.0);
426 assertEquals(3.0, f.y);
427 f = SIMD.float32x4.withZ(f, 2.0);
428 assertEquals(2.0, f.z);
429 f = SIMD.float32x4.withW(f, 1.0);
430 assertEquals(1.0, f.w);
431 f = SIMD.float32x4.zero();
436 %OptimizeFunctionOnNextCall(testSIMDSetters);
439 function testSIMDConversion() {
440 var m = SIMD.int32x4(0x3F800000, 0x40000000, 0x40400000, 0x40800000);
441 var n = SIMD.float32x4.fromInt32x4Bits(m);
442 assertEquals(1.0, n.x);
443 assertEquals(2.0, n.y);
444 assertEquals(3.0, n.z);
445 assertEquals(4.0, n.w);
446 n = SIMD.float32x4(5.0, 6.0, 7.0, 8.0);
447 m = SIMD.int32x4.fromFloat32x4Bits(n);
448 assertEquals(0x40A00000, m.x);
449 assertEquals(0x40C00000, m.y);
450 assertEquals(0x40E00000, m.z);
451 assertEquals(0x41000000, m.w);
452 // Flip sign using bit-wise operators.
453 n = SIMD.float32x4(9.0, 10.0, 11.0, 12.0);
454 m = SIMD.int32x4(0x80000000, 0x80000000, 0x80000000, 0x80000000);
455 var nMask = SIMD.int32x4.fromFloat32x4Bits(n);
456 nMask = SIMD.int32x4.xor(nMask, m); // flip sign.
457 n = SIMD.float32x4.fromInt32x4Bits(nMask);
458 assertEquals(-9.0, n.x);
459 assertEquals(-10.0, n.y);
460 assertEquals(-11.0, n.z);
461 assertEquals(-12.0, n.w);
462 nMask = SIMD.int32x4.fromFloat32x4Bits(n);
463 nMask = SIMD.int32x4.xor(nMask, m); // flip sign.
464 n = SIMD.float32x4.fromInt32x4Bits(nMask);
465 assertEquals(9.0, n.x);
466 assertEquals(10.0, n.y);
467 assertEquals(11.0, n.z);
468 assertEquals(12.0, n.w);
471 testSIMDConversion();
472 testSIMDConversion();
473 %OptimizeFunctionOnNextCall(testSIMDConversion);
474 testSIMDConversion();
476 function testSIMDConversion2() {
477 var m = SIMD.int32x4(1, 2, 3, 4);
478 var n = SIMD.float32x4.fromInt32x4(m);
479 assertEquals(1.0, n.x);
480 assertEquals(2.0, n.y);
481 assertEquals(3.0, n.z);
482 assertEquals(4.0, n.w);
483 n = SIMD.float32x4(5.0, 6.0, 7.0, 8.0);
484 m = SIMD.int32x4.fromFloat32x4(n);
485 assertEquals(5, m.x);
486 assertEquals(6, m.y);
487 assertEquals(7, m.z);
488 assertEquals(8, m.w);
491 testSIMDConversion2();
492 testSIMDConversion2();
493 %OptimizeFunctionOnNextCall(testSIMDConversion2);
494 testSIMDConversion2();
497 function testSIMDComparisons() {
498 var m = SIMD.float32x4(1.0, 2.0, 0.1, 0.001);
499 var n = SIMD.float32x4(2.0, 2.0, 0.001, 0.1);
501 cmp = SIMD.float32x4.lessThan(m, n);
502 assertEquals(-1, cmp.x);
503 assertEquals(0x0, cmp.y);
504 assertEquals(0x0, cmp.z);
505 assertEquals(-1, cmp.w);
507 cmp = SIMD.float32x4.lessThanOrEqual(m, n);
508 assertEquals(-1, cmp.x);
509 assertEquals(-1, cmp.y);
510 assertEquals(0x0, cmp.z);
511 assertEquals(-1, cmp.w);
513 cmp = SIMD.float32x4.equal(m, n);
514 assertEquals(0x0, cmp.x);
515 assertEquals(-1, cmp.y);
516 assertEquals(0x0, cmp.z);
517 assertEquals(0x0, cmp.w);
519 cmp = SIMD.float32x4.notEqual(m, n);
520 assertEquals(-1, cmp.x);
521 assertEquals(0x0, cmp.y);
522 assertEquals(-1, cmp.z);
523 assertEquals(-1, cmp.w);
525 cmp = SIMD.float32x4.greaterThanOrEqual(m, n);
526 assertEquals(0x0, cmp.x);
527 assertEquals(-1, cmp.y);
528 assertEquals(-1, cmp.z);
529 assertEquals(0x0, cmp.w);
531 cmp = SIMD.float32x4.greaterThan(m, n);
532 assertEquals(0x0, cmp.x);
533 assertEquals(0x0, cmp.y);
534 assertEquals(-1, cmp.z);
535 assertEquals(0x0, cmp.w);
538 testSIMDComparisons();
539 testSIMDComparisons();
540 %OptimizeFunctionOnNextCall(testSIMDComparisons);
541 testSIMDComparisons();
543 function testSIMDAnd() {
544 var m = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
545 var n = SIMD.float32x4(~1.0, 2.0, 3.0, 4.0);
546 o = SIMD.float32x4.and(m,n); // and
547 assertEquals(0, o.x);
548 assertEquals(2, o.y);
549 assertEquals(3, o.z);
550 assertEquals(4, o.w);
555 %OptimizeFunctionOnNextCall(testSIMDAnd);
558 function testSIMDOr() {
559 var m = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
560 var n = SIMD.float32x4(~1.0, 2.0, 3.0, 4.0);
561 var o = SIMD.float32x4.or(m,n); // or
562 assertEquals(-Infinity, o.x);
563 assertEquals(2.0, o.y);
564 assertEquals(3.0, o.z);
565 assertEquals(4.0, o.w);
570 %OptimizeFunctionOnNextCall(testSIMDOr);
573 function testSIMDXor() {
574 var m = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
575 var n = SIMD.float32x4(~1.0, 2.0, 3.0, 4.0);
576 var o = SIMD.float32x4.xor(m,n); // xor
577 assertEquals(-Infinity, o.x);
578 assertEquals(0x0, o.y);
579 assertEquals(0x0, o.z);
580 assertEquals(0x0, o.w);
585 %OptimizeFunctionOnNextCall(testSIMDXor);
588 function testSIMDNot() {
589 var m = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
590 m = SIMD.float32x4.not(m);
591 m = SIMD.float32x4.not(m);
592 assertEquals(1.0, m.x);
593 assertEquals(2.0, m.y);
594 assertEquals(3.0, m.z);
595 assertEquals(4.0, m.w);
600 %OptimizeFunctionOnNextCall(testSIMDNot);
603 function testSIMDSelect() {
604 var m = SIMD.int32x4.bool(true, true, false, false);
605 var t = SIMD.float32x4(1.0, 2.0, 3.0, 4.0);
606 var f = SIMD.float32x4(5.0, 6.0, 7.0, 8.0);
607 var s = SIMD.float32x4.select(m, t, f);
608 assertEquals(1.0, s.x);
609 assertEquals(2.0, s.y);
610 assertEquals(7.0, s.z);
611 assertEquals(8.0, s.w);
616 %OptimizeFunctionOnNextCall(testSIMDSelect);
620 function testFloat32x4ArrayBasic() {
621 var a = new Float32x4Array(1);
622 assertEquals(1, a.length);
623 assertEquals(16, a.byteLength);
624 assertEquals(16, a.BYTES_PER_ELEMENT);
625 assertEquals(16, Float32x4Array.BYTES_PER_ELEMENT);
626 assertEquals(0, a.byteOffset);
627 assertTrue(undefined != a.buffer);
628 var b = new Float32x4Array(4);
629 assertEquals(4, b.length);
630 assertEquals(64, b.byteLength);
631 assertEquals(16, b.BYTES_PER_ELEMENT);
632 assertEquals(16, Float32x4Array.BYTES_PER_ELEMENT);
633 assertEquals(0, b.byteOffset);
634 assertTrue(undefined != b.buffer);
637 testFloat32x4ArrayBasic();
639 function testFloat32x4ArrayGetAndSet() {
640 var a = new Float32x4Array(4);
641 a[0] = SIMD.float32x4(1, 2, 3, 4);
642 a[1] = SIMD.float32x4(5, 6, 7, 8);
643 a[2] = SIMD.float32x4(9, 10, 11, 12);
644 a[3] = SIMD.float32x4(13, 14, 15, 16);
645 assertEquals(a[0].x, 1);
646 assertEquals(a[0].y, 2);
647 assertEquals(a[0].z, 3);
648 assertEquals(a[0].w, 4);
650 assertEquals(a[1].x, 5);
651 assertEquals(a[1].y, 6);
652 assertEquals(a[1].z, 7);
653 assertEquals(a[1].w, 8);
655 assertEquals(a[2].x, 9);
656 assertEquals(a[2].y, 10);
657 assertEquals(a[2].z, 11);
658 assertEquals(a[2].w, 12);
660 assertEquals(a[3].x, 13);
661 assertEquals(a[3].y, 14);
662 assertEquals(a[3].z, 15);
663 assertEquals(a[3].w, 16);
665 var b = new Float32x4Array(4);
666 b.setAt(0,SIMD.float32x4(1, 2, 3, 4));
667 b.setAt(1,SIMD.float32x4(5, 6, 7, 8));
668 b.setAt(2,SIMD.float32x4(9, 10, 11, 12));
669 b.setAt(3,SIMD.float32x4(13, 14, 15, 16));
671 assertEquals(b.getAt(0).x, 1);
672 assertEquals(b.getAt(0).y, 2);
673 assertEquals(b.getAt(0).z, 3);
674 assertEquals(b.getAt(0).w, 4);
676 assertEquals(b.getAt(1).x, 5);
677 assertEquals(b.getAt(1).y, 6);
678 assertEquals(b.getAt(1).z, 7);
679 assertEquals(b.getAt(1).w, 8);
681 assertEquals(b.getAt(2).x, 9);
682 assertEquals(b.getAt(2).y, 10);
683 assertEquals(b.getAt(2).z, 11);
684 assertEquals(b.getAt(2).w, 12);
686 assertEquals(b.getAt(3).x, 13);
687 assertEquals(b.getAt(3).y, 14);
688 assertEquals(b.getAt(3).z, 15);
689 assertEquals(b.getAt(3).w, 16);
692 testFloat32x4ArrayGetAndSet();
693 testFloat32x4ArrayGetAndSet();
694 %OptimizeFunctionOnNextCall(testFloat32x4ArrayGetAndSet);
695 testFloat32x4ArrayGetAndSet();
697 function testFloat32x4ArraySwap() {
698 var a = new Float32x4Array(4);
699 a[0] = SIMD.float32x4(1, 2, 3, 4);
700 a[1] = SIMD.float32x4(5, 6, 7, 8);
701 a[2] = SIMD.float32x4(9, 10, 11, 12);
702 a[3] = SIMD.float32x4(13, 14, 15, 16);
704 // Swap element 0 and element 3
709 assertEquals(a[3].x, 1);
710 assertEquals(a[3].y, 2);
711 assertEquals(a[3].z, 3);
712 assertEquals(a[3].w, 4);
714 assertEquals(a[1].x, 5);
715 assertEquals(a[1].y, 6);
716 assertEquals(a[1].z, 7);
717 assertEquals(a[1].w, 8);
719 assertEquals(a[2].x, 9);
720 assertEquals(a[2].y, 10);
721 assertEquals(a[2].z, 11);
722 assertEquals(a[2].w, 12);
724 assertEquals(a[0].x, 13);
725 assertEquals(a[0].y, 14);
726 assertEquals(a[0].z, 15);
727 assertEquals(a[0].w, 16);
730 testFloat32x4ArraySwap();
732 function testFloat32x4ArrayCopy() {
733 var a = new Float32x4Array(4);
734 a[0] = SIMD.float32x4(1, 2, 3, 4);
735 a[1] = SIMD.float32x4(5, 6, 7, 8);
736 a[2] = SIMD.float32x4(9, 10, 11, 12);
737 a[3] = SIMD.float32x4(13, 14, 15, 16);
738 var b = new Float32x4Array(a);
739 assertEquals(a[0].x, b[0].x);
740 assertEquals(a[0].y, b[0].y);
741 assertEquals(a[0].z, b[0].z);
742 assertEquals(a[0].w, b[0].w);
744 assertEquals(a[1].x, b[1].x);
745 assertEquals(a[1].y, b[1].y);
746 assertEquals(a[1].z, b[1].z);
747 assertEquals(a[1].w, b[1].w);
749 assertEquals(a[2].x, b[2].x);
750 assertEquals(a[2].y, b[2].y);
751 assertEquals(a[2].z, b[2].z);
752 assertEquals(a[2].w, b[2].w);
754 assertEquals(a[3].x, b[3].x);
755 assertEquals(a[3].y, b[3].y);
756 assertEquals(a[3].z, b[3].z);
757 assertEquals(a[3].w, b[3].w);
759 a[2] = SIMD.float32x4(17, 18, 19, 20);
761 assertEquals(a[2].x, 17);
762 assertEquals(a[2].y, 18);
763 assertEquals(a[2].z, 19);
764 assertEquals(a[2].w, 20);
766 assertTrue(a[2].x != b[2].x);
767 assertTrue(a[2].y != b[2].y);
768 assertTrue(a[2].z != b[2].z);
769 assertTrue(a[2].w != b[2].w);
772 testFloat32x4ArrayCopy();
774 function testFloat32x4ArrayViewBasic() {
775 var a = new Float32Array(8);
776 // view with no offset.
777 var b = new Float32x4Array(a.buffer, 0);
779 var c = new Float32x4Array(a.buffer, 16);
780 // view with no offset but shorter than original list.
781 var d = new Float32x4Array(a.buffer, 0, 1);
782 assertEquals(a.length, 8);
783 assertEquals(b.length, 2);
784 assertEquals(c.length, 1);
785 assertEquals(d.length, 1);
786 assertEquals(a.byteLength, 32);
787 assertEquals(b.byteLength, 32);
788 assertEquals(c.byteLength, 16);
789 assertEquals(d.byteLength, 16)
790 assertEquals(a.byteOffset, 0);
791 assertEquals(b.byteOffset, 0);
792 assertEquals(c.byteOffset, 16);
793 assertEquals(d.byteOffset, 0);
796 testFloat32x4ArrayViewBasic();
798 function testFloat32x4ArrayViewValues() {
799 var a = new Float32Array(8);
800 var b = new Float32x4Array(a.buffer, 0);
801 var c = new Float32x4Array(a.buffer, 16);
802 var d = new Float32x4Array(a.buffer, 0, 1);
804 for (var i = 0; i < b.length; i++) {
805 assertEquals(0.0, b[i].x);
806 assertEquals(0.0, b[i].y);
807 assertEquals(0.0, b[i].z);
808 assertEquals(0.0, b[i].w);
810 for (var i = 0; i < c.length; i++) {
811 assertEquals(0.0, c[i].x);
812 assertEquals(0.0, c[i].y);
813 assertEquals(0.0, c[i].z);
814 assertEquals(0.0, c[i].w);
816 for (var i = 0; i < d.length; i++) {
817 assertEquals(0.0, d[i].x);
818 assertEquals(0.0, d[i].y);
819 assertEquals(0.0, d[i].z);
820 assertEquals(0.0, d[i].w);
822 for (var i = 0; i < a.length; i++) {
825 for (var i = 0; i < b.length; i++) {
826 assertTrue(0.0 != b[i].x);
827 assertTrue(0.0 != b[i].y);
828 assertTrue(0.0 != b[i].z);
829 assertTrue(0.0 != b[i].w);
831 for (var i = 0; i < c.length; i++) {
832 assertTrue(0.0 != c[i].x);
833 assertTrue(0.0 != c[i].y);
834 assertTrue(0.0 != c[i].z);
835 assertTrue(0.0 != c[i].w);
837 for (var i = 0; i < d.length; i++) {
838 assertTrue(0.0 != d[i].x);
839 assertTrue(0.0 != d[i].y);
840 assertTrue(0.0 != d[i].z);
841 assertTrue(0.0 != d[i].w);
843 assertEquals(start+0, b[0].x);
844 assertEquals(start+1, b[0].y);
845 assertEquals(start+2, b[0].z);
846 assertEquals(start+3, b[0].w);
847 assertEquals(start+4, b[1].x);
848 assertEquals(start+5, b[1].y);
849 assertEquals(start+6, b[1].z);
850 assertEquals(start+7, b[1].w);
852 assertEquals(start+4, c[0].x);
853 assertEquals(start+5, c[0].y);
854 assertEquals(start+6, c[0].z);
855 assertEquals(start+7, c[0].w);
857 assertEquals(start+0, d[0].x);
858 assertEquals(start+1, d[0].y);
859 assertEquals(start+2, d[0].z);
860 assertEquals(start+3, d[0].w);
863 testFloat32x4ArrayViewValues();
865 function testViewOnFloat32x4Array() {
866 var a = new Float32x4Array(4);
867 a[0] = SIMD.float32x4(1, 2, 3, 4);
868 a[1] = SIMD.float32x4(5, 6, 7, 8);
869 a[2] = SIMD.float32x4(9, 10, 11, 12);
870 a[3] = SIMD.float32x4(13, 14, 15, 16);
871 assertEquals(a[0].x, 1);
872 assertEquals(a[0].y, 2);
873 assertEquals(a[0].z, 3);
874 assertEquals(a[0].w, 4);
876 assertEquals(a[1].x, 5);
877 assertEquals(a[1].y, 6);
878 assertEquals(a[1].z, 7);
879 assertEquals(a[1].w, 8);
881 assertEquals(a[2].x, 9);
882 assertEquals(a[2].y, 10);
883 assertEquals(a[2].z, 11);
884 assertEquals(a[2].w, 12);
886 assertEquals(a[3].x, 13);
887 assertEquals(a[3].y, 14);
888 assertEquals(a[3].z, 15);
889 assertEquals(a[3].w, 16);
892 var b = new Float32Array(a.buffer);
893 assertEquals(b.length, 16);
894 assertEquals(b.byteLength, 64);
898 // Observe changes in "a"
899 assertEquals(a[0].x, 1);
900 assertEquals(a[0].y, 2);
901 assertEquals(a[0].z, 99);
902 assertEquals(a[0].w, 4);
904 assertEquals(a[1].x, 5);
905 assertEquals(a[1].y, 6);
906 assertEquals(a[1].z, 1);
907 assertEquals(a[1].w, 8);
909 assertEquals(a[2].x, 9);
910 assertEquals(a[2].y, 10);
911 assertEquals(a[2].z, 11);
912 assertEquals(a[2].w, 12);
914 assertEquals(a[3].x, 13);
915 assertEquals(a[3].y, 14);
916 assertEquals(a[3].z, 15);
917 assertEquals(a[3].w, 16);
920 testViewOnFloat32x4Array();
922 function testArrayOfFloat32x4() {
924 var a4 = new Float32x4Array(2);
925 for (var i = 0; i < a4.length; i++) {
926 a[i] = SIMD.float32x4(i, i + 1, i + 2, i + 3);
927 a4[i] = SIMD.float32x4(i, i + 1, i + 2, i + 3);
930 for (var i = 0; i < a4.length; i++) {
931 assertEquals(a[i].x, a4[i].x);
932 assertEquals(a[i].y, a4[i].y);
933 assertEquals(a[i].z, a4[i].z);
934 assertEquals(a[i].w, a4[i].w);
938 testArrayOfFloat32x4();